Introduction

Contrairement à la plupart des éditeurs, Git ne dispose pas d'un bouton « Annuler » unique. Il vous offre à la place un petit ensemble de commandes ciblant chacune un endroit différent où votre travail réside : le répertoire de travail (les fichiers sur le disque), l'index de staging (les modifications marquées pour le prochain commit) et l'historique des commits (les instantanés déjà enregistrés). Choisir la bonne commande dépend de laquelle de ces trois zones vous souhaitez annuler, et si la modification a déjà été partagée avec d'autres personnes.

Cette page couvre la boîte à outils complète : consulter l'historique, restaurer des fichiers et annuler un ou plusieurs commits — avec git checkout, git restore, git reset, git revert, git clean et git commit --amend.

Choisir la bonne commande

Avant toute commande spécifique, il est utile de savoir quelle zone chacune touche et si elle réécrit l'historique :

La règle la plus importante : reset et amend réécrivent l'historique, donc utilisez-les uniquement sur des commits que vous n'avez pas encore poussés. Pour tout ce qui a déjà été partagé, utilisez revert.

Consulter d'anciens commits

On ne peut pas annuler ce qu'on ne trouve pas. Le meilleur outil pour consulter l'historique est git log. Chaque commit possède un hash d'identification que vous utilisez pour le référencer :

git log --oneline
a3b2a21 Crossword solver with Vue.js
c54ce02 New logic for crossword game
3acb8d0 Some changes in crossword logic
de32112 Styling crossword table area

Par défaut, git log n'affiche que les commits accessibles depuis la branche courante. Pour afficher les commits de toutes les branches, ajoutez --all. Utilisez git checkout ou git switch pour visiter d'autres branches.

Consulter une ancienne révision

Pour inspecter le projet tel qu'il était à un moment antérieur, commencez par trouver le hash de la révision souhaitée :

git log --oneline
b7119f2 Changes in Scrabble Solver
234be24 Fixing search input bug
b235bf4 Make some changes to solver.php
256a81c Create solver.php
3243e12 Initial changes

Ensuite, extrayez ce commit par son hash :

git checkout b235bf4

Vous pouvez maintenant parcourir les fichiers, exécuter des tests, et même modifier des choses. Rien de ce que vous faites ici n'est enregistré sur une branche, votre travail actuel est donc en sécurité. Cet état temporaire s'appelle un HEAD détaché — HEAD pointe directement vers un commit au lieu de pointer vers la tête d'une branche. Revenez sur votre branche quand vous avez terminé :

git switch -  # or: git checkout master

Une fois de retour sur votre branche, utilisez git revert ou git reset pour annuler les modifications souhaitées.

Annuler un instantané committé

Il existe plusieurs façons d'annuler un commit. La bonne dépend du fait que le commit ait été partagé ou non. Imaginons que notre historique ressemble à ceci :

git log --oneline
863fa8e Making some improvements
b235bf4 Make some changes to solver.php
256a81c Create solver.php
3243e12 Initial changes

Les sections ci-dessous annulent le commit 863fa8e Making some improvements de trois façons différentes.

Avec git checkout (inspecter sans modifier la branche)

Extraire le commit précédent, b235bf4, place le dépôt dans l'état avant le commit d'améliorations :

git checkout b235bf4

Il s'agit d'un détour en lecture seule, pas d'une véritable annulation : vous vous retrouvez dans un état HEAD détaché. Tout nouveau commit que vous créez ici devient orphelin une fois que vous repassez sur une branche existante, et le ramasse-miettes de Git peut finir par le supprimer. Pour conserver le travail effectué depuis cet état, créez une branche à partir de là :

git checkout -b improvements-removed

Vous disposez maintenant d'une nouvelle branche, improvements-removed, dont la chronologie n'a jamais inclus 863fa8e. Le checkout est idéal pour observer un ancien état ; les deux commandes suivantes annulent véritablement le commit.

