Un commit envoyé trop vite, avec un fichier oublié, un message plein de fautes ou une modification qui casse le site, arrive à tout le monde, et plus encore quand on débute. Annuler un commit Git est presque toujours possible, à condition d'utiliser la commande qui correspond à votre situation.

Toute la difficulté tient en une question : ce commit est-il resté sur votre ordinateur, ou l'avez-vous déjà envoyé en ligne ? Selon la réponse, une même commande peut corriger proprement votre erreur ou effacer du travail que vous vouliez garder.

Et si une commande a déjà effacé un commit par erreur, Git permet en général de le retrouver pendant 30 jours.

En résumé

Si le commit n'a pas encore été envoyé en ligne, la commande git reset --soft HEAD~1 l'annule en gardant vos modifications, prêtes à être corrigées. S'il a déjà été envoyé avec un push, utilisez git revert puis git push : Git crée un nouveau commit qui défait le précédent, sans réécrire l'historique que d'autres ont déjà récupéré.

Ce que sont un commit et un push, et pourquoi la différence compte

Git est un logiciel qui garde l'historique des fichiers d'un projet. Chaque fois que vous le lui demandez, il enregistre l'état de vos fichiers à cet instant, et cet enregistrement s'appelle un commit. Chaque commit porte un message qui décrit ce qui a changé, ainsi qu'un identifiant unique fait de chiffres et de lettres, comme a1b2c3d, que l'on appelle le hash.

Ces commits s'accumulent d'abord dans le dossier de votre projet, sur votre ordinateur. Ce dossier suivi par Git s'appelle un dépôt, et la suite de commits qu'il contient forme une branche, dont la principale se nomme le plus souvent main. Le push est l'étape suivante : la commande git push envoie vos nouveaux commits vers une copie de votre dépôt hébergée en ligne, en général sur GitHub, où d'autres personnes, ou le service qui publie votre site, viennent les récupérer.

Schéma en trois étapes : les commits restent dans le dépôt sur votre ordinateur, git push les envoie vers la copie en ligne sur GitHub, où d’autres personnes les récupèrent.
Illustration : Fiindt

Tant qu'un commit n'a pas été poussé, vous êtes donc le seul à le connaître, et vous pouvez le modifier ou le supprimer sans gêner personne. Une fois poussé, il fait partie d'un historique partagé. Le faire disparaître oblige alors à réécrire cet historique en ligne, ce qui peut casser le travail de ceux qui l'ont déjà récupéré. C'est la raison pour laquelle la documentation de GitLab sur l'annulation des changements demande de ne jamais modifier l'historique d'une branche partagée. Une exception toutefois : si le commit contient un mot de passe ou une clé d'API, un revert ne suffit pas, car le secret reste lisible dans l'historique. Changez d'abord ce mot de passe ou cette clé. Suivez ensuite le guide de GitHub pour retirer des données sensibles d'un dépôt.

Les commandes qui suivent se tapent dans un terminal, c'est-à-dire la fenêtre où l'on écrit des instructions à l'ordinateur sous forme de texte, ouverte dans le dossier de votre projet. Si vous préférez cliquer, les mêmes opérations existent dans deux logiciels courants, présentés plus bas.

Savoir si votre commit a déjà été poussé

Avant de choisir une commande, vérifiez donc où se trouve le commit à annuler. Le moyen le plus simple consiste à ouvrir la page de votre dépôt sur GitHub et à afficher la liste de ses commits : si le vôtre y figure, avec son message, il a été poussé.

Dans le terminal, la commande git status donne la réponse dès ses premières lignes. Si elle affiche « Your branch is ahead of 'origin/main' by 1 commit », votre dernier commit n'est pas encore en ligne. Si elle affiche « Your branch is up to date with 'origin/main' », il a déjà été poussé. La commande git log --oneline, elle, affiche vos commits, un par ligne, du plus récent au plus ancien, avec leur identifiant court et leur message. Notez l'identifiant du commit à annuler, car la méthode prévue pour les commits déjà poussés en aura besoin.

Annuler un commit qui n'a pas encore été poussé

Si le commit n'existe que sur votre ordinateur, vous avez trois possibilités, qui se distinguent par ce qu'elles font de vos modifications. Le tableau suivant vous aide à repérer la vôtre avant de lire le détail.

Votre situation Commande Ce que deviennent vos modifications
Message à corriger ou fichier oublié git commit --amend Intégrées au commit corrigé
Commit à défaire, travail à garder git reset --soft HEAD~1 Conservées, prêtes à être recommitées
Commit et modifications à jeter git reset --hard HEAD~1 Effacées de vos fichiers

Corriger le message ou ajouter un fichier oublié avec git commit --amend

