Annuler les modifications dans Git : Reset, Restore, Revert expliqués

Annuler des modifications dans Git est sûr lorsque vous savez quelle couche vous modifiez : l'arbre de travail, la zone de staging ou l'historique des commits. Les commandes courantes sont git restore, git reset et git revert, et elles résolvent différents problèmes.

La grande règle est simple : utilisez restore pour les fichiers, reset pour les modifications locales de l'historique, et revert pour annuler des commits que d'autres personnes ont peut-être déjà.

Comprendre les concepts de base

Gardez ces zones à l'esprit :

Arbre de travail : les fichiers que vous éditez.
Zone de staging, également appelée l'index : les modifications sélectionnées pour le prochain commit.
Historique des commits : les commits déjà enregistrés.
HEAD : le commit actuel vers lequel pointe votre branche.

Exécutez git status avant d'annuler quoi que ce soit. Il vous indique si les modifications sont non indexées, indexées ou déjà commitées.

`git restore` : Pour annuler des modifications dans le répertoire de travail et la zone de staging

Utilisez git restore lorsque vous souhaitez modifier des fichiers dans l'arbre de travail ou la zone de staging sans déplacer l'historique de la branche.

Désindexer des fichiers

Si vous avez indexé un fichier par erreur, désindexez-le avec --staged :

git restore --staged <fichier>

Pour tout désindexer :

git restore --staged .

Vos modifications de fichier restent dans l'arbre de travail. Elles sont simplement retirées du prochain commit.

Annuler des modifications dans le répertoire de travail

Pour jeter les modifications non indexées d'un fichier :

git restore <fichier>

Cela fait correspondre la copie de l'arbre de travail à l'index. Si le fichier n'est pas indexé, cela signifie généralement qu'il revient à HEAD. Vérifiez d'abord avec git diff car cela annule les modifications locales.

Pour annuler à la fois les modifications indexées et non indexées d'un fichier et le restaurer depuis HEAD :

git restore --source=HEAD --staged --worktree <fichier>

Restaurer un fichier depuis un commit spécifique

Vous pouvez également ramener un fichier depuis un ancien commit :

git restore --source=<commit> -- chemin/vers/fichier

Cela modifie le fichier dans votre arbre de travail. Commitez-le si l'ancienne version est celle que vous souhaitez conserver à l'avenir.

`git reset` : Réécrire l'historique

Utilisez git reset lorsque vous souhaitez déplacer le pointeur de la branche actuelle. Il peut également modifier la zone de staging et l'arbre de travail selon le mode.

Comprendre les modes (`--soft`, `--mixed`, `--hard`)

Les trois modes courants sont :

git reset --soft HEAD^

Déplace HEAD d'un commit en arrière et conserve les modifications du commit annulé dans la zone de staging.

git reset --mixed HEAD^

Déplace HEAD d'un commit en arrière et conserve les modifications du commit annulé non indexées. --mixed est le mode par défaut, donc git reset HEAD^ fait la même chose.

git reset --hard HEAD^

Déplace HEAD d'un commit en arrière et supprime les modifications correspondantes de la zone de staging et de l'arbre de travail. C'est destructeur. Ne l'exécutez pas à la légère.

Modèles utiles de reset :

git reset --soft HEAD^      # refaire le dernier commit local, garder les modifications indexées
git reset HEAD^             # annuler le dernier commit local, garder les modifications non indexées
git reset                   # désindexer toutes les modifications indexées
git reset --hard origin/main # supprimer les modifications locales et correspondre à origin/main

Réinitialiser un ancien commit

Pour reculer votre branche de deux commits tout en conservant les modifications dans votre arbre de travail :

git reset --mixed HEAD~2

Ne réinitialisez que les commits locaux ou ceux que votre équipe a accepté de réécrire. Si les commits sont déjà sur une branche partagée, préférez git revert.

`git revert` : Créer un nouveau commit pour annuler des modifications

git revert crée un nouveau commit qui applique l'inverse d'un commit antérieur. Il ne supprime ni ne déplace le commit original, il est donc sûr pour les branches partagées.

Revert un commit :

git revert <hash-du-commit>

Revert une plage :

git revert HEAD~3..HEAD

Si des conflits apparaissent, résolvez-les, indexez les fichiers et continuez :

git add <fichiers-corrigés>
git revert --continue

Revert un commit de fusion nécessite une attention particulière car Git doit savoir quel parent doit être traité comme la ligne principale :

git revert -m 1 <commit-de-fusion>

Ne faites cela que si vous comprenez ce que la fusion a introduit. Pour les branches de production, demandez une relecture avant de revert des fusions.

Choisir la bonne commande

Utilisez ce guide rapide :

Désindexer un fichier : git restore --staged <fichier>.
Annuler les modifications non indexées d'un fichier : git restore <fichier>.
Annuler le dernier commit local et garder les modifications indexées : git reset --soft HEAD^.
Annuler le dernier commit local et garder les modifications non indexées : git reset HEAD^.
Supprimer les modifications et commits locaux de manière destructive : git reset --hard <commit>.
Annuler un commit poussé en toute sécurité : git revert <hash-du-commit>.

En pratique

Avant d'annuler quoi que ce soit, exécutez git status et décidez ce que vous modifiez. Utilisez restore pour le nettoyage au niveau des fichiers, reset pour les commits locaux non poussés, et revert pour l'historique partagé. Lorsqu'une commande inclut --hard, faites une pause et vérifiez d'abord avec git diff.