Parcourir les aide-mémoire · Git

Technologie: GitCatégorie: Gestion de versionsNiveau: IntermédiaireMis à jour

Annuler des modifications en toute sécurité

Annulez des modifications Git en toute sécurité en choisissant la bonne commande pour les modifications non indexées, les modifications indexées, les commits locaux ou l’historique partagé, sans détruire votre travail par accident.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. Inspecter avant d’annuler
  5. Annuler les modifications non indexées d’un fichier suivi
  6. Annuler toutes les modifications non indexées des fichiers suivis
  7. Restaurer un fichier depuis HEAD
  8. Restaurer un fichier depuis un commit plus ancien
  9. Restaurer un fichier depuis une autre branche
  10. Désindexer un fichier en conservant ses modifications
  11. Tout désindexer en conservant toutes les modifications
  12. Désindexer certains blocs (hunks)
  13. Corriger le message du dernier commit local
  14. Ajouter un fichier oublié au dernier commit local
  15. Supprimer le dernier commit local en gardant les modifications indexées
  16. Supprimer le dernier commit local en gardant les modifications non indexées
  17. Comprendre les modes de reset
  18. Éviter git reset --hard pour le nettoyage courant
  19. Annuler un commit partagé avec git revert
  20. Faire un revert du dernier commit partagé
  21. Faire un revert d’une plage contiguë dans un seul nouveau commit
  22. Abandonner un revert en conflit
  23. Poursuivre un revert en conflit
  24. Faire un revert d’un commit de merge avec prudence
  25. Abandonner les modifications indexées et non indexées d’un fichier suivi
  26. Récupérer un commit supprimé par un reset accidentel
  27. Récupérer une branche locale supprimée
  28. Récupérer après un rebase ou un amend accidentel
  29. Récupérer un fichier sans déplacer la branche
  30. Annuler seulement une partie d’un fichier non indexé
  31. Inspecter un commit avant de l’annuler
  32. Comparer ce qui disparaîtrait avant de faire reculer une branche
  33. Faire un reset vers un commit local précis en conservant les modifications
  34. Faire un hard reset vers une branche distante uniquement si le travail local est jetable
  35. Analyser un push rejeté au lieu de supprimer le travail local
  36. Annuler la suppression d’un fichier suivi avant le commit
  37. Prévisualiser le nettoyage des fichiers non suivis
  38. Supprimer les fichiers non suivis uniquement de façon délibérée
  39. Être particulièrement prudent avec les fichiers ignorés
  40. Utiliser stash quand vous ne savez pas si le travail doit être abandonné
  41. Retirer un commit de l’historique privé
  42. Annuler un merge accidentel avant son commit
  43. Annuler un merge local terminé
  44. Annuler un cherry-pick en cours
  45. Annuler un cherry-pick partagé terminé
  46. Préférer revert pour les commits de rollback en production
  47. Vérifier après l’annulation
  48. Interpréter le résultat
  49. Points à vérifier
  50. Vous ne savez pas si une modification est indexée
  51. Un reset a supprimé un commit dont vous avez encore besoin
  52. Le revert a produit des conflits
  53. git restore n’a pas supprimé un fichier non suivi
  54. Le push est rejeté après un reset local
  55. Annuler un commit casse du code plus récent
  56. Notes de production
  57. L’historique partagé doit généralement être annulé avec revert
  58. Reset est avant tout un outil pour l’historique local
  59. Le reflog est local
  60. Les fichiers non suivis peuvent n’avoir aucun moyen de récupération dans Git
  61. Les branches de sauvegarde ne coûtent presque rien
  62. Un revert réussi peut tout de même casser l’application
  63. Erreurs fréquentes
  64. 1. Commencer par git reset --hard
  65. 2. Utiliser reset sur un historique partagé
  66. 3. Utiliser revert alors que vous vouliez réécrire un historique local privé
  67. 4. Supposer que git restore peut récupérer des fichiers non suivis
  68. 5. Lancer git clean -fd sans prévisualisation
  69. 6. Modifier (amend) un commit partagé à la légère
  70. 7. Faire un revert d’un merge sans comprendre -m
  71. 8. Faire un force push après un reset sans vérifier les modifications distantes
  72. 9. Supprimer une branche parce que le commit est « probablement ailleurs »
  73. 10. Sauter la vérification après l’annulation
  74. Étape suivante
  75. Pour aller plus loin

