3.8 : Revenir en arrière : restore, revert, reset

Trois noms voisins, trois effets radicalement différents

restore, revert, reset. Trois commandes qui commencent par les mêmes lettres et qui font des choses sans rapport.

C’est probablement la plus grande source d’accidents chez les débutants — et la raison pour laquelle beaucoup finissent par recopier leur dossier avant chaque manipulation.

Il existe pourtant une méthode infaillible pour choisir. Elle tient en une question.


La question de tri

Où se trouve le changement que vous voulez annuler ?

   ┌───────────┐        ┌───────────┐        ┌────────────┐        ┌──────────┐
   │ L'ÉTABLI  │        │ LE PLATEAU│        │ LE REGISTRE│        │ LA FORGE │
   │           │        │           │        │   LOCAL    │        │          │
   └─────┬─────┘        └─────┬─────┘        └──────┬─────┘        └─────┬────┘
         │                    │                     │                    │
     restore              restore              reset                revert
                          --staged            (réécrit)          (ajoute un
                                                                enregistrement)
Le changement est… La commande Ce qu’elle fait
Modifié, pas encore ajouté git restore <fichier> Annule vos modifications
Ajouté au plateau git restore --staged <fichier> Le retire du plateau
Enregistré, pas publié git reset Réécrit votre historique local
Publié sur la forge git revert Crée un enregistrement qui l’annule

Retenez la dernière ligne. C’est la règle d’or de cette leçon :

On réécrit ce qui est local. On ajoute par-dessus ce qui est publié.


git restore — annuler des modifications en cours

Jeter ce que vous venez de faire

git restore Logon.ps1

Le fichier revient à son état du dernier enregistrement. Vos modifications non enregistrées disparaissent.

⚠️ Cette commande est destructive et sans filet. Contrairement à presque tout le reste de Git, ce que vous annulez ici n’a jamais été enregistré : reflog ne pourra pas vous le rendre. C’est l’une des rares façons de perdre réellement du travail avec Git.

Le réflexe : git diff avant, pour voir ce que vous êtes sur le point de jeter.

Pour tout le dépôt :

git restore .

À manier avec le même sérieux.

Retirer du plateau

git restore --staged Logon.ps1

Vous aviez fait git add un peu vite. Cette commande retire le fichier du plateau sans toucher à son contenu : vos modifications sont toujours là, elles ne sont simplement plus en partance.

C’est l’opération inverse de git add, et elle est totalement sans risque.

Récupérer une ancienne version d’un fichier

Celle-ci est précieuse, et peu connue :

git restore --source=HEAD~5 -- Logon.ps1

Vous récupérez le fichier tel qu’il était cinq enregistrements plus tôt, sans toucher au reste du dépôt ni à l’historique.

Traduction en situation réelle : « le script fonctionnait avant la modification de la semaine dernière, remets-moi cette version-là, mais laisse tout le reste tranquille ».

Vous pouvez aussi désigner une version publiée :

git restore --source=v1.3 -- Logon.ps1

C’est probablement la commande de cette leçon que vous utiliserez le plus en dépannage.


git reset — réécrire son historique local

Là où restore travaille sur les fichiers, reset travaille sur l’historique. Il déplace le point où se trouve votre branche.

Trois modes, qui se distinguent par ce qu’ils touchent.

                     REGISTRE      PLATEAU      ÉTABLI
   --soft            déplacé       conservé     conservé
   --mixed (défaut)  déplacé       vidé         conservé
   --hard            déplacé       vidé         ÉCRASÉ

--soft : défaire l’enregistrement, garder le travail

git reset --soft HEAD~1

Le dernier enregistrement disparaît, mais toutes vos modifications reviennent sur le plateau, prêtes à être ré-enregistrées.

Le cas d’usage typique : vous avez produit trois enregistrements brouillons en une heure et vous voulez n’en faire qu’un, propre, avant de publier.

git reset --soft HEAD~3
git commit -m "Ajout de la surveillance d'espace disque sur les serveurs de fichiers"

Trois enregistrements confus deviennent un enregistrement lisible. Tant que rien n’est publié, c’est une excellente pratique.

--mixed : le comportement par défaut

git reset HEAD~1

L’enregistrement disparaît, le plateau est vidé, mais vos fichiers restent modifiés sur le disque. Il faudra refaire git add.

Utile quand vous voulez recomposer différemment ce qui partira.

--hard : tout écraser

git reset --hard HEAD~1

L’enregistrement disparaît, et vos fichiers reviennent à leur état antérieur. Tout ce qui n’était pas enregistré est perdu.

⚠️ C’est la commande la plus dangereuse de Git, et c’est celle qu’on trouve le plus souvent recommandée sur les forums, sans avertissement.

Deux garde-fous avant de la taper :

  • git status — reste-t-il du travail non enregistré ?
  • Ce que vous supprimez est-il déjà publié ? Si oui, ne la tapez pas.

Bonne nouvelle malgré tout : ce qui avait été enregistré reste récupérable via git reflog, objet de la leçon suivante. Ce qui ne l’avait pas été est perdu pour de bon.

⚠️ Jamais après publication

Si l’enregistrement que vous supprimez existe déjà sur la forge, votre historique local et celui du serveur divergent. Le prochain push sera rejeté, et la seule façon de forcer serait d’écraser le travail de vos collègues.

C’est le scénario du force push qui fait disparaître les commits des autres — nous le traiterons dans l’annexe des catastrophes. Évitez-le simplement en appliquant la règle d’or.


