Commit sur la mauvaise branche Git

Vous avez commité sur main alors que vous auriez dû être sur votre feature branch ? C'est l'un des problèmes Git les plus fréquents. La bonne nouvelle : rien n'est perdu. Ce guide vous montre comment déplacer vos commits vers la bonne branche selon trois scénarios : dernier commit, plusieurs commits, et modifications non commitées.

Prérequis : Les branches en bref et Cherry-pick.

Ce que vous allez apprendre

• Déplacer le dernier commit sur la bonne branche avec reset + cherry-pick
• Déplacer plusieurs commits en chaîne vers une autre branche
• Utiliser stash + switch pour interrompre proprement un travail en cours
• Réorganiser des branches entières avec rebase --onto

Quel scénario vous concerne ?

Le bon outil dépend de deux choses : le nombre de commits à déplacer et le fait que le travail soit déjà commité ou encore dans le répertoire de travail. Repérez votre ligne dans le tableau, puis allez directement au scénario correspondant. Tant que rien n'a été poussé sur le dépôt distant, les quatre techniques sont réversibles grâce à git reflog, qui conserve la trace de toutes les positions passées de vos branches pendant 90 jours par défaut.

Situation	Solution	Difficulté
1 commit local sur la mauvaise branche	branch + reset	Facile
Plusieurs commits locaux	cherry-pick un par un	Moyen
Série de commits à déplacer	rebase --onto	Avancé
Modifications non commitées sur la mauvaise branche	stash + switch	Facile

Glissez pour voir

Scénario 1 : déplacer le dernier commit

Vous avez fait un commit sur main au lieu de feature/login :

main:    A - B - C - D (votre commit par erreur)

1. Créez la branche feature à partir de la position actuelle

   git branch feature/login

   La branche feature/login pointe maintenant sur le commit D.

2. Reculez main d'un commit

   git reset --hard HEAD~1

   main revient au commit C. Le commit D existe toujours, il est sur feature/login.

3. Basculez sur la bonne branche

   git switch feature/login

Résultat :

main:            A - B - C
feature/login:   A - B - C - D ✓

Vérification :

git log --oneline -3
# D doit apparaître dans feature/login mais plus dans main

Commit non poussé uniquement

Cette technique utilise git reset --hard qui réécrit l'historique de main. Ne l'utilisez que si le commit D n'a pas été poussé. Si le commit est déjà sur le remote, utilisez cherry-pick + revert (voir scénario 2).

Scénario 2 : déplacer plusieurs commits

Vous avez fait 3 commits sur main qui auraient dû être sur feature/dashboard :

main:    A - B - C - D - E - F
                     ^-- ces 3 commits

1. Notez les SHA des commits à déplacer

   git log --oneline -5

   Sortie :

   f1a2b3c (HEAD -> main) feat: page de stats
   d4e5f6a feat: graphiques dashboard
   a7b8c9d feat: layout dashboard
   1234567 fix: correction CSS
   abcdef0 feat: ajout header

   Les commits a7b8c9d, d4e5f6a et f1a2b3c doivent être déplacés.

2. Créez et basculez sur la branche cible

   git switch -c feature/dashboard main~3

   Cela crée feature/dashboard à partir du commit juste avant les 3 commits erronés.

3. Cherry-pick les commits dans l'ordre

   git cherry-pick a7b8c9d d4e5f6a f1a2b3c

   Ou avec une plage :

   git cherry-pick a7b8c9d^..f1a2b3c

4. Revenez sur main et supprimez les commits

   git switch main
   git reset --hard HEAD~3

Vérification :

git log --oneline --all --graph

Les 3 commits doivent apparaître sur feature/dashboard et avoir disparu de main.

Scénario 3 : déplacer avec rebase --onto

Si les commits à déplacer forment une série continue et que la branche cible existe déjà, rebase --onto est plus élégant que plusieurs cherry-picks :

git rebase --onto feature/dashboard main~3 main

Cette commande signifie : « prends les commits entre main~3 et main, et rejoue-les sur feature/dashboard ».

Vérification après le rebase :

git log --oneline --all --graph
# Les commits doivent apparaître sur feature/dashboard
# main doit pointer sur le commit d'avant la série déplacée
git log main --oneline -3
# Confirme que main ne contient plus les commits déplacés

Quand préférer rebase --onto

rebase --onto est utile quand vous avez beaucoup de commits à déplacer. Pour 1 ou 2 commits, cherry-pick est plus simple et plus lisible.