Problème

Vous avez modifié le mauvais fichier, indexé trop de choses, fait un commit par erreur, ou vous devez annuler une modification déjà partagée.

Git propose plusieurs commandes aux noms proches :

restore
reset
revert
checkout
reflog

mais elles agissent sur des parties différentes de l’état de Git.

Le risque est d’utiliser une commande destructive avant d’avoir identifié où se trouve la modification indésirable :

  • uniquement dans l’arbre de travail
  • dans l’index (zone de préparation, ou staging area)
  • dans un commit local
  • dans l’historique publié/partagé

L’objectif est d’annuler sur la plus petite portée possible tout en préservant la possibilité de récupération.

Réponse rapide

Suivez cet arbre de décision :

Modification de fichier non indexée
→ git restore <file>

Indexé par erreur
→ git restore --staged <file>

Dernier commit local erroné, garder les modifications indexées
→ git reset --soft HEAD~1

Dernier commit local erroné, garder les modifications non indexées
→ git reset HEAD~1

Dernier commit local à corriger légèrement
→ git commit --amend

Commit partagé/poussé à annuler
→ git revert <commit>

Vous pensez avoir perdu un commit local
→ git reflog

Avant d’annuler quoi que ce soit :

git status
git diff
git diff --cached
git log --oneline --decorate -10

Ne commencez pas par :

git reset --hard

sauf si vous voulez délibérément abandonner les modifications locales suivies.

Code / commandes

Inspecter avant d’annuler

git status
git diff
git diff --cached
git log --oneline --decorate -10

Ces commandes présentent peu de risque et vous indiquent si la modification indésirable se trouve dans l’arbre de travail, dans l’index ou dans l’historique des commits.

Annuler les modifications non indexées d’un fichier suivi

git restore src/app.py

Cette commande abandonne les modifications non indexées de ce fichier.

Vérifiez d’abord :

git diff src/app.py

Annuler toutes les modifications non indexées des fichiers suivis

git restore .

Cette commande peut abandonner de nombreuses modifications locales. Examinez d’abord git status et git diff.

Restaurer un fichier depuis HEAD

git restore \
  --source=HEAD \
  -- src/app.py

Restaurer un fichier depuis un commit plus ancien

git restore \
  --source=HEAD~1 \
  -- src/app.py

Seul le fichier de l’arbre de travail est modifié. Examinez-le, puis faites un commit séparément si vous restaurez volontairement l’ancienne version.

Restaurer un fichier depuis une autre branche

git restore \
  --source=origin/main \
  -- src/app.py

Utilisez cette commande lorsqu’un fichier doit correspondre à une autre branche sans déplacer votre branche courante.

Désindexer un fichier en conservant ses modifications

git restore --staged src/app.py

Le fichier reste modifié dans l’arbre de travail.

Tout désindexer en conservant toutes les modifications

git restore --staged .

Utile avant de réorganiser une grosse modification indexée en commits plus petits.

Désindexer certains blocs (hunks)

git reset -p

Puis réindexez uniquement les bons morceaux :

git add -p
git diff --cached

Corriger le message du dernier commit local

git commit --amend

Cette commande crée un nouvel ID de commit. Utilisez-la librement tant que le commit n’est pas partagé.

Ajouter un fichier oublié au dernier commit local

git add src/config.py
git commit --amend --no-edit

Ne modifiez pas à la légère (amend) des commits dont d’autres personnes dépendent déjà.