Avec git revert (l'annulation sûre et partageable)

git revert HEAD crée un nouveau commit qui applique l'inverse du commit ciblé. Rien n'est effacé — l'historique progresse vers l'avant :

git revert HEAD

Après exécution, le journal ressemble à ceci :

git log --oneline
23a4b42 Revert "Making some improvements"
863fa8e Making some improvements
b235bf4 Make some changes to solver.php
256a81c Create solver.php
3243e12 Initial changes

L'effet de 863fa8e est désormais annulé, pourtant le commit figure toujours dans l'historique ; 23a4b42 inverse simplement ses modifications. Comme rien n'est réécrit, vous restez sur la même branche et ne cassez le clone de personne d'autre. C'est la bonne méthode pour annuler des commits qui ont été poussés ou partagés publiquement.

Avec git reset (réécrire l'historique local)

git reset déplace le pointeur de la branche courante vers un commit choisi. Exécuter git reset --hard b235bf4 ramène la branche à ce commit et supprime tout ce qui vient après :

git reset --hard b235bf4
git log --oneline
b235bf4 Make some changes to solver.php
256a81c Create solver.php
3243e12 Initial changes

Le commit 863fa8e a disparu de l'historique de cette branche. C'est propre et direct, mais comme cela réécrit l'historique, vous ne devez l'appliquer qu'à des commits que vous n'avez pas encore poussés. git reset accepte un paramètre de mode qui contrôle jusqu'où l'annulation se propage :

• --soft — déplace uniquement le pointeur de branche ; conserve les modifications en staging.
• --mixed (par défaut) — déplace le pointeur et désindexe les modifications, mais les conserve dans le répertoire de travail.
• --hard — déplace le pointeur et supprime les modifications indexées et celles du répertoire de travail.

Annuler le dernier commit

Parfois vous ne voulez pas supprimer le commit le plus récent — vous avez simplement commité trop tôt ou rédigé un mauvais message. Indexez les modifications supplémentaires avec git add, puis amendez :

git add forgotten-file.txt
git commit --amend

Git ouvre votre éditeur configuré afin que vous puissiez modifier le message du dernier commit, et les nouvelles modifications indexées sont intégrées dans ce même commit. Pour ne modifier que le message en une seule ligne :

git commit --amend -m "A clearer message"

Amender remplace le commit précédent par un nouveau (avec un nouveau hash), donc traitez-le comme reset : n'amendez que des commits que vous n'avez pas encore poussés.

Annuler des modifications non commitées

Avant qu'une modification soit commitée, elle réside dans le répertoire de travail et l'index de staging ; vous pouvez donc l'annuler depuis l'une ou l'autre de ces zones sans toucher à l'historique. La commande moderne est git restore :

# Discard edits to a tracked file (working directory)
git restore <file>
# Unstage a file but keep its edits
git restore --staged <file>

Les équivalents plus anciens fonctionnent toujours et apparaissent dans de nombreuses documentations :

# Discard changes in the working directory
git checkout -- <file>
# Unstage a file
git reset HEAD <file>

Supprimer les fichiers non suivis

git restore et reset ne s'appliquent qu'aux fichiers que Git connaît déjà. Pour supprimer des fichiers entièrement nouveaux et non suivis, utilisez git clean. Prévisualisez toujours avec -n (simulation à blanc) :

git clean -n      # list what would be removed
git clean -f      # actually remove untracked files

Comment les trois zones sont liées

Il est utile de bien distinguer les trois zones, car chaque commande d'annulation en cible une précise :

• Répertoire de travail — les fichiers sur le disque que votre éditeur modifie. git restore <file> et git clean opèrent ici.
• Index de staging — l'instantané que vous construisez pour le prochain commit. git add y place les modifications ; git restore --staged (un reset --mixed) les renvoie vers le répertoire de travail.
• Historique des commits — les instantanés enregistrés. git reset le réécrit ; git revert y ajoute des commits.

Se remettre d'une annulation erronée

Un reset ou une branche supprimée peuvent sembler terrifiants, mais Git perd rarement quoi que ce soit immédiatement. Le git reflog enregistre les positions successives de HEAD, vous pouvez donc retrouver le hash d'un commit « perdu » et y revenir avec reset :

git reflog
1a2b3c4 HEAD@{0}: reset: moving to b235bf4
863fa8e HEAD@{1}: commit: Making some improvements

Récupérez avec git reset --hard 863fa8e (ou créez une branche à partir de ce commit). Si vous souhaitez simplement mettre votre travail de côté temporairement plutôt que de l'annuler, envisagez git stash à la place.

Annuler des modifications publiques

Une fois un commit poussé, d'autres personnes peuvent l'avoir. Utilisez git revert pour les modifications publiques, jamais git reset. Reset supprime des commits de l'historique, donc réécrire une branche partagée oblige tout le monde à réparer ses clones. Revert laisse le commit original en place et enregistre un nouveau commit qui l'inverse — sans risque pour tous ceux qui ont déjà tiré.

Pratique