Annuler des modifications dans Git

Ce guide vous apprend à corriger vos erreurs dans Git. Que vous ayez ajouté un fichier par erreur au staging, commité trop vite, ou publié un commit défectueux, Git offre une commande pour chaque situation. Trois d'entre elles ne détruisent rien. La quatrième, git restore sur un fichier, supprime définitivement vos modifications non commitées, et cette page le signale à chaque fois qu'elle l'emploie.

Prérequis : comprendre le cycle add/commit et consulter l'historique.

Ce que vous allez apprendre

• Retirer un fichier du staging sans perdre vos modifications
• Annuler des modifications dans le répertoire de travail avec restore
• Modifier le dernier commit avec --amend avant de partager
• Inverser un commit public avec revert sans réécrire l'historique

Les 4 scénarios d'annulation

Scénario	Commande	Danger
Retirer un fichier du staging	git restore --staged	Aucun, les fichiers restent modifiés
Annuler les modifications d'un fichier	git restore	Perte des modifications non commitées
Corriger le dernier commit	git commit --amend	Réécrit l'historique local
Inverser un commit publié	git revert	Aucun, crée un nouveau commit

Glissez pour voir

Le tableau ci-dessus résume les quatre situations que vous rencontrerez. Les sections suivantes détaillent chacune d'elles.

Retirer un fichier du staging

Vous avez fait git add sur un fichier par erreur. Le fichier est dans le staging, mais vous ne voulez pas le commiter.

git restore --staged style.css

Vérification :

git status

Le fichier passe de "Changes to be committed" à "Changes not staged for commit". Les modifications dans le fichier ne sont pas perdues, elles restent dans votre répertoire de travail.

Pour retirer tous les fichiers du staging :

git restore --staged .

Ancienne syntaxe

Avant Git 2.23, la commande équivalente était git reset HEAD style.css. Elle fonctionne toujours, mais git restore est plus claire et plus sûre. Privilégiez la syntaxe moderne.

Annuler les modifications d'un fichier

Vous avez modifié un fichier et vous voulez abandonner ces modifications. La commande est git restore, et sa subtilité tient en une phrase : elle restaure depuis l'index, pas depuis le dernier commit. Tant que vous n'avez rien mis dans l'index, les deux portent la même version et la nuance ne se voit pas. Dès que vous faites un git add, elle décide du résultat.

Action irréversible

Cette commande supprime définitivement vos modifications non commitées. Git ne peut pas les récupérer. Vérifiez deux fois avant de l'exécuter.

git restore style.css

Vérification :

git diff style.css

Aucune sortie signifie que le fichier est désormais identique à l'index. C'est exactement ce que compare git diff sans argument : le répertoire de travail et l'index, pas le répertoire de travail et le dernier commit.

Pour restaurer tous les fichiers modifiés :

git restore .

D'où vient le contenu restauré

La démonstration tient en quelques commandes. On met trois versions différentes dans les trois arbres de Git, puis on regarde laquelle git restore ramène :

git show HEAD:style.css   # ce que porte le dernier commit
git show :style.css       # ce que porte l'index
cat style.css             # ce que porte le répertoire de travail

version COMMITEE
version INDEXEE
version TRAVAIL

git restore style.css
cat style.css

version INDEXEE

Le fichier revient à la version indexée, pas à celle du commit. Si vous vouliez celle du commit, il faut la demander.

Le triptyque restore

Chaque forme dit d'où vient le contenu et où il va. C'est le seul modèle à retenir, il rend les trois commandes évidentes :

Commande	Source	Destination
git restore style.css	l'index	le répertoire de travail
git restore --staged style.css	le dernier commit	l'index
git restore --source=HEAD --staged --worktree style.css	le dernier commit	l'index et le répertoire de travail

Glissez pour voir

La troisième forme est celle qui correspond vraiment à « remettre ce fichier comme au dernier commit ». Les deux premières sont des demi-tours partiels, ce qui est souvent ce qu'on veut, à condition de le savoir.

Restaurer depuis un commit spécifique

Vous pouvez restaurer un fichier depuis n'importe quel commit :

git restore --source=a1b2c3d style.css

Le fichier est restauré avec le contenu qu'il avait dans le commit a1b2c3d. La modification est placée dans votre répertoire de travail, prête à être commitée.

Corriger le dernier commit

Modifier le message

Vous avez fait une faute de frappe dans votre message de commit :

git commit --amend -m "Message corrigé"

Ajouter des fichiers oubliés

Vous avez oublié d'inclure un fichier dans le dernier commit :