Souvent, l'erreur n'a rien de grave : le commit est presque bon, mais il lui manque un fichier ou son message est mal écrit. Ajoutez d'abord le fichier oublié avec git add nom-du-fichier, qui le prépare pour le prochain commit, puis tapez git commit --amend -m "Votre nouveau message".

D'après la documentation de git commit, Git remplace alors votre dernier commit par un nouveau commit, qui contient le fichier ajouté et le message corrigé. Ce remplacement réécrit l'historique, et c'est pourquoi le livre officiel Pro Git demande de ne corriger ainsi que des commits restés locaux.

Défaire le commit en gardant votre travail avec git reset --soft HEAD~1

Quand vous voulez vraiment défaire le commit, mais sans perdre ce que vous aviez écrit, la commande à utiliser est git reset --soft HEAD~1. Dans cette commande, HEAD désigne le commit sur lequel repose votre travail actuel, c'est-à-dire en pratique votre dernier commit, et HEAD~1 désigne celui qui le précède, selon la page de Git consacrée à la façon de désigner un commit.

La commande ramène donc votre branche un commit en arrière sans toucher à vos fichiers. La documentation de git reset précise qu'avec l'option --soft, vos fichiers et vos modifications préparées restent tels quels. Vous retrouvez ainsi votre travail exactement comme juste avant le commit, et vous pouvez le compléter puis le recommiter.

Si vous tapez git reset HEAD~1 sans option, Git utilise un mode intermédiaire appelé --mixed. Vos fichiers restent intacts là aussi, mais plus rien n'est préparé, et il vous faudra refaire git add avant le prochain commit.

Effacer le commit et les modifications avec git reset --hard HEAD~1

La troisième option, git reset --hard HEAD~1, est la seule qui détruit quelque chose. Elle remet tous les fichiers suivis par Git dans leur version au commit précédent, ce qui efface le commit et tout ce qu'il contenait de vos fichiers. Seuls les fichiers que vous n'avez jamais ajoutés avec git add restent en place.

Le danger vient surtout de ce qu'elle emporte au passage. Toute modification que vous n'aviez pas encore commitée disparaît en même temps, et le livre Pro Git rappelle que ce qui est perdu avant d'avoir été commité ne peut pas être récupéré par Git. Avant de lancer cette commande, tapez donc git status, qui liste les fichiers modifiés depuis le dernier commit, et assurez-vous que rien dans cette liste ne mérite d'être gardé.

Déplacer un commit fait sur la mauvaise branche

Si vous avez commité sur main au lieu d'une branche de travail, et que ce commit n'est pas poussé, vous pouvez le déplacer plutôt que le défaire. Tapez git branch nouvelle-branche pour créer une branche qui contient ce commit. Tapez ensuite git reset --hard HEAD~1 pour retirer le commit de main, puis git switch nouvelle-branche pour reprendre votre travail sur la nouvelle branche. La documentation de git reset donne cet enchaînement en exemple. Comme pour tout reset --hard, lancez d'abord git status pour vérifier que vous n'avez aucune modification non commitée.

Annuler un commit déjà poussé avec git revert

Une fois le commit en ligne, la méthode change : au lieu d'effacer le commit, vous en ajoutez un nouveau qui fait exactement l'inverse. C'est le rôle de git revert, qui selon sa documentation officielle enregistre de nouveaux commits pour inverser l'effet de commits précédents. L'historique partagé n'est pas réécrit, et la documentation de VS Code sur les commits souligne que cette méthode ne demande aucun push forcé.

Schéma en trois étapes : le commit déjà en ligne, puis git revert qui crée un commit d’annulation, puis git push qui l’envoie sur GitHub sans réécrire l’historique.
Illustration : Fiindt

La commande exige toutefois que vos fichiers ne contiennent aucune modification en cours. Commitez d'abord ce que vous étiez en train de faire, puis suivez ces trois étapes :

  1. Tapez git log --oneline et copiez l'identifiant du commit à annuler.
  2. Tapez git revert --no-edit a1b2c3d, en remplaçant a1b2c3d par cet identifiant.
  3. Vérifiez que vos fichiers sont revenus à l'état voulu, puis tapez git push pour envoyer le commit d'annulation en ligne.

L'option --no-edit évite un piège dans lequel tombent beaucoup de débutants. Sans elle, Git ouvre un éditeur de texte pour vous laisser modifier le message du commit d'annulation, et cet éditeur est souvent Vim, qui ne se ferme pas avec les raccourcis habituels. Si cela vous arrive, appuyez sur Échap, tapez :wq puis Entrée : le message proposé est accepté et la commande se termine.

Il arrive aussi que Git signale un conflit, parce que les lignes à défaire ont été modifiées depuis par un autre commit et qu'il ne sait pas trancher seul. Dans ce cas, corrigez les fichiers qu'il indique, préparez-les avec git add, puis tapez git revert --continue. Vous pouvez aussi tout abandonner avec git revert --abort, qui remet vos fichiers dans l'état d'avant la commande.

