Parcourir les aide-mémoire · Git
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
- Problème
- Réponse rapide
- Code / commandes
- Inspecter avant d’annuler
- Annuler les modifications non indexées d’un fichier suivi
- Annuler toutes les modifications non indexées des fichiers suivis
- Restaurer un fichier depuis HEAD
- Restaurer un fichier depuis un commit plus ancien
- Restaurer un fichier depuis une autre branche
- Désindexer un fichier en conservant ses modifications
- Tout désindexer en conservant toutes les modifications
- Désindexer certains blocs (hunks)
- Corriger le message du dernier commit local
- Ajouter un fichier oublié au dernier commit local
- Supprimer le dernier commit local en gardant les modifications indexées
- Supprimer le dernier commit local en gardant les modifications non indexées
- Comprendre les modes de reset
- Éviter git reset --hard pour le nettoyage courant
- Annuler un commit partagé avec git revert
- Faire un revert du dernier commit partagé
- Faire un revert d’une plage contiguë dans un seul nouveau commit
- Abandonner un revert en conflit
- Poursuivre un revert en conflit
- Faire un revert d’un commit de merge avec prudence
- Abandonner les modifications indexées et non indexées d’un fichier suivi
- Récupérer un commit supprimé par un reset accidentel
- Récupérer une branche locale supprimée
- Récupérer après un rebase ou un amend accidentel
- Récupérer un fichier sans déplacer la branche
- Annuler seulement une partie d’un fichier non indexé
- Inspecter un commit avant de l’annuler
- Comparer ce qui disparaîtrait avant de faire reculer une branche
- Faire un reset vers un commit local précis en conservant les modifications
- Faire un hard reset vers une branche distante uniquement si le travail local est jetable
- Analyser un push rejeté au lieu de supprimer le travail local
- Annuler la suppression d’un fichier suivi avant le commit
- Prévisualiser le nettoyage des fichiers non suivis
- Supprimer les fichiers non suivis uniquement de façon délibérée
- Être particulièrement prudent avec les fichiers ignorés
- Utiliser stash quand vous ne savez pas si le travail doit être abandonné
- Retirer un commit de l’historique privé
- Annuler un merge accidentel avant son commit
- Annuler un merge local terminé
- Annuler un cherry-pick en cours
- Annuler un cherry-pick partagé terminé
- Préférer revert pour les commits de rollback en production
- Vérifier après l’annulation
- Interpréter le résultat
- Points à vérifier
- Vous ne savez pas si une modification est indexée
- Un reset a supprimé un commit dont vous avez encore besoin
- Le revert a produit des conflits
- git restore n’a pas supprimé un fichier non suivi
- Le push est rejeté après un reset local
- Annuler un commit casse du code plus récent
- Notes de production
- L’historique partagé doit généralement être annulé avec revert
- Reset est avant tout un outil pour l’historique local
- Le reflog est local
- Les fichiers non suivis peuvent n’avoir aucun moyen de récupération dans Git
- Les branches de sauvegarde ne coûtent presque rien
- Un revert réussi peut tout de même casser l’application
- Erreurs fréquentes
- 1. Commencer par git reset --hard
- 2. Utiliser reset sur un historique partagé
- 3. Utiliser revert alors que vous vouliez réécrire un historique local privé
- 4. Supposer que git restore peut récupérer des fichiers non suivis
- 5. Lancer git clean -fd sans prévisualisation
- 6. Modifier (amend) un commit partagé à la légère
- 7. Faire un revert d’un merge sans comprendre -m
- 8. Faire un force push après un reset sans vérifier les modifications distantes
- 9. Supprimer une branche parce que le commit est « probablement ailleurs »
- 10. Sauter la vérification après l’annulation
- Étape suivante
- 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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.