Comment annuler en toute sécurité les erreurs Git : Revert, Reset et Checkout expliqués

Les erreurs Git semblent généralement pires qu'elles ne le sont. Vous avez peut-être commité le mauvais fichier, stagé trop de choses, ou poussé une mauvaise modification sur une branche partagée. La correction sécurisée dépend d'une question : la modification a-t-elle déjà été partagée ?

Ce guide explique quand utiliser git revert, git reset et git checkout, avec des exemples que vous pouvez copier attentivement. La version courte est simple : utilisez git revert pour les commits partagés, git reset pour le nettoyage local, et git checkout uniquement lorsque vous voulez changer de branche ou restaurer des états de fichiers plus anciens.

D'abord, vérifiez ce que vous êtes sur le point d'annuler

Avant d'exécuter une commande d'annulation, regardez votre état actuel :

git status
git log --oneline --decorate -5

git status vous indique si vous avez du travail non stagé, stagé ou non suivi. git log montre les commits récents et où pointe votre branche.

Si vous avez du travail local que vous ne voulez pas perdre, créez d'abord une branche de sécurité rapide :

git branch backup-avant-annulation

Cette branche vous donne un moyen facile de revenir en arrière si vous choisissez la mauvaise commande.

Utilisez git revert pour les commits déjà poussés

git revert crée un nouveau commit qui applique l'inverse d'un commit antérieur. Il ne supprime pas l'historique, c'est donc le choix le plus sûr pour les branches partagées comme main, develop, ou toute branche que d'autres personnes ont pu tirer.

Supposons que votre historique ressemble à ceci :

A -- B -- C -- D  main

Le commit C a introduit un bug, mais D est bon et doit rester. Trouvez le hash du commit :

git log --oneline

Puis revert uniquement ce commit :

git revert abcdef1

Git ouvre votre éditeur pour le message du commit de revert. Après l'avoir sauvegardé, l'historique ressemble à ceci :

A -- B -- C -- D -- E  main

Le commit E annule les modifications de C. Tout le monde peut tirer ce nouveau commit normalement.

Revert d'un commit de fusion

Les commits de fusion nécessitent un drapeau supplémentaire car Git doit savoir quel parent est la ligne principale :

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

Pour une fusion normale dans main, -m 1 signifie généralement "garder le premier parent", c'est-à-dire la branche dans laquelle vous avez fusionné. Ne devinez pas ici. Exécutez d'abord ceci et inspectez les parents :

git show --summary <hash-du-commit-de-fusion>

Si vous n'êtes pas sûr du parent à garder, demandez à un coéquipier ou testez le revert sur une branche temporaire.

Utilisez git reset pour les commits locaux

git reset déplace le pointeur de votre branche actuelle. Selon le mode, il peut également modifier la zone de staging et vos fichiers de travail. Utilisez-le principalement pour les commits que vous n'avez pas poussés.

Désindexer un fichier

Si vous avez stagé le mauvais fichier, désindexez-le sans modifier le contenu du fichier :

git restore --staged fichier_indesirable.txt

Les exemples Git plus anciens utilisent souvent cette commande équivalente :

git reset HEAD fichier_indesirable.txt

Les deux retirent le fichier de la zone de staging. Vos modifications restent dans votre répertoire de travail.

Annuler le dernier commit mais garder les modifications stagées

Utilisez --soft lorsque le message du commit était erroné ou que vous voulez ajouter un fichier supplémentaire avant de recommiter :

git reset --soft HEAD~1

Votre branche recule d'un commit, mais les modifications de ce commit restent stagées.

Annuler le dernier commit et garder les modifications non stagées

Utilisez le reset mixte par défaut lorsque vous voulez retravailler les fichiers avant de commiter à nouveau :

git reset HEAD~1

Cela recule la branche d'un commit et laisse les modifications dans votre répertoire de travail.

Jeter les commits locaux et les modifications de fichiers

--hard réinitialise la branche, la zone de staging et les fichiers suivis dans votre répertoire de travail :

git reset --hard HEAD~1

Utilisez ceci uniquement lorsque vous êtes certain de ne pas avoir besoin des modifications supprimées. Cela ne supprime pas les fichiers non suivis, mais cela supprimera les modifications des fichiers suivis sans demander à nouveau.

Utilisez git checkout avec précaution

git checkout a deux tâches courantes dans les anciens workflows Git : changer de branche et restaurer des fichiers. Les versions plus récentes de Git divisent ces tâches en commandes plus claires : git switch pour les branches et git restore pour les fichiers.

Pour changer de branche :

git switch main

Équivalent plus ancien :

git checkout main

Pour supprimer les modifications non commitées dans un fichier suivi :

git restore mon_fichier.txt

Équivalent plus ancien :

git checkout -- mon_fichier.txt

Cette restauration de fichier est destructive pour les modifications non commitées dans le fichier sélectionné. Si vous pourriez avoir besoin des modifications plus tard, stash-les d'abord :

git stash push -m "sauvegarder le travail avant restauration"

Utilisez git reflog si vous êtes allé trop loin

Si vous avez exécuté git reset --hard ou déplacé une branche par erreur, git reflog peut encore montrer où HEAD pointait auparavant :

git reflog

Vous pourriez voir une entrée antérieure comme HEAD@{2} ou un hash de commit d'avant le reset. Vous pouvez créer une branche de récupération à partir de celle-ci :

git branch recuperation <hash-du-commit>

Reflog est local à votre clone et n'est pas un système de sauvegarde, mais il vous sauve souvent des erreurs récentes.

Quelle commande devez-vous choisir ?

Utilisez git revert lorsque le mauvais commit est déjà poussé ou que d'autres personnes ont pu baser leur travail dessus.

Utilisez git reset --soft lorsque votre dernier commit local doit être refait mais que les modifications sont toujours correctes.

Utilisez git reset lorsque vous voulez que le dernier commit local revienne sous forme de modifications de fichiers non stagées.

Utilisez git reset --hard uniquement lorsque les modifications locales suivies peuvent être supprimées.

Utilisez git restore ou git checkout -- <fichier> lorsque vous voulez supprimer les modifications non commitées dans des fichiers spécifiques.

L'habitude la plus sûre est de vérifier git status, de créer une branche de sauvegarde temporaire lorsque les enjeux sont élevés, et d'éviter de réécrire l'historique partagé. Si un commit a atteint un dépôt distant partagé, git revert est généralement la correction la plus propre.