Scénario 4 : modifications non commitées

Vous avez commencé à modifier des fichiers mais pas encore commité, et vous réalisez que vous êtes sur la mauvaise branche.

Si la branche cible existe déjà

Il faut mettre les modifications de côté le temps du changement de branche, car Git refuse de basculer si un fichier modifié diffère entre les deux branches.

git stash
git switch feature/login
git stash pop

git stash enregistre vos modifications dans une pile dédiée (la référence refs/stash) puis remet le répertoire de travail à l'état du dernier commit. git stash pop réapplique l'entrée la plus récente sur la branche courante et la supprime de la pile.

Vérification :

git status
# Les fichiers modifiés doivent apparaître comme "Changes not staged for commit"
# ou "Changes to be committed" selon leur état initial
git diff --stat
# Confirme que vos modifications sont bien sur la bonne branche

Si la branche cible n'existe pas encore

Encore plus simple, git switch -c emporte automatiquement les modifications non commitées :

git switch -c feature/login

Vos fichiers modifiés suivent le changement de branche. Commitez-les normalement.

Conflit possible avec stash

Si la branche cible a des modifications qui entrent en conflit avec les vôtres, git stash pop peut échouer avec un conflit. Dans ce cas, résolvez les conflits puis exécutez git stash drop pour supprimer le stash.

Si git switch refuse de changer de branche

Git refuse de changer de branche quand vos modifications entrent en conflit avec la branche cible :

error: Your local changes to the following files would be overwritten by checkout

Solution : stashez d'abord, puis changez de branche :

git stash
git switch feature/login
git stash pop

Récapitulatif des commandes

Voici les quatre séquences complètes, dans l'ordre exact où les taper. Le point commun de toutes celles qui déplacent des commits déjà créés : elles se terminent par un reset --hard sur la branche d'origine. C'est cette étape que l'on oublie le plus souvent, et son absence laisse les commits présents sur les deux branches à la fois. Remplacez N par le nombre de commits concernés.

Situation	Commandes
1 commit local	git branch feature → git reset --hard HEAD~1 → git switch feature
N commits locaux	git switch -c feature main~N → git cherry-pick SHA1^..SHAN → git switch main → git reset --hard HEAD~N
Série de commits	git rebase --onto target main~N main
Modifs non commitées	git stash → git switch branch → git stash pop
Nouvelle branche	git switch -c feature (les modifs suivent automatiquement)

Glissez pour voir

Dépannage : problèmes courants

Les incidents rencontrés pendant un déplacement de commits viennent presque toujours de deux sources : un conflit parce que la branche cible a évolué de son côté, ou un reset --hard appliqué sur des commits déjà poussés. Le second cas est le plus gênant car il désynchronise vos collègues. Retrouvez votre message d'erreur dans la colonne de gauche pour identifier la manœuvre de sortie.

Symptôme	Cause probable	Solution
cherry-pick crée des conflits	La branche cible a divergé	Résolvez les conflits, puis git cherry-pick --continue
stash pop échoue avec conflits	Modifications incompatibles entre branches	Résolvez les conflits, puis git stash drop
reset --hard a supprimé les commits sur main	Commit déjà poussé, les collègues sont cassés	git reflog + git reset --hard HEAD@{n} pour restaurer, puis utiliser revert
Les commits sont dupliqués (sur les 2 branches)	Oublié le reset --hard sur la branche d'origine	Exécutez le reset --hard HEAD~N sur la branche source
rebase --onto n'a rien déplacé	Mauvais paramètres (plage vide)	Vérifiez : git rebase --onto <cible> <début_exclu> <fin_inclue>

Glissez pour voir

À retenir

• 1 commit local : créez la branche, puis reset --hard HEAD~1 sur la branche d'origine
• Plusieurs commits : cherry-pick un par un ou par plage (SHA^..SHA)
• Série continue : rebase --onto est plus élégant que N cherry-picks
• Pas encore commité : git stash + git switch + git stash pop
• Nouvelle branche : git switch -c feature emporte les modifs non commitées automatiquement
• N'oubliez jamais le reset --hard sur la branche d'origine pour supprimer les commits dupliqués

Prochaines étapes

Annuler et corriger des commits Amend, revert, reset : toutes les techniques d'annulation par symptôme.

Résoudre les conflits de merge Marqueurs de conflit, --ours/--theirs, rerere et stratégies de résolution.

Cherry-pick Maîtrisez la copie sélective de commits entre branches.

×

📖 Voir la documentation →