Pourquoi le push forcé n'est pas une bonne solution pour débuter

Une autre méthode est souvent proposée pour les commits déjà poussés : les effacer avec git reset, puis renvoyer l'historique modifié avec git push --force. Elle fonctionne techniquement, mais elle comporte des risques qu'un débutant mesure mal.

Après un reset, un simple git push est en effet refusé, parce que votre historique ne prolonge plus celui qui est en ligne. L'option --force supprime cette vérification, et la documentation de git push avertit qu'elle peut faire perdre des commits au dépôt en ligne. Si quelqu'un a poussé son travail entre-temps, ce travail disparaît. La variante --force-with-lease limite ce risque, puisqu'elle refuse d'écraser la copie en ligne si celle-ci a changé depuis votre dernière récupération.

Branches protégées

Un push forcé peut être tout simplement bloqué. GitHub bloque par défaut les push forcés sur les branches protégées, c'est-à-dire les branches pour lesquelles le propriétaire du dépôt a activé des règles de sécurité. Pour un commit déjà en ligne, git revert reste donc la voie la plus sûre, même si vous travaillez seul.

Annuler un commit sans terminal, dans VS Code ou GitHub Desktop

Si vous travaillez dans un éditeur de code, vous n'avez pas forcément besoin de taper ces commandes. Deux logiciels très répandus proposent les mêmes opérations dans leurs menus, avec la même frontière entre commit local et commit poussé.

Dans VS Code

VS Code propose une action « Undo Last Commit » dans sa vue Source Control, accessible par le menu More Actions (les trois points), puis Commit. Elle retire le dernier commit de votre historique local et garde ses modifications préparées, ce qui correspond à un git reset --soft HEAD~1.

La documentation de VS Code précise qu'il ne faut pas utiliser cette action sur un historique partagé. Pour un commit déjà poussé, elle renvoie vers la commande git revert --no-edit présentée plus haut, à taper dans le terminal intégré à l'éditeur.

Dans GitHub Desktop

GitHub Desktop distingue lui aussi les deux cas. Pour un commit pas encore poussé, le guide d'annulation de GitHub Desktop indique d'ouvrir l'onglet Changes, dans la barre de gauche, puis de cliquer sur le bouton Undo en bas de cette barre.

Bas de l'onglet Changes de GitHub Desktop : sous le bouton Commit to main, le dernier commit « Revise search function » est affiché avec la mention Committed just now et un bouton Undo encadré en orange
Image : GitHub Docs, CC BY 4.0

Pour un commit déjà poussé, ouvrez l'onglet History, faites un clic droit sur le commit et choisissez « Revert Changes in Commit ». La documentation de GitHub Desktop sur le revert rappelle que ce revert est lui-même un commit, qu'il vous reste donc à pousser comme n'importe quel autre.

Récupérer un commit effacé par erreur avec git reflog

Si vous avez lancé un git reset --hard et que vous le regrettez, tout n'est pas perdu pour ce qui avait été commité. Git tient en effet un journal, appelé reflog, qui enregistre selon la documentation de git reflog chaque déplacement de vos branches dans votre dépôt local.

Tapez git reflog : chaque ligne montre un état passé de votre projet, avec son identifiant et l'action qui l'a produit. Repérez la ligne qui précède votre reset, copiez son identifiant, puis tapez git reset --hard suivi de cet identifiant pour revenir à cet état.

Par exemple, après un git reset --hard HEAD~1, la commande affiche des lignes de ce type :

9f8e7d6 HEAD@{0}: reset: moving to HEAD~1
e4f5a6b HEAD@{1}: commit: Ajoute la page contact

La ligne HEAD@{1} correspond à l'état d'avant le reset. Tapez alors git reset --hard e4f5a6b, et votre commit « Ajoute la page contact » revient, avec ses fichiers.

Schéma en quatre étapes : le commit e4f5a6b, son effacement par git reset --hard HEAD~1, la ligne HEAD@{1} retrouvée avec git reflog, puis le commit revenu avec git reset --hard e4f5a6b.
Illustration : Fiindt
Les limites du reflog

Le reflog a trois limites. Il n'existe que sur votre ordinateur. La trace d'un commit qui n'appartient plus à aucune branche n'y est gardée, par défaut, que 30 jours, selon la documentation de git reflog. Surtout, il ne contient que des commits, si bien que les modifications jamais commitées effacées par le reset ne s'y trouvent pas.

Quelle commande choisir pour annuler un commit Git : le récapitulatif

Avant de taper quoi que ce soit, lancez git status pour savoir si le commit est en ligne. S'il ne l'est pas, git reset --soft HEAD~1 le défait en gardant votre travail. S'il l'est, tapez git revert --no-edit suivi de son identifiant, puis git push. Et avant tout git reset --hard, relisez la liste affichée par git status.