Supprimer le dernier commit local en gardant les modifications indexées

git reset --soft HEAD~1

Résultat :

commit retiré de l’historique de la branche locale
les modifications restent indexées

Supprimer le dernier commit local en gardant les modifications non indexées

git reset HEAD~1

Le mode par défaut est --mixed.

Résultat :

commit retiré
les modifications restent dans l’arbre de travail
index réinitialisé

Comprendre les modes de reset

--soft
→ déplace HEAD/la branche
→ conserve l’index
→ conserve l’arbre de travail

--mixed
→ déplace HEAD/la branche
→ réinitialise l’index
→ conserve l’arbre de travail

--hard
→ déplace HEAD/la branche
→ réinitialise l’index
→ réinitialise l’arbre de travail

--hard est l’option destructive.

Éviter git reset --hard pour le nettoyage courant

git reset --hard HEAD

Cette commande abandonne les modifications suivies, indexées ou non.

Avant de l’utiliser :

git status
git diff
git diff --cached

Si le commit courant peut avoir de l’importance, créez d’abord une branche de sauvegarde :

git branch backup-before-reset

Annuler un commit partagé avec git revert

git revert <commit>

Exemple :

git revert a1b2c3d

Cette commande crée un nouveau commit qui inverse le commit sélectionné.

Utilisez-la pour l’historique partagé, car les ID de commit existants restent intacts.

Faire un revert du dernier commit partagé

git revert HEAD

Faire un revert d’une plage contiguë dans un seul nouveau commit

git revert --no-commit <oldest>^..<newest>

Vérifiez :

git status
git diff --cached

Puis faites le commit :

git commit -m "Revert problematic release changes"

Abandonner un revert en conflit

git revert --abort

Poursuivre un revert en conflit

Résolvez les fichiers, puis :

git add path/to/file
git revert --continue

Faire un revert d’un commit de merge avec prudence

git revert -m 1 <merge-commit>

-m sélectionne le parent principal (mainline). Ne le devinez pas.

Inspectez d’abord le merge :

git show --no-patch --pretty=%P <merge-commit>

Un mauvais parent peut annuler le mauvais côté du merge.

Abandonner les modifications indexées et non indexées d’un fichier suivi

git restore \
  --source=HEAD \
  --staged \
  --worktree \
  -- src/app.py

Cette commande est destructive pour ce fichier.

Récupérer un commit supprimé par un reset accidentel

git reflog

Exemple :

e4f5a6b HEAD@{0}: reset: moving to HEAD~1
a1b2c3d HEAD@{1}: commit: Add report engine

Inspectez :

git show a1b2c3d

Récupérez en toute sécurité :

git switch -c recovery a1b2c3d

Récupérer une branche locale supprimée

git reflog
git switch -c recovered-feature <commit>

Supprimer une branche supprime généralement le nom de la branche, pas immédiatement l’objet commit.

Récupérer après un rebase ou un amend accidentel

git reflog

Retrouvez l’ancienne pointe de la branche, inspectez-la et créez une branche de récupération temporaire :

git switch -c before-rewrite <old-commit>

Récupérer un fichier sans déplacer la branche

git restore \
  --source=<commit> \
  -- path/to/file

Préférez cette approche à la réinitialisation de toute une branche juste pour récupérer un fichier.

Annuler seulement une partie d’un fichier non indexé

git restore -p src/app.py

Git vous présente les blocs (hunks) et vous laisse choisir ceux à abandonner.

Inspecter un commit avant de l’annuler

git show <commit>

Résumé uniquement :

git show --stat <commit>

Comparer ce qui disparaîtrait avant de faire reculer une branche

git diff <commit>..HEAD

Faire un reset vers un commit local précis en conservant les modifications

Garder indexé :

git reset --soft <commit>

Garder non indexé :

git reset <commit>

À utiliser uniquement lorsque la réécriture de l’historique est acceptable.

