Infra16 min de lecture
Git sans prise de tête : stash, amend, fetch, rebase, reflog
Git sans peur : git stash, git mv, commit --amend, fetch ou pull, rebase ou merge, rebase interactif, push --force-with-lease et le reflog pour presque tout annuler.

Git te fait peur ? Tu t'arrêtes à git add, git commit et git push, et le reste des commandes t'angoisse ? Tu n'es pas seul.
Git paraît intimidant parce que presque chaque commande agit à un endroit différent, et personne ne te montre la carte. Une fois que tu comprends où agit chaque commande, Git cesse d'être un monstre et devient un outil qui te sauve chaque semaine.
J'ai publié la première version de cet article sur Medium en 2023, en portugais. Voici la version revue : de meilleures explications, quelques erreurs de ma part corrigées et chaque commande testée à nouveau.
J'explique ici les commandes que j'utilise le plus au-delà du commit et du push, avec des exemples que j'ai vraiment lancés dans un dépôt de test : git stash, git mv, git commit --amend, git fetch, git rebase (y compris l'interactif) et, à la fin, git reflog, qui annule presque n'importe quelle erreur.
TL;DR#
git stashrange dans un tiroir les modifications pas encore commitées, etgit stash poples rend. Les nouveaux fichiers n'y entrent qu'avec-u.git mvest un raccourci pourmv+git add. Git n'enregistre pas les renommages : il les déduit du contenu. Pour voir l'historique d'un fichier renommé, utilisegit log --follow.git commit --amendremplace le dernier commit par un nouveau. Parfait pour un fichier oublié ou un mauvais message, tant que le commit n'a pas été poussé.git fetchtélécharge et met à jourorigin/main, rien de plus. Il ne touche pas à ton code.git pull, c'estfetch+merge(ourebase).git rebaserejoue tes commits sur une autre base et garde un historique en ligne droite. Le mode interactif (-i) fusionne, modifie et réordonne les commits.- Tu as réécrit un historique déjà poussé ? Utilise
git push --force-with-lease, jamais--force(ni+branche). Dans mon test,+maina effacé le commit d'une collègue sans prévenir. - Ça a mal tourné ?
git reflogliste tous les endroits où tonHEADest passé, etgit reset --hard HEAD@{n}t'y ramène.
La carte : où agit chaque commande#
Avant les commandes, le schéma qui m'a fait comprendre Git. Il y a cinq endroits, et chaque commande déplace des modifications de l'un à l'autre :
- Répertoire de travail : les fichiers que tu modifies.
- Stash : un tiroir pour garder des modifications sans les commiter.
- Index (ou staging) : ce qui entrera dans le prochain commit, après
git add. - Dépôt local : tes commits, sur ta machine.
- Distant : GitHub (ou GitLab, Bitbucket). Ta machine garde une copie de ce qu'elle y a vu en dernier,
origin/main.
Garde cette carte en tête. Presque toutes les confusions avec Git viennent de l'idée qu'une commande agit à un endroit alors qu'elle agit à un autre.
git stash : le tiroir#
Tu es en plein milieu d'une tâche, avec des fichiers modifiés, et tu dois changer de branche pour corriger un bug urgent. Commiter un travail à moitié fini, ce n'est pas joli. git stash range les modifications dans un tiroir et laisse le répertoire propre :
git stash push -m "wip: signup form"
git switch hotfix/login
# ...fix the bug, commit, push...
git switch feature/signup
git stash popUn détail qui piège beaucoup de monde : un nouveau fichier, que Git ne suit pas encore, ne va pas dans le tiroir. Dans mon test, après git stash, le nouveau fichier était toujours là :
$ git stash push -m "wip: signup form"
Saved working directory and index state On main: wip: signup form
$ git status --short
?? draft.txtPour emporter aussi les nouveaux fichiers, utilise -u (pour --include-untracked) :
git stash push -u -m "wip: signup form"Le
git stash save "nom"des vieux tutoriels est obsolète. La façon actuelle de nommer un stash, c'estgit stash push -m "nom".
pop ou apply ?#
Les deux remettent les modifications du tiroir dans le répertoire de travail. La différence, c'est ce qui arrive au tiroir :
git stash applyapplique et garde le stash dans la liste. Pratique pour appliquer la même modification sur plusieurs branches.git stash popapplique et supprime le stash de la liste. C'estapplysuivi degit stash drop.
À une exception près : si le pop provoque un conflit, il ne supprime rien. Git te le dit lui-même :
Auto-merging app.txt
CONFLICT (content): Merge conflict in app.txt
...
The stash entry is kept in case you need it again.Tu résous le conflit, puis tu supprimes le stash avec git stash drop quand tu es sûr de ne plus en avoir besoin.
Les autres commandes du tiroir :
git stash list # every stash, newest first: stash@{0}, stash@{1}...
git stash show -p stash@{1} # what is inside one of them
git stash pop stash@{1} # bring back a specific one
git stash drop stash@{1} # delete onegit mv : renommer et déplacer#
git mv renomme ou déplace un fichier et prépare déjà la modification pour le commit :
git mv index.html home.html # rename
git mv index.html public/ # move
git mv scripts src/scripts # folders tooLa première version de cet article disait que git mv sert à « ne pas perdre l'historique ». Je le croyais aussi, et ce n'est pas tout à fait ça. Git n'enregistre pas les renommages. Il enregistre le contenu des fichiers à chaque commit et, au moment de l'afficher, il compare : si un fichier a disparu et qu'un autre presque identique est apparu, il en conclut qu'il a été renommé.
C'est pourquoi mv + git add -A donne exactement le même résultat. J'ai testé les deux, et git status affiche la même chose :
$ git mv index.html home.html
$ git status --short
R index.html -> home.html
$ mv home.html start.html && git add -A
$ git status --short
R home.html -> start.htmlLe R, c'est Git qui dit « j'ai détecté un renommage ». git mv t'épargne juste une étape.
Et l'historique ? Le git log d'un fichier s'arrête au renommage. Pour suivre le fichier à travers ses anciens noms, utilise --follow :
$ git log --oneline -- home.html
3b727de rename index to home
$ git log --oneline --follow -- home.html
3b727de rename index to home
a366c0e add index pageAstuce : renomme dans un commit et modifie le contenu dans un autre. Si tu renommes et réécris la moitié du fichier dans le même commit, Git risque de ne pas reconnaître le même fichier, et là même --follow ne retrouve pas l'historique.
Tu as changé d'avis avant de commiter ? Renomme-le dans l'autre sens avec git mv home.html index.html.
git commit --amend : corriger le dernier commit#
« git amend » n'existe pas comme commande. Ce qui existe, c'est l'option --amend de git commit, qui remplace le dernier commit par un nouveau.
Tu as oublié un fichier :
git add forgotten-file.ts
git commit --amend --no-edit # same message, new contentTu t'es trompé de message :
git commit --amend -m "feat: rename the home page"Ce que peu de gens remarquent, c'est que le commit n'est pas modifié, il est remplacé. Regarde le hash changer à chaque --amend dans mon test :
22b393b rename again # before
f5024f2 rename again # after --amend --no-edit
4c2a0e4 feat: rename the home page # after --amend -mD'où la règle : n'utilise --amend que sur un commit pas encore poussé. S'il est déjà sur le distant et que quelqu'un l'a récupéré, tu auras besoin d'un push forcé (on en parle à la fin) et cette personne se retrouvera avec un commit qui n'existe plus.
git fetch : regarder avant de rapatrier#
git fetch télécharge les nouveautés du distant et met à jour origin/main, cette copie du distant qui vit sur ta machine. Il ne touche ni à ta branche ni à tes fichiers. C'est comme lire les gros titres sans ouvrir le journal.
$ git fetch origin
From ../origin
4c2a0e4..8d7de9d main -> origin/main
$ git status -sb
## main...origin/main [behind 1]
$ git log --oneline main..origin/main
8d7de9d feat: add the profile pagemain..origin/main liste les commits qui sont sur le distant mais pas encore sur ta main. Tu vois ce qui est arrivé avant de décider de le rapatrier.
Et git pull ? C'est fetch suivi d'un merge (ou d'un rebase, si tu le configures). Il télécharge et fusionne dans ta branche, tout d'un coup :
git pull # fetch + merge
git pull --rebase # fetch + rebaseJe préfère faire un fetch d'abord quand la branche est partagée ou quand je n'ai pas mis à jour depuis des jours. Je vois la taille du changement avant que le conflit ne me tombe dessus.
Récupérer les changements d'un autre dépôt#
fetch marche avec n'importe quel distant, pas seulement origin. Exemple : tu as un fork et tu veux les nouveautés du projet d'origine. Ajoute-le comme deuxième distant :
git remote add upstream https://github.com/original-author/project.git
git fetch upstream
git merge upstream/mainupstream n'est qu'un surnom, comme origin. Ensuite, tu résous les conflits (s'il y en a), tu commites et tu pousses sur ton fork.
git rebase : rejouer tes commits sur une autre base#
Tu as créé une branche, fait deux commits, et pendant ce temps quelqu'un a poussé un nouveau commit sur main. Pour récupérer ce qui est arrivé sur main, il y a deux façons :
git mergecrée un commit de merge qui réunit les deux historiques. Rien n'est réécrit.git rebaseprend tes commits et les rejoue un par un par-dessus la nouvellemain, comme si tu avais commencé la branche maintenant. L'historique reste en ligne droite.
Dans mon test, ma main locale avait deux commits qu'origin/main n'avait pas, et origin/main en avait un que je n'avais pas :
* 0df7909 wip
* 6f1f89e add z
| * 8d7de9d feat: add the profile page (origin/main)
|/
* 4c2a0e4 feat: rename the home pageAprès git rebase origin/main :
* 2b2bea3 wip
* 4f1c163 add z
* 8d7de9d feat: add the profile page
* 4c2a0e4 feat: rename the home pageMes deux commits sont passés au-dessus, en ligne droite, avec de nouveaux hashs (0df7909 est devenu 2b2bea3). C'est le point clé du rebase : il ne déplace pas les commits, il crée de nouveaux commits avec le même contenu.
Lequel utiliser ? Aucun n'est meilleur, et beaucoup d'équipes en choisissent un par défaut. La seule règle qui compte : ne fais pas de rebase sur des commits que d'autres ont déjà récupérés. Sur ta propre branche, avant d'ouvrir la PR, vas-y.
Rebase interactif : ranger les commits avant la PR#
git rebase -i ouvre une liste des commits et te laisse dire quoi faire de chacun :
git rebase -i HEAD~3 # the last 3 commitspick 4f1c163 # add z
pick 2b2bea3 # wip
pick 060be7b # fix typo
# Rebase 8d7de9d..060be7b onto 8d7de9d (3 commands)Sous cette liste, Git explique lui-même les commandes. Celles que j'utilise le plus :
pick: garde le commit tel quel.reword: le garde, mais ouvre l'éditeur pour changer le message.edit: s'arrête sur ce commit pour que tu changes ce que tu veux (fichiers, auteur), puisgit rebase --continue.squash: le fusionne avec le commit du dessus et combine les messages.fixup: le fusionne avec le commit du dessus et jette son message.drop: supprime le commit.
Tu changes le mot en début de ligne, tu enregistres et tu fermes. Pour fondre wip et fix typo dans le commit du dessus, par exemple :
pick 4f1c163 # add z
fixup 2b2bea3 # wip
fixup 060be7b # fix typoPour modifier plusieurs messages, remplace pick par reword. Git s'arrête sur chacun et ouvre l'éditeur.
Si l'éditeur ne s'ouvre pas (ou si Vim s'ouvre et que tu ne sais pas en sortir), configure VS Code :
git config --global core.editor "code --wait"Le --wait fait attendre Git jusqu'à ce que tu fermes l'onglet.
Des commits avec le mauvais nom ou le mauvais e-mail#
Un classique sur un ordinateur neuf : tu as oublié de configurer user.name et user.email, et tes commits sont partis en root@localhost. D'abord, configure-les :
git config --global user.name "Your Name"
git config --global user.email "you@example.com"Ensuite, pour corriger uniquement le dernier commit :
git commit --amend --no-edit --reset-authorPour en corriger plusieurs, au lieu de marquer edit un par un comme je le faisais, utilise --exec, qui lance une commande après chaque commit rejoué :
git rebase origin/main --exec "git commit --amend --no-edit --reset-author"Note le origin/main au lieu de HEAD~10. Il ne prend que les commits qui ne sont pas encore sur le distant, autrement dit, seulement les tiens. Dans mon test, j'ai utilisé HEAD~2 et l'un des deux était le commit d'une collègue, déjà sur le distant. Le rebase a remplacé son auteur par moi sans demander. Compter les commits avec HEAD~n, c'est facile de se tromper. Utiliser la bonne base, non.
Push forcé sans effacer le travail des autres#
Toute commande qui réécrit l'historique (--amend, rebase) crée de nouveaux commits. Si les anciens étaient déjà sur le distant, le git push normal est refusé, parce que le distant devrait jeter des commits. C'est là qu'arrive le push forcé.
La première version de cet article conseillait git push origin +nom-de-la-branche. Le + fait la même chose que --force : il écrase le distant avec ta version, sans regarder ce qu'il y a. J'ai fait le test : une collègue a poussé un commit sur la branche pendant que je réécrivais la mienne. Avec +main, le push est passé, et son commit a disparu du distant :
$ git push origin +main
+ c0a4ca7...db2256b main -> main (forced update)Avec --force-with-lease, le même push a été refusé :
$ git push --force-with-lease origin main
! [rejected] main -> main (stale info)
error: failed to push some refs to '../origin.git'--force-with-lease n'écrase que si le distant est toujours identique à la dernière version que tu as vue (ton origin/main). Si quelqu'un a poussé quelque chose entre-temps, il refuse, et tu fais git fetch, tu récupères le commit de cette personne et tu réessaies.
Une précaution : si tu lances git fetch juste avant, ton origin/main est déjà à jour, et le lease laisse passer le push même si tu n'as pas intégré le commit de cette personne. Pour boucher ce trou, il y a --force-if-includes, qui vérifie que ce qui est sur le distant est aussi dans ta branche. Je l'ai testé : après un git fetch, --force-with-lease seul est passé par-dessus le nouveau commit de la collègue, et avec --force-if-includes en plus le push a été refusé :
$ git push --force-with-lease --force-if-includes origin main
! [rejected] main -> main (remote ref updated since checkout)Un alias évite de taper tout ça à chaque fois :
git config --global alias.pushf "push --force-with-lease --force-if-includes"
git pushfEt la règle habituelle : un push forcé sur ta branche, aucun souci. Sur une main partagée, mets-toi d'accord avec l'équipe avant (ou protège la main sur GitHub).
git reflog : le « annuler » de Git#
Un rebase a mal tourné ? Un reset --hard au mauvais endroit ? Pas de panique. Presque rien n'est vraiment perdu dans Git. git reflog garde chaque endroit où ton HEAD est passé, y compris des commits qui n'apparaissent plus dans git log :
$ git reflog -6
9eadb5e HEAD@{0}: rebase (finish): returning to refs/heads/main
9eadb5e HEAD@{1}: commit (amend): add z
3a8f3fa HEAD@{2}: rebase (pick): add z
f7db88b HEAD@{3}: commit (amend): feat: add the profile page
8d7de9d HEAD@{4}: rebase (start): checkout HEAD~2
fba2c8f HEAD@{5}: rebase (finish): returning to refs/heads/mainC'est comme ça que j'ai annulé le rebase qui avait changé l'auteur du commit de ma collègue. HEAD@{5} était l'état d'avant, donc :
git reset --hard HEAD@{5}Et tout est revenu comme avant. Avant toute opération qui te fait peur, tu peux aussi créer une branche de sécurité, qui ne coûte rien :
git branch backup/before-rebaseSi ça tourne mal, la branche est là, qui pointe vers le commit d'avant.
Le reflog est local et n'est pas éternel : par défaut, les entrées de commits qui ne sont sur aucune branche expirent au bout de 30 jours. Et une modification jamais commitée ni stashée, le reflog ne peut pas la sauver.
L'aide-mémoire à coller à côté de l'écran#
| Je veux... | Commande |
|---|---|
| Ranger ce qui n'est pas commité et nettoyer le répertoire | git stash push -u -m "name" |
| Le ressortir du tiroir | git stash pop |
| Renommer un fichier | git mv old new |
| Voir l'historique d'un fichier renommé | git log --follow -- file |
| Ajouter un fichier oublié au dernier commit | git add file && git commit --amend --no-edit |
| Voir ce qui est arrivé sur le distant, sans rien toucher | git fetch && git log main..origin/main |
| Mettre ma branche à jour en ligne droite | git rebase origin/main |
| Fusionner ou modifier des commits avant la PR | git rebase -i origin/main |
| Pousser un historique réécrit sans effacer celui des autres | git push --force-with-lease |
| Réparer une bêtise | git reflog et git reset --hard HEAD@{n} |
Conclusion#
Tu vois, ce n'est pas si sorcier. Quand tu vois les cinq endroits (répertoire, stash, index, dépôt local et distant), chaque commande n'est qu'une flèche entre eux. Et avec reflog en poche, se tromper ne fait plus peur, parce que presque tout peut s'annuler.
Tu veux t'entraîner sans risque ? Crée un dossier, lance git init et refais tous les exemples de cet article dedans. C'est comme ça que j'ai testé chaque commande ici.
Références#
À lire aussi

Infra12 min de lecture
Datadog de zéro : l'intégrer et lire le tableau de bord

Infra16 min de lecture
Économiser des tokens dans Claude Code avec rtk et graphify

Infra13 min de lecture
Comment effacer un disque dur ou SSD avant de le vendre