git revert — annuler proprement ce qui est publié

git revert 7d2e881

Cette commande ne supprime rien. Elle crée un nouvel enregistrement qui applique l’inverse exact de celui désigné.

   a3f9c21 ── 7d2e881 ── e5b1c93 ── f4a8d02
              (le bug)              (annulation de 7d2e881)

L’histoire conserve les deux : l’erreur et sa correction.

Pourquoi c’est le bon comportement

Cela peut sembler moins propre que de faire disparaître l’erreur. C’est en réalité exactement ce qu’il faut, pour trois raisons.

Rien ne diverge. Vos collègues ont déjà l’enregistrement fautif. Ajouter par-dessus fonctionne pour tout le monde ; le supprimer ne fonctionnerait que pour vous.

La trace est conservée. Six mois plus tard, l’historique montre qu’on a essayé quelque chose, que ça n’a pas marché, et qu’on l’a annulé. C’est une information, pas une honte.

C’est réversible. Un revert peut lui-même être annulé par un revert, si vous vous rendez compte que le changement était finalement bon.

En situation

C’est la commande de l’incident de production :

git revert 7d2e881
git push

Deux commandes, dix secondes, et la version fautive est neutralisée pour tout le monde. Vous chercherez la cause à tête reposée.

Quelques variantes

git revert HEAD                  # annuler le dernier
git revert HEAD~2..HEAD          # annuler les trois derniers
git revert -n 7d2e881            # préparer l'annulation sans enregistrer tout de suite

Un revert peut produire un conflit, si le code a évolué depuis. Vous le résolvez exactement comme en leçon 3.5 : marqueurs, arbitrage, git add, puis git revert --continue.

Le cas de l’enregistrement de fusion : annuler une fusion demande de préciser quelle branche conserver, avec l’option -m 1. C’est un cas rare et délicat ; nous le traiterons dans l’annexe des catastrophes.


Les quatre situations réelles

« J’ai modifié un fichier par erreur, je n’ai rien enregistré. »

git diff Logon.ps1        # vérifier ce qu'on jette
git restore Logon.ps1

« J’ai fait trois enregistrements brouillons, je veux n’en faire qu’un. Rien n’est publié. »

git reset --soft HEAD~3
git commit -m "Un message clair"

« J’ai poussé un script qui casse la production. »

git revert HEAD
git push

« Le script fonctionnait avant la modification du mois dernier. »

git log --oneline -- Logon.ps1        # repérer la bonne version
git restore --source=<empreinte> -- Logon.ps1
git diff                              # vérifier ce qu'on récupère
git commit -am "Retour à la version du 12/07 : la 1.5 casse le mappage RH"

Remarquez la dernière : on ne réécrit rien, on ajoute un enregistrement qui restaure l’ancien contenu. Traçable, explicable, sans effet sur les collègues.


Ce qui vous rattrapera

Une bonne nouvelle pour finir : presque tout est récupérable.

Un enregistrement supprimé par un reset --hard, une branche effacée, une manipulation mal comprise — tant que le travail avait été enregistré au moins une fois, Git en garde la trace pendant plusieurs semaines.

C’est l’objet de la leçon suivante, et c’est ce qui doit vous permettre de manipuler ces commandes sans crainte excessive.

La seule exception, et elle est importante : ce qui n’a jamais été enregistré n’est nulle part. D’où le conseil de la leçon 3.3 — enregistrez avant toute manipulation risquée. Un git commit de dix secondes est le meilleur filet de sécurité qui existe.


Les erreurs classiques

Symptôme Cause
Du travail non enregistré a disparu restore ou reset --hard — irrécupérable
push rejeté après un reset Vous avez réécrit un historique déjà publié : utilisez revert
revert produit un conflit Normal si le fichier a évolué : résolvez, puis git revert --continue
reset --soft semble n’avoir rien fait Il a fonctionné : vos modifications sont sur le plateau, voyez git status
Vous vouliez retirer du plateau et avez tout perdu restore --staged retire ; restore seul écrase
Impossible d’annuler une fusion Il faut préciser -m 1 — voir l’annexe

Ce qu’il faut retenir

  • La question de tri : où se trouve le changement — établi, plateau, registre local, forge ?
  • restore annule des modifications de fichiers ; restore --staged retire du plateau.
  • git restore sans option est destructif et sans filet : git diff d’abord.
  • restore --source= récupère un fichier à une version antérieure, sans toucher au reste.
  • reset réécrit l’historique local : --soft garde tout, --hard écrase tout.
  • reset --soft HEAD~n est excellent pour regrouper des enregistrements brouillons non publiés.
  • revert crée un enregistrement d’annulation : c’est la commande des incidents de production.
  • La règle d’or : on réécrit ce qui est local, on ajoute par-dessus ce qui est publié.
  • Tout ce qui a été enregistré reste récupérable ; ce qui ne l’a jamais été, non.

Dans la leçon suivante

Nous avons évoqué plusieurs fois un mécanisme capable de retrouver ce que vous croyiez perdu. Il est temps de le regarder en face.

git reflog est la boîte noire de Git : il consigne chacun de vos déplacements, y compris ceux que vous avez annulés, y compris les enregistrements qui n’appartiennent plus à aucune branche. C’est lui qui permet de récupérer un reset --hard malencontreux, une branche supprimée, ou un travail qu’on croyait envolé.

C’est aussi le socle de l’annexe des catastrophes du vendredi 17h : six des cas qu’elle traite se résolvent avec cette seule commande.