Annuler un commit Git : reset, revert et restore
Tu as fait un commit trop vite ? Pousse un bug ? Pas de panique. Git offre plusieurs manières d'annuler. Cette page t'explique laquelle utiliser selon ta situation.
Par Anaïs Sparesotto, développeuse web et responsable pédagogique · Mis à jour le
Quelle commande utiliser ?
La bonne façon d'annuler dépend d'une seule question : où se trouve la modification maintenant ? Encore dans tes fichiers, dans un commit local, ou dans un commit déjà pushé ? Réponds à ça, et la commande suit.
git restore
Tu as modifié ou indexé des fichiers sans commiter. Tu veux revenir à la version précédente.
git restore <fichier>git reset ou --amend
Tu as commité sans pusher. Tu peux réécrire ton propre historique librement.
git reset --soft HEAD~1git revert
D'autres ont peut-être le commit. Annule-le avec un nouveau commit au lieu de réécrire l'historique.
git revert <hash>Avant d'annuler : les trois endroits où vit une modification
Git range ton travail dans trois zones. Le répertoire de travail, ce sont les fichiers que tu modifies. La zone de staging (ou index) contient ce que tu as sélectionné avec git add. L'historique, c'est la chaîne des commits, et HEAD pointe sur celui où tu te trouves.
Chaque commande d'annulation déplace des choses entre ces zones. git restore agit sur les fichiers. git reset recule la branche et décide du sort du staging et des fichiers. git revert ajoute un nouveau commit et laisse le passé tranquille. Dans les exemples, HEAD~1 veut dire « un commit avant HEAD », et HEAD~3 trois commits en arrière.
Un bon réflexe avant toute annulation : lance git status et git log --oneline -5 pour voir exactement où tu en es.
Annuler des modifications non commitées : git restore
Si tu n'as pas encore commité, tu n'as aucun commit à annuler. git restore <fichier> jette les modifications de ton répertoire de travail et remet le fichier dans sa version indexée, ou dans celle du dernier commit si rien n'était indexé. Ces modifications ne sont sauvegardées nulle part : vérifie le fichier avant.
git restore --staged <fichier> fait l'inverse : il sort le fichier de la zone de staging et garde tes modifications dans le fichier. Utile quand tu as lancé git add . un peu trop vite.
Tu veux garder les modifications pour plus tard au lieu de les supprimer ? Mets-les de côté avec git stash. Toutes les options dans le guide git restore.
Annuler le dernier commit local : git reset --soft, --mixed ou --hard
git reset HEAD~1 recule ta branche d'un commit, comme si le dernier commit n'avait jamais existé. Les trois modes ne diffèrent que par ce qu'ils font du contenu de ce commit. Les trois exemples partent du même historique :
--soft : tout reste indexé
Le commit est retiré, mais ses modifications sont toujours dans la zone de staging, prêtes à être commitées à nouveau. C'est le bon choix pour refaire un commit autrement, par exemple pour le découper ou le fusionner avec le suivant. Git n'affiche rien, c'est normal.
--mixed : modifs gardées, mais désindexées
C'est le mode par défaut quand tu tapes git reset HEAD~1. Le commit et le staging sont annulés, tes fichiers restent tels quels. Tu choisis à nouveau ce que tu git add.
--hard : tout jeter
Le commit, le staging et les modifications des fichiers suivis sont supprimés. Tes fichiers reviennent à l'état de HEAD~1. Le commit lui-même se retrouve encore avec le reflog (voir plus bas), mais les modifications non commitées effacées par --hard sont perdues pour de bon. Les fichiers non suivis ne sont pas touchés.
Plusieurs commits : change le nombre. git reset --soft HEAD~3 annule les trois derniers commits et laisse toutes leurs modifications indexées : une façon simple de les regrouper en un seul.
Tu changes d'avis ? Juste après un reset, Git garde l'ancienne position dans ORIG_HEAD, donc git reset --hard ORIG_HEAD te ramène en arrière. Tous les détails dans le guide git reset.
Corriger le dernier commit au lieu de l'annuler : git commit --amend
Souvent, tu ne veux pas annuler le commit, juste le corriger : une faute dans le message, un fichier oublié, une ligne de debug restée là. Indexe la correction, puis lance git commit --amend. Git remplace le dernier commit par un nouveau qui inclut les modifications indexées. --no-edit garde le message, -m en donne un nouveau.
Le commit corrigé reçoit un nouveau hash. C'est une réécriture d'historique, donc la même règle que pour reset s'applique : n'utilise --amend que sur des commits pas encore pushés. Les autres options sont dans le guide git commit.
Annuler un commit déjà pushé : git revert
Une fois le commit sur le dépôt distant, tes collègues l'ont peut-être déjà récupéré. Si tu le supprimes en local avec reset, ta branche et la leur ne sont plus d'accord, et un git push normal est refusé. git revert <hash> règle ça proprement : il crée un nouveau commit qui applique l'inverse exact de l'ancien. L'historique ne fait qu'avancer, personne n'a besoin de se resynchroniser.
Plusieurs commits : git revert --no-commit HEAD~3..HEAD annule les trois derniers commits dans ton répertoire de travail, puis un seul git commit les enregistre en un revert. Sans --no-commit, tu obtiens un commit de revert par commit.
Un commit de merge : un merge a deux parents, donc Git doit savoir quel côté garder. -m 1 garde le premier parent, en général la branche dans laquelle tu as mergé.
Tu dois vraiment supprimer un commit pushé, par exemple un mot de passe publié par erreur ? Alors fais le reset en local et pousse avec git push --force-with-lease, après avoir prévenu ton équipe. Contrairement à --force, il refuse d'écraser des commits que tu n'as pas vus. Un secret pushé doit aussi être révoqué : supprimer le commit n'efface pas les copies déjà récupérées par d'autres. Plus de détails dans le guide git revert.
Récupérer un commit après une mauvaise annulation : git reflog
Un commit retiré par git reset ou --amend n'est pas supprimé tout de suite. Git note chaque déplacement de HEAD dans le reflog : commits, resets, checkouts, rebases. Trouve la ligne juste avant ton erreur, puis reviens-y avec git reset --hard HEAD@{n}, ou crée une branche sur ce hash pour l'examiner au calme.
Deux limites à connaître : le reflog est local à ta machine (il n'est jamais pushé), et les vieilles entrées expirent, après 90 jours par défaut, ou 30 jours pour les commits qui ne sont plus atteignables depuis une branche. Il ne peut pas non plus faire revenir des modifications jamais commitées. Le guide git reflog détaille tout pas à pas.
Tableau de décision : annuler un commit dans chaque situation
Trouve ta situation dans la première colonne. « Réécrit l'historique » veut dire : à faire seulement sur des commits pas encore pushés.
| Situation | Commande | Réécrit l'historique | Tes modifications |
|---|---|---|---|
| Fichier modifié, pas indexé, tu veux l'ancienne version | git restore <fichier> | Non, sans risque si pushé | Perdues (les modifs non indexées) |
| Fichier indexé par erreur | git restore --staged <fichier> | Non, sans risque si pushé | Gardées dans le fichier |
| Dernier commit avec une faute ou un fichier oublié (pas pushé) | git commit --amend | Oui, en local seulement | Gardées, ajoutées au nouveau commit |
| Annuler le dernier commit, garder les modifs indexées | git reset --soft HEAD~1 | Oui, en local seulement | Gardées, indexées |
| Annuler le dernier commit, garder les modifs non indexées | git reset HEAD~1 | Oui, en local seulement | Gardées, non indexées |
| Jeter le dernier commit et ses modifs | git reset --hard HEAD~1 | Oui, en local seulement | Perdues (commit récupérable via reflog) |
| Annuler un commit déjà pushé | git revert <hash> | Non, sans risque si pushé | Annulées par un nouveau commit |
| Annuler un merge déjà pushé | git revert -m 1 <hash> | Non, sans risque si pushé | Annulées par un nouveau commit |
| Retrouver un commit après un mauvais reset | git reflog, puis git reset --hard HEAD@{n} | Oui, en local seulement | Commit restauré |
Les erreurs fréquentes quand on annule un commit
Utiliser --hard au lieu de --soft
--hard efface aussi les modifications non commitées de tes fichiers. Si tu veux seulement refaire le commit, --soft ou le mode par défaut suffit. Dans le doute, lance d'abord git stash.
Faire un reset ou un --amend sur un commit pushé
Le push suivant est refusé, et le forcer réécrit l'historique de tes collègues. Sur une branche partagée, utilise git revert.
Croire que git restore annule un commit
git restore n'agit que sur les fichiers. Le commit reste dans l'historique. Pour retirer le commit lui-même, utilise reset ou revert.
Annuler un merge sans -m
Git s'arrête avec « is a merge but no -m option was given ». Ajoute -m 1 pour garder la branche dans laquelle tu as mergé.
Compter HEAD~n sur la mauvaise branche
HEAD~2 dépend de la branche où tu te trouves. Vérifie avec git log --oneline avant le reset, pas après.
Paniquer après une erreur
Une modification commitée est très difficile à perdre avec Git. Avant de tenter des commandes au hasard, ouvre git reflog : ton commit y est presque toujours.
Pour annuler autre chose qu'un commit (un fichier, un merge en cours, des fichiers non suivis), lis le guide complet annuler des modifications avec Git.
GitQuest est conçu par Anaïs (nouvelle fenêtre), développeuse web et responsable pédagogique, spécialisée en formations tech et accessibilité numérique.
Questions sur l'annulation de commits
Apprends à annuler sans paniquer
GitQuest t'entraîne à maîtriser reset, revert et restore dans des situations réalistes.