Faire un hard reset vers une branche distante uniquement si le travail local est jetable

git fetch origin
git reset --hard origin/main

Avant de le faire :

git status
git log --oneline origin/main..HEAD
git branch backup-before-hard-reset

Ne le faites pas simplement parce qu’un push a été rejeté.

Analyser un push rejeté au lieu de supprimer le travail local

git fetch origin
git log \
  --oneline \
  --graph \
  --decorate \
  HEAD \
  origin/<branch>

Comprenez d’abord la divergence.

Annuler la suppression d’un fichier suivi avant le commit

Si elle n’est pas indexée :

git restore path/to/file

Si la suppression est indexée :

git restore --staged path/to/file
git restore path/to/file

Prévisualiser le nettoyage des fichiers non suivis

git restore ne peut ni récupérer ni supprimer des fichiers que Git n’a jamais suivis.

Prévisualisez :

git clean -n

Inclure les répertoires :

git clean -nd

Supprimer les fichiers non suivis uniquement de façon délibérée

git clean -f

Inclure les répertoires non suivis :

git clean -fd

Ces commandes sont destructives.

Être particulièrement prudent avec les fichiers ignorés

Prévisualisez :

git clean -nx

git clean -x inclut les fichiers ignorés et peut supprimer des fichiers d’environnement, des artefacts générés, des caches et la configuration locale.

Utiliser stash quand vous ne savez pas si le travail doit être abandonné

git stash push -u -m "Safety copy before cleanup"

Puis inspectez plus tard :

git stash list
git stash show -p stash@{0}

Retirer un commit de l’historique privé

Pour un historique local/non partagé :

git rebase -i HEAD~5

Remplacez :

pick a1b2c3d Bad commit

par :

drop a1b2c3d Bad commit

Cette opération réécrit les ID des commits concernés.

Annuler un merge accidentel avant son commit

git merge --abort

Annuler un merge local terminé

S’il n’est pas publié, conservez d’abord un pointeur de récupération :

git branch backup-before-reset
git reset --hard HEAD~1

Si le merge est déjà partagé, faites plutôt un revert du merge.

Annuler un cherry-pick en cours

git cherry-pick --abort

Annuler un cherry-pick partagé terminé

git revert HEAD

Préférer revert pour les commits de rollback en production

Pour une modification partagée et déployée :

git revert <commit>
git push

Cela préserve un rollback auditable.

Vérifier après l’annulation

Relancez les vérifications utiles :

git status
git diff
git diff --cached
git log --oneline --decorate -10

Une commande réussie ne prouve pas que vous avez annulé ce que vous vouliez annuler.

Interpréter le résultat

Situation Commande la plus sûre Préserve les modifications ? Réécrit l’historique ?
Modification de fichier non indexée git restore <file> Non pour les modifications sélectionnées Non
Indexé par erreur git restore --staged <file> Oui Non
Dernier commit local, garder indexé git reset --soft HEAD~1 Oui Oui
Dernier commit local, garder non indexé git reset HEAD~1 Oui Oui
Dernier commit local à corriger légèrement git commit --amend Oui Oui
Commit partagé à annuler git revert <commit> Oui Non
Commit local perdu git reflog Aide à la récupération Non
Supprimer des fichiers non suivis git clean Non Non

La distinction importante est la suivante :

restore
→ arbre de travail / index

reset
→ branche + index + éventuellement arbre de travail

revert
→ nouveau commit qui inverse l’historique partagé existant

Points à vérifier

Vous ne savez pas si une modification est indexée

Exécutez :

git status
git diff
git diff --cached

Ne devinez pas.

Un reset a supprimé un commit dont vous avez encore besoin

Exécutez :

git reflog

L’ancien commit est peut-être encore récupérable.

Le revert a produit des conflits

Le dépôt a changé depuis le commit d’origine.

Résolvez avec soin la modification inverse souhaitée, puis poursuivez le revert.

git restore n’a pas supprimé un fichier non suivi

