Annuler et corriger des commits Git

Vous avez fait une erreur sur un commit et vous cherchez comment corriger ? Ce guide part de ce que vous observez (le symptôme) et vous mène directement à la solution. Que le commit soit local ou déjà poussé, qu’il s’agisse d’une faute de frappe ou d’un commit entier à annuler, Git a une commande adaptée. Vous repartirez avec un arbre de décision clair pour ne plus hésiter.

Prérequis : Annuler des modifications et Git reset démystifié.

Ce que vous allez apprendre

Choisir entre --amend, reset et revert selon la situation
Corriger un message de commit sans modifier le contenu
Annuler un commit local proprement sans laisser de trace
Inverser un commit publié avec git revert sans réécrire l’historique
Récupérer des commits après un reset --hard accidentel

Arbre de décision : quelle commande utiliser ?

Avant de taper quoi que ce soit, posez-vous deux questions : le commit est-il déjà poussé ? et que voulez-vous corriger ?

Mon commit a un problème
├── Le commit est LOCAL (pas encore poussé)
│   ├── Juste le message → git commit --amend
│   ├── Fichier oublié   → git add + git commit --amend
│   ├── Annuler 1 commit → git reset --soft HEAD~1
│   └── Annuler N commits → git reset --soft HEAD~N
│
├── Le commit est PUBLIÉ (déjà poussé)
│   ├── Annuler 1 commit → git revert <SHA>
│   ├── Annuler un merge → git revert -m 1 <SHA>
│   └── Annuler plusieurs → git revert <SHA1>..<SHA2>
│
└── J'ai fait reset --hard par erreur
    └── git reflog + git reset --hard <SHA>

La règle est simple : --amend et reset pour le local, revert pour le publié. Le reflog est votre filet de sécurité.

« Mon message de commit est faux »

Vous venez de commiter et le message contient une faute ou ne décrit pas bien la modification :

git commit --amend -m "feat: ajouter la validation du formulaire"

Vérification :

git log --oneline -1

Le SHA du commit change — c’est un nouveau commit qui remplace l’ancien. Le contenu des fichiers reste identique.

« J’ai oublié un fichier dans mon commit »

Vous avez commité, puis vous réalisez qu’un fichier manque :

Ajoutez le fichier oublié au staging
Fenêtre de terminal
```
git add fichier-oublie.ts
```
Intégrez-le au dernier commit
Fenêtre de terminal
```
git commit --amend --no-edit
```

Le --no-edit conserve le message original. Le résultat est un seul commit contenant toutes les modifications.

Pour retirer un fichier commité par erreur (sans le supprimer du disque) :

git restore --staged fichier-secret.env
git commit --amend --no-edit

« Je veux annuler mon dernier commit local »

Le commit n’a pas été poussé et vous voulez le défaire. Choisissez le mode de reset selon ce que vous voulez garder :

Mode	Commande	Modifications	Staging
Soft	`git reset --soft HEAD~1`	Conservées	Conservées (prêtes à recommiter)
Mixed (défaut)	`git reset HEAD~1`	Conservées	Vidé (à re-ajouter avec `git add`)
Hard	`git reset --hard HEAD~1`	Supprimées	Vidé

Le cas le plus courant est --soft — il annule le commit mais garde tout en staging, prêt à être recommité différemment :

git reset --soft HEAD~1

Vérification :

git status
# Les fichiers sont dans "Changes to be committed"

Pour annuler les 3 derniers commits et les regrouper en un :

git reset --soft HEAD~3
git commit -m "feat: fonctionnalité complète"

« Je veux annuler un commit déjà poussé »

Le commit est sur le remote et d’autres développeurs l’ont peut-être récupéré. On ne réécrit pas l’historique partagé — on crée un commit inverse avec git revert :

git revert a1b2c3d

Git ouvre l’éditeur pour le message (par défaut : Revert "Message original"). Sauvegardez pour créer le commit de revert.

Vérification :

git log --oneline -3

Sortie attendue :

f8e7d6c Revert "feat: ajouter le cache"
a1b2c3d feat: ajouter le cache
9a8b7c6 fix: corriger le timeout

Le commit a1b2c3d reste dans l’historique — revert ne l’efface pas, il applique les modifications inverses dans un nouveau commit.

Revert sans ouvrir l’éditeur

git revert --no-edit a1b2c3d

Revert de plusieurs commits

