Comment annuler les modifications dans Git ?

Question

Accepted Answer

Git offre plusieurs façons **d'annuler les modifications** selon la situation — supprimer les modifications non validées, désindexer, modifier le dernier commit, révoquer un commit, ou réinitialiser. Connaître le bon outil pour chaque situation est important, une compétence pratique précieuse. ## Annuler les modifications non validées (répertoire de travail) ```bash git restore # discard unstaged changes to a file (revert to last commit) git checkout -- # older equivalent git restore . # discard ALL unstaged changes (careful!) git clean -fd # remove untracked files/directories ``` ## Désindexer (conserver les modifications, simplement les désindexer) ```bash git restore --staged # unstage a file (changes stay in working dir) git reset # older equivalent ``` ## Corriger ou modifier le dernier commit ```bash git commit --amend -m "New message" # change the last commit's message git commit --amend # add staged changes to the last commit # ⚠️ amend REWRITES the commit — don't amend commits already pushed/shared ``` ## Annuler une modification validée ```text TWO main approaches: REVERT → creates a NEW commit that undoes a previous commit (SAFE for shared history) git revert → history preserved; the undo is itself a commit RESET → moves the branch pointer BACK (rewrites history — for LOCAL commits only) git reset --soft HEAD~1 → undo commit, KEEP changes staged git reset --mixed HEAD~1 → undo commit, keep changes unstaged (default) git reset --hard HEAD~1 → undo commit AND DISCARD changes (⚠️ destructive!) ``` ## revert vs reset (le choix clé) ```text REVERT → safe for PUBLIC/shared commits (adds a new undoing commit; doesn't rewrite history) RESET → rewrites history (only for LOCAL, unpushed commits; never on shared branches) → Rule: use REVERT to undo commits others may have; RESET only for local cleanup. ``` ## Pourquoi c'est important Savoir comment annuler les modifications dans Git est important, une compétence pratique fréquemment nécessaire, car les erreurs et le besoin d'annuler des modifications sont inévitables en développement, et Git fournit des façons puissantes (mais situation-spécifiques) de récupérer. Comprendre le **bon outil pour chaque situation** est la compétence clé : supprimer **les modifications non validées** (`git restore` pour annuler les éditions du répertoire de travail, `git clean` pour les fichiers non suivis), **désindexer** (`git restore --staged` pour conserver les modifications mais les désindexer), **modifier** le dernier commit (changer son message ou y ajouter — avec le caveat important de ne pas modifier les commits poussés car cela réécrit l'historique), et annuler **les modifications validées**. Pour annuler les commits, comprendre la **distinction critique entre revert et reset** est particulièrement important : **`revert`** crée un nouveau commit qui annule un commit précédent et est **sûr pour l'historique partagé/public** (cela ne réécrit pas l'historique, donc cela ne perturbera pas les autres), tandis que **`reset`** déplace le pointeur de branche et **réécrit l'historique**, le rendant approprié uniquement pour **les commits locaux, non poussés** (et `reset --hard` est destructif, supprimant les modifications). La règle — utiliser `revert` pour les commits que d'autres peuvent avoir, `reset` uniquement pour le nettoyage local — est vitale car réécrire l'historique partagé (via reset sur les commits poussés) cause des problèmes sérieux pour les collaborateurs. Connaître ces options empêche à la fois de perdre du travail (en utilisant des commandes destructives sans réfléchir) et de perturber la collaboration (en réécrivant l'historique partagé). Puisque l'annulation de modifications est un besoin courant et inévitable et que Git offre plusieurs approches situation-spécifiques avec d'importantes implications de sécurité (notamment revert vs reset pour l'historique partagé), savoir comment annuler les modifications dans Git — le bon outil pour chaque scénario et la distinction cruciale revert-vs-reset — est une connaissance pratique précieuse, fréquemment appliquée pour travailler avec confiance et sécurité avec Git, une compétence qui transforme l'anxiété des erreurs en récupération routinière tout en évitant le piège sérieux de réécrire l'historique partagé.