C’est normal.

Utilisez :

git clean -n

pour prévisualiser le nettoyage des fichiers non suivis.

Le push est rejeté après un reset local

Vous avez réécrit l’historique de la branche.

Ne faites pas de force push avant d’avoir vérifié si la branche distante est partagée.

Annuler un commit casse du code plus récent

Des commits ultérieurs peuvent en dépendre.

Inspectez la chaîne de dépendances avant de faire un revert d’autres parties de l’historique.

Notes de production

L’historique partagé doit généralement être annulé avec revert

Cela préserve :

  • la piste d’audit
  • les ID de commit
  • les références CI/CD
  • l’historique des collaborateurs

Reset est avant tout un outil pour l’historique local

Utilisez-le pour des commits qui ne sont pas largement partagés.

Le reflog est local

git reflog enregistre les déplacements des références locales.

Ce n’est pas un journal d’audit distant/global, et la récupération dépend de la conservation locale du reflog et des objets.

Les fichiers non suivis peuvent n’avoir aucun moyen de récupération dans Git

Si un fichier non suivi n’a jamais fait l’objet d’un commit ni d’un stash et qu’il est supprimé avec git clean, Git ne peut normalement pas le restaurer.

Les branches de sauvegarde ne coûtent presque rien

Avant toute opération risquée :

git branch backup-before-change

Cela peut rendre la récupération triviale.

Un revert réussi peut tout de même casser l’application

Le code de rollback peut entrer en conflit avec :

  • les migrations de base de données
  • les contrats d’API
  • l’état du déploiement
  • les feature flags
  • les commits ultérieurs qui en dépendent

Exécutez les tests et validez le plan de livraison/de rollback.

Erreurs fréquentes

1. Commencer par git reset --hard

Cela peut détruire inutilement du travail local suivi.

2. Utiliser reset sur un historique partagé

Cela réécrit l’historique de la branche et peut perturber les collaborateurs.

3. Utiliser revert alors que vous vouliez réécrire un historique local privé

Revert conserve le commit d’origine et ajoute un commit inverse.

Pour un nettoyage non publié, reset/rebase peut donner un résultat plus propre.

4. Supposer que git restore peut récupérer des fichiers non suivis

Il ne peut pas restaurer un contenu que Git n’a jamais suivi.

5. Lancer git clean -fd sans prévisualisation

Des fichiers non suivis peuvent être supprimés définitivement.

6. Modifier (amend) un commit partagé à la légère

L’ID du commit change.

7. Faire un revert d’un merge sans comprendre -m

Vous pouvez inverser le mauvais côté du merge.

8. Faire un force push après un reset sans vérifier les modifications distantes

Vous pouvez écraser les commits de vos coéquipiers.

9. Supprimer une branche parce que le commit est « probablement ailleurs »

Vérifiez d’abord.

10. Sauter la vérification après l’annulation

Git a peut-être fait exactement ce que vous avez demandé, mais pas ce que vous vouliez.

Étape suivante

Partez de l’état actuel pour choisir l’annulation sûre la plus limitée.

  • Une modification non indexée doit disparaître → git restore <file>.
  • Un fichier a été indexé par erreur → git restore --staged <file>.
  • Vous devez découper le travail indexé → indexez/désindexez par blocs (patch).
  • Le dernier commit local doit être refait → utilisez un reset soft ou mixed.
  • Le dernier commit local doit être légèrement corrigé → faites un amend avant de le partager.
  • Un commit publié doit être inversé → git revert.
  • Un merge partagé doit être annulé → inspectez les parents du merge, puis faites un revert du merge.
  • Vous pensez avoir perdu du travail → inspectez git reflog.
  • Des fichiers non suivis doivent être nettoyés → prévisualisez avec git clean -n.
  • Vous ne savez pas si le travail compte → créez une branche de sauvegarde ou un stash avant toute commande destructive.

← Tous les aide-mémoire