Annuler en Git : restore, reset, revert et reflog

Annuler en Git dépend de l'endroit où se trouve l'erreur : git restore annule une modification pas encore commitée, git commit --amend corrige le dernier commit, git reset supprime des commits qui n'ont pas été poussés, et git revert annule un commit déjà partagé en créant un commit inverse. Ce chapitre donne la bonne commande pour chaque situation, explique les trois modes de git reset et montre comment git reflog récupère presque tout, même après une fausse manœuvre. Il se termine par git stash, qui met ton travail de côté sans commit.

La question à se poser d'abord

Avant de taper une commande d'annulation, situe ton erreur. Elle est forcément dans l'un de ces quatre états :

Jeter des modifications non commitées avec git restore

Tu as modifié app.js, rien ne marche, et tu veux revenir à la version du dernier commit :

git restore app.js

Les variantes :

git restore ne touche pas aux fichiers non suivis. Pour supprimer les fichiers non suivis d'un dossier (des fichiers générés, par exemple), git clean -n affiche ce qui serait supprimé, puis git clean -f supprime. Avec -d, les dossiers non suivis aussi.

git switch et git restore remplacent git checkout

Dans des tutoriels plus anciens, tu croiseras git checkout partout. Cette commande faisait deux métiers très différents : changer de branche et écraser des fichiers. Une faute de frappe dans un nom de branche pouvait transformer un changement de branche en perte de modifications. Depuis la version 2.23 de Git (2019), deux commandes séparent ces métiers : git switch pour les branches, git restore pour les fichiers. git checkout fonctionne toujours, mais utilise les nouvelles commandes.

Modifier le dernier commit avec amend

Tu viens de commiter et tu remarques une faute dans le message, ou un fichier oublié.

# Corriger le message du dernier commit
git commit --amend -m "Ajoute la route GET /notes avec pagination"

# Ajouter un fichier oublié sans changer le message
git add routes/notes.test.js
git commit --amend --no-edit

--amend ne modifie pas le commit : il en crée un nouveau, avec une nouvelle empreinte, qui remplace l'ancien au bout de la branche. Si l'ancien avait été poussé, ton historique local et celui de GitHub divergent, et le prochain git push est refusé. Réserve donc --amend aux commits non poussés.

Faire reculer la branche avec git reset

git reset <commit> déplace la branche courante vers un commit plus ancien. Les commits qui suivaient disparaissent de la branche. Ce qui arrive à leurs modifications dépend du mode :

Chaque mode a son usage :

• --soft sert à refaire un commit. Tu as fait trois petits commits « wip » sur ta branche, non poussés : git reset --soft HEAD~3 les défait en gardant tout préparé, puis un seul git commit les remplace par un commit propre.
• --mixed sert à revenir avant le commit pour le recomposer : tu as tout commité d'un bloc, tu veux finalement deux commits. git reset HEAD~1, puis deux séries de git add et git commit.
• --hard sert à tout jeter pour revenir à un état propre : ton essai est raté, tu veux retrouver exactement le commit d'avant, ou aligner ta branche sur celle du serveur avec git reset --hard origin/main.

Le scénario « j'ai commité sur main au lieu de ma branche », sans avoir poussé :

git switch -c feature/export     # la nouvelle branche emporte le commit
git switch main
git reset --hard HEAD~1          # main revient avant le commit

Le commit n'est pas perdu : il vit sur feature/export. Pense toujours à faire la sauvegarde (une branche, un stash) avant un --hard.

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

Le commit 8d3e1a2 a introduit un bug et il est déjà sur GitHub. Hugo l'a récupéré. Réécrire l'historique casserait son dépôt. git revert crée un nouveau commit qui fait exactement l'inverse :

git revert 8d3e1a2

[main 5c71f40] Revert "Arrondit les indemnités au centime supérieur"
 1 file changed, 1 insertion(+), 1 deletion(-)

Git ouvre l'éditeur pour le message, prérempli avec Revert "…" et une ligne This reverts commit 8d3e1a2…. Complète-le avec la raison de l'annulation. Le commit d'origine reste dans l'historique, suivi de son annulation : on voit ce qui s'est passé, et le prochain git push passe normalement.

Si le code a évolué depuis le commit annulé, git revert peut rencontrer un conflit : tu le résous comme un conflit de fusion (chapitre 6), puis git revert --continue.

Reset ou revert ?

Si tu as fait un reset sur des commits déjà poussés, GitHub refuse ton push (non-fast-forward). La tentation est git push --force, qui écrase l'historique distant : sur une branche partagée, tu supprimes les commits que tes coéquipiers ont poussés entre-temps. Si tu dois vraiment forcer sur ta propre branche, utilise git push --force-with-lease, qui refuse d'écraser des commits que tu n'as pas encore vus (chapitre 7).

Retrouver un commit perdu avec git reflog

Tu as fait un git reset --hard HEAD~2 de trop, et deux heures de travail commité semblent avoir disparu. Pas de panique : Git note dans le reflog chaque déplacement de HEAD, pendant 90 jours par défaut (30 jours pour les commits qui ne sont plus sur aucune branche).

git reflog

3759676 (HEAD -> main) HEAD@{0}: reset: moving to HEAD~2
12607ec HEAD@{1}: commit: Ajoute le filtre par date
40f61f6 HEAD@{2}: commit: Documente l'installation
3759676 (HEAD -> main) HEAD@{3}: commit: Ajoute l'export CSV

On lit de haut en bas, du plus récent au plus ancien. Avant le reset, HEAD était sur 12607ec. Pour y revenir :

git reset --hard 12607ec

Ou, plus prudent, crée une branche sur ce commit pour l'examiner : git branch sauvetage 12607ec. Le reflog retrouve aussi une branche supprimée par erreur ou l'état d'avant un rebase raté.

Mettre son travail de côté avec git stash

Tu es au milieu d'une modification, pas assez avancée pour un commit, et tu dois changer de branche pour corriger un bug urgent. Git refuse si tes modifications entrent en conflit avec l'autre branche :

error: Your local changes to the following files would be overwritten by checkout:
	src/frais.js
Please commit your changes or stash them before you switch branches.
Aborting

git stash range tes modifications non commitées dans une pile et remet ton répertoire de travail dans l'état du dernier commit :

git stash push -m "formulaire à moitié fait"
git switch main
# ... tu corriges le bug, tu commites, tu pousses ...
git switch feature/formulaire
git stash pop

Si git stash pop rencontre un conflit, l'entrée reste dans la pile : tu résous le conflit, puis tu la supprimes avec git stash drop. Ne laisse pas la pile grossir : un stash oublié depuis trois semaines, sans message, est presque impossible à reprendre. Au-delà de quelques heures, un commit sur une branche de travail vaut mieux.

Exercices

9b4e2d1 (HEAD -> feature/formulaire) HEAD@{0}: reset: moving to HEAD~3
61c0f8a HEAD@{1}: commit: Valide le montant côté client
2ad93e7 HEAD@{2}: commit: Ajoute le champ date
d7f15b0 HEAD@{3}: commit: Ajoute le champ motif
9b4e2d1 (HEAD -> feature/formulaire) HEAD@{4}: commit: Crée le composant Formulaire