Pour annuler une série de commits (du plus ancien au plus récent) :

git revert --no-edit a1b2c3d..e5f6a7b

Cette commande crée autant de commits de revert que de commits dans la plage. Si la plage contient 5 commits, vous aurez 5 nouveaux commits Revert "..." dans l’historique. Pour les regrouper en un seul :

git revert --no-commit a1b2c3d..e5f6a7b
git commit -m "revert: annuler les commits a1b2c3d à e5f6a7b"

« Je veux annuler un merge déjà poussé »

Un merge commit a deux parents. Il faut indiquer à Git quel parent est la « branche principale » avec -m :

git revert -m 1 <SHA-du-merge>

-m 1 signifie : « garde le premier parent (généralement main) et annule les changements amenés par le second parent (la feature branch) ».

Après un revert de merge, Git considère que les commits de la branche feature ont déjà été intégrés. Si vous voulez réintroduire ces changements plus tard, il faudra « revert le revert » :

git revert <SHA-du-revert>

Vérification — confirmez que le merge est bien inversé :

git diff HEAD~1 HEAD --stat

Les fichiers modifiés par le merge doivent apparaître comme « supprimés » ou « modifiés inversement ».

« J’ai fait reset —hard par erreur »

Pas de panique. Le reflog enregistre chaque mouvement de HEAD dans votre repo local. Vos commits ne sont pas vraiment perdus — ils sont juste « déréférencés ».

Consultez le reflog pour retrouver le SHA perdu

git reflog

Sortie typique :

a1b2c3d HEAD@{0}: reset: moving to HEAD~3
e4f5a6b HEAD@{1}: commit: feat: ma feature importante
c7d8e9f HEAD@{2}: commit: fix: corriger le bug login
b0a1c2d HEAD@{3}: commit: docs: mise à jour README

Restaurez HEAD à la position d’avant le reset
Fenêtre de terminal
```
git reset --hard e4f5a6b
```
Ou en utilisant la notation reflog :
Fenêtre de terminal
```
git reset --hard HEAD@{1}
```

Vérification :

git log --oneline -5

Vos commits sont de retour. Le reflog conserve les entrées pendant 90 jours par défaut — vous avez largement le temps de réagir.

Après un merge, rebase ou reset, Git sauvegarde automatiquement la position précédente dans ORIG_HEAD. Pour annuler immédiatement :

git reset --hard ORIG_HEAD

C’est plus rapide que de chercher dans le reflog, mais ne fonctionne que pour la dernière opération.

Dépannage : problèmes courants

Symptôme	Cause probable	Solution
`--amend` a changé le SHA et le push est rejeté	Le commit original était déjà poussé	`git push --force-with-lease` (si vous êtes seul sur la branche) ou `git revert`
`error: could not revert` + conflits	Le revert entre en conflit avec des changements ultérieurs	Résolvez les conflits, puis `git revert --continue`
`git revert --abort` pour repartir à zéro	Revert trop complexe, vous voulez annuler	Normal — repart à l’état avant le revert
`reset --soft` n’annule qu’un seul commit	Vous voulez annuler plusieurs commits	Utilisez `HEAD~N` (ex : `HEAD~3` pour 3 commits)
Le reflog est vide	Reflog expiré (> 90 jours) ou repo fraîchement cloné	Essayez `git fsck --lost-found` pour trouver les objets orphelins
`revert` d’un merge échoue sans `-m`	Git ne sait pas quel parent garder	Ajoutez `-m 1` pour garder le premier parent (main)

À retenir

Arbre de décision : --amend pour corriger le dernier commit local, reset pour annuler des commits locaux, revert pour les commits publiés
git commit --amend corrige le message ou ajoute des fichiers au dernier commit (change le SHA)
git reset --soft HEAD~N annule N commits en gardant les modifications prêtes à recommiter
git revert crée un commit inverse — sûr pour les branches partagées
git revert -m 1 est nécessaire pour annuler un merge commit
Le reflog (git reflog) est votre filet de sécurité — il conserve 90 jours d’historique
ORIG_HEAD permet d’annuler immédiatement la dernière opération

Prochaines étapes

Commit sur la mauvaise branche Déplacez des commits vers la bonne branche sans perdre de travail.

Récupérer des données perdues Reflog, branches supprimées, detached HEAD : retrouvez tout.

Reset démystifié Comprenez les 3 arbres de Git et les modes soft, mixed, hard.