1. Ajoutez le fichier oublié au staging

   git add fichier-oublie.css

2. Corrigez le commit en conservant le même message

   git commit --amend --no-edit

Le résultat est un seul commit contenant toutes les modifications. L'ancien commit est remplacé par le nouveau (SHA différent).

Ne pas amend un commit publié

--amend réécrit l'historique : il crée un nouveau commit avec un SHA différent. Si le commit original a déjà été poussé vers un dépôt distant, cela causera des conflits pour les autres développeurs. N'utilisez --amend que sur des commits locaux (non poussés).

Inverser un commit publié avec git revert

Quand un commit a déjà été poussé et partagé avec d'autres développeurs, on ne réécrit pas l'historique. On crée un nouveau commit qui annule les modifications du commit fautif :

git revert a1b2c3d

Git ouvre l'éditeur pour le message. Le message par défaut est Revert "Message du commit original". Vous pouvez le modifier si besoin, puis sauvegarder.

Vérification :

git log --oneline -3

Sortie attendue :

f8e7d6c Revert "Message du commit original"
a1b2c3d Message du commit original
9a8b7c6 Commit précédent

Le commit a1b2c3d est toujours dans l'historique, git revert ne l'efface pas. Il crée un nouveau commit (f8e7d6c) qui applique les modifications inverses.

Revert sans ouvrir l'éditeur

git revert --no-edit a1b2c3d

Revert plusieurs commits

Pour inverser une série de commits :

git revert --no-edit a1b2c3d..e5f6a7b

Cela crée un commit de revert pour chaque commit de la plage, du plus récent au plus ancien.

Résumé : choisir la bonne commande

J'ai fait git add par erreur ?
  └─→ git restore --staged <fichier>

Je veux abandonner mes modifications locales ?
  └─→ git restore <fichier>  (IRRÉVERSIBLE) (source : l'index)

Je veux vraiment revenir au dernier commit ?
  └─→ git restore --source=HEAD --staged --worktree <fichier>

Mon dernier commit a un problème ? (pas encore poussé)
  └─→ git commit --amend

Mon commit est déjà poussé/partagé ?
  └─→ git revert <SHA>

Et git reset ?

git reset offre des modes plus avancés (--soft, --mixed, --hard) traités dans le guide dédié. Ne le confondez pas avec les commandes de ce guide :

Commande	Modifie l'index	Modifie le working directory	Modifie l'historique
git restore	Selon option	Oui	Non
git commit --amend	Non	Non	Oui (local)
git revert	Oui	Oui	Oui (nouveau commit)
git reset --hard	Oui	Oui	Oui (destructif)

Glissez pour voir

Pour les cas courants, restore, --amend et revert sont suffisants et sans surprises.

Dépannage : problèmes courants

Symptôme	Cause probable	Solution
git restore ne fait rien	Le fichier est déjà identique à l'index, sa source par défaut	Vérifiez avec git status et git diff
git restore ne ramène pas la version attendue	Le fichier avait été indexé : c'est l'index qui est restauré, pas le commit	git restore --source=HEAD --staged --worktree <fichier>
error: could not revert	Conflit lors du revert	Résolvez le conflit, puis git revert --continue
--amend a modifié le mauvais commit	Vous aviez des commits non poussés entre	git reflog pour retrouver l'ancien SHA, puis git reset --soft SHA
Modifications perdues après git restore	Comportement normal, les modifications non commitées sont supprimées	Commitez souvent pour éviter les pertes
git revert HEAD~3..HEAD ne revert pas ce que j'attendais	La syntaxe de plage exclut la borne gauche	Utilisez HEAD~3^..HEAD ou revertissez un par un

Glissez pour voir

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

10 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• git restore --staged retire un fichier du staging sans le modifier : il copie le dernier commit dans l'index
• git restore copie l'index dans le répertoire de travail, pas le dernier commit. Pour viser le commit, il faut --source=HEAD --staged --worktree (irréversible dans les deux cas)
• git commit --amend corrige le dernier commit local (message ou contenu)
• git revert crée un commit inverse, sûr pour les commits partagés
• Règle d'or : --amend pour le local, revert pour le partagé
• Commitez souvent, c'est la meilleure protection contre les pertes

Pour aller plus loin

• Alias et productivité : Des raccourcis pour les commandes de correction que vous venez de voir.
• Les branches Git : Le module qui isole vos essais, de sorte qu'une annulation ne touche jamais la branche principale.
• Reset démystifié : Les trois arbres de Git et les modes soft, mixed et hard qui agissent derrière chaque annulation.

×

📖 Voir la documentation →