Merge ou rebase : lequel choisir ?
Merge et rebase réunissent deux branches, mais pas avec le même historique. La différence en schéma, la règle d'or et quand choisir l'un ou l'autre.
Par Anaïs Sparesotto (nouvelle fenêtre)Publié le 8 min de lecture
En bref : git merge et git rebase intègrent tous les deux le travail d'une branche dans une autre et donnent les mêmes fichiers à la fin, mais pas le même historique. git merge ajoute un commit de fusion et garde la trace de la bifurcation, alors que git rebase rejoue tes commits au bout de l'autre branche pour obtenir une ligne droite, en les réécrivant.
Le choix n'est donc pas une question de résultat, mais de lecture : quel historique ton équipe veut-elle relire dans six mois ? Et une règle ne se discute pas : on ne rebase jamais des commits déjà partagés.
Ce que chaque commande fait à l'historique
Tu as fait deux commits sur la branche formulaire-contact pendant qu'un commit « Corrige le pied de page » arrivait sur main. Les branches ont divergé :
git log --oneline --graph --all* d62a5ce (HEAD -> main) Corrige le pied de page| * 44017e4 (formulaire-contact) Valide l'adresse e-mail| * 41dd223 Ajoute le formulaire de contact|/* 3bebbf0 Crée la page d'accueilgit merge : un commit de fusion
Depuis main, git merge réunit les deux branches dans un nouveau commit, qui a deux parents :
git merge formulaire-contact# (sortie raccourcie)Merge made by the 'ort' strategy.git log --oneline --graph* 00b4828 (HEAD -> main) Merge branch 'formulaire-contact'|\| * 44017e4 (formulaire-contact) Valide l'adresse e-mail| * 41dd223 Ajoute le formulaire de contact* | d62a5ce Corrige le pied de page|/* 3bebbf0 Crée la page d'accueilGit ouvre d'abord ton éditeur avec le message proposé : enregistre et ferme. Aucun commit existant n'est modifié, et l'historique garde la trace des deux lignes de travail. Le revers : sur un projet actif, les commits de fusion encombrent le graphe. Voir aussi git merge expliqué.
git rebase : une ligne droite
Depuis ta branche, git rebase main la place au bout de main et rejoue tes commits un par un :
git switch formulaire-contactSwitched to branch 'formulaire-contact'git rebase mainSuccessfully rebased and updated refs/heads/formulaire-contact.git log --oneline --graph --all* 0b101d7 (HEAD -> formulaire-contact) Valide l'adresse e-mail* 4b8af70 Ajoute le formulaire de contact* d62a5ce (main) Corrige le pied de page* 3bebbf0 Crée la page d'accueilRegarde les identifiants : 41dd223 est devenu 4b8af70, 44017e4 est devenu 0b101d7. Ce sont de nouveaux commits : même contenu, autre parent. Ensuite, depuis main, git merge formulaire-contact répond Fast-forward, sans commit de fusion. Détails dans git rebase expliqué.
Merge ou rebase : le comparatif
git merge | git rebase | |
|---|---|---|
| Historique obtenu | Bifurcations et commits de fusion | Une seule ligne droite |
| Commits existants | Inchangés | Recopiés, avec de nouveaux identifiants |
| Conflits | Résolus une fois, dans le commit de fusion | Résolus commit par commit |
| Sur une branche partagée | Sans risque | À éviter |
| Pour pousser ensuite | git push | git push --force-with-lease si la branche était déjà en ligne |
La règle d'or : ne jamais rebaser des commits déjà partagés
Le rebase remplace des commits par des copies. Si d'autres possèdent les originaux, tu dois forcer le push pour envoyer ta version, ce qui retire les anciens commits de la branche distante. Au prochain git pull de tes collègues, chaque commit apparaît en double, et un commit poussé entre-temps peut disparaître.
D'où la règle : on ne rebase jamais des commits déjà poussés sur une branche partagée (main, develop, ou toute branche où vous êtes plusieurs). Tu peux en revanche rebaser librement :
- tes commits locaux, pas encore poussés ;
- ta propre branche, même déjà poussée, tant que personne d'autre ne travaille dessus.
Dans le doute, choisis merge : il ne réécrit rien.
Résoudre un conflit pendant un rebase
Le rebase rejoue tes commits un par un : il peut donc s'arrêter sur chacun. Ici, ton commit « Ajoute le lien vers le formulaire » touche la même ligne du pied de page que main :
git rebase main# (sortie raccourcie)CONFLICT (content): Merge conflict in index.htmlerror: could not apply da8b1ed... Ajoute le lien vers le formulaireLes marqueurs sont les mêmes qu'avec merge, mais les côtés sont inversés : pendant un rebase, le côté HEAD montre la version de main (plus tes commits déjà rejoués), et l'autre côté, le commit que Git est en train de rejouer.
cat index.html<h1>Mon site</h1><<<<<<< HEAD<footer>(c) 2026 Mon site</footer>=======<footer>(c) 2026 - <a href="contact.html">Contact</a></footer>>>>>>>> da8b1ed (Ajoute le lien vers le formulaire)Garde ce qui doit rester (ici, les deux changements), supprime les marqueurs, puis :
git add index.htmlgit rebase --continue[detached HEAD 5e65105] Ajoute le lien vers le formulaire 1 file changed, 1 insertion(+), 1 deletion(-)Successfully rebased and updated refs/heads/formulaire-contact.Git ouvre ton éditeur pour confirmer le message, puis passe au commit suivant (detached HEAD est normal : Git remet ta branche en place à la fin). Pour tout arrêter, git rebase --abort remet ta branche comme avant le rebase. Pour trancher un conflit, la méthode est la même qu'avec merge : résoudre un conflit de merge pas à pas.
git pull --rebase et le réglage pull.rebase
git pull fait un git fetch puis, par défaut, un merge. Si un·e collègue a poussé pendant que tu commitais en local, chaque synchronisation ajoute un commit Merge branch 'main' of ... sans intérêt. Les versions récentes de Git refusent même de choisir à ta place : fatal: Need to specify how to reconcile divergent branches.
git pull --rebase rejoue plutôt tes commits locaux au-dessus de ceux que tu viens de récupérer :
git pull --rebaseSuccessfully rebased and updated refs/heads/main.git log --oneline --graph* 45a6cc8 (HEAD -> main) Ajoute le plan du site* 0617384 (origin/main, origin/HEAD) Met à jour le README* e084f2e Crée la page d'accueilCe rebase respecte la règle d'or : seuls tes commits pas encore poussés sont rejoués. Pour en faire le comportement par défaut : git config --global pull.rebase true (sans --global, pour le dépôt en cours seulement ; false revient au merge). Avec des modifications non commitées, git pull --rebase refuse de démarrer : commite-les ou range-les avec git stash.
Après un rebase : git push --force-with-lease
Ta branche personnelle était déjà en ligne (sauvegarde, pull request), puis tu l'as rebasée. Le dépôt distant a encore les anciens commits, donc git push est refusé :
git push# (sortie raccourcie) ! [rejected] formulaire-contact -> formulaire-contact (non-fast-forward)Le message complet conseille un git pull, mais ici ton historique contiendrait chaque commit en double, plus un commit de fusion. Remplace plutôt la branche distante par ta version :
git push --force-with-lease# (sortie raccourcie) + 7c28e58...49cb9e1 formulaire-contact -> formulaire-contact (forced update)--force-with-lease est la version prudente de --force : Git n'écrase la branche distante que si elle n'a pas bougé depuis ta dernière récupération. Si quelqu'un y a poussé entre-temps, le push est refusé avec (stale info). Mais un git fetch fait entre-temps (par toi ou par ton éditeur) contourne cette vérification : ajoute --force-if-includes pour que Git contrôle aussi que tu as intégré ces commits. Autres causes de refus : failed to push some refs.
Choisir une convention d'équipe
Merge et rebase ne s'excluent pas. L'important est de choisir une règle ensemble et de l'écrire, par exemple dans le README. Trois conventions sont courantes :
- Tout en merge : chaque branche est intégrée par un commit de fusion (
git merge --no-ffle crée même quand une avance rapide est possible). Rien n'est réécrit : idéal pour une équipe qui débute. - Rebase, puis avance rapide : chacun·e rebase sa branche sur
main, puis l'intègre avecgit merge --ff-only, qui refuse si la branche n'est pas à jour.mainreste une ligne droite. - Squash : les commits de la branche sont regroupés en un seul à l'intégration (
git merge --squash). Ligne droite, mais le détail des étapes disparaît.
Sur GitHub, ce sont les trois options de fusion d'une pull request (« Create a merge commit », « Rebase and merge », « Squash and merge »), et le dépôt peut n'en autoriser qu'une. Pense aussi à régler pull.rebase de la même façon pour toute l'équipe. Pour l'organisation complète des branches, lis le workflow de branches Git.
Questions fréquentes
Quelle est la différence entre git merge et git rebase ?
git merge réunit deux branches dans un commit de fusion, sans toucher aux commits existants. git rebase recopie tes commits au bout de l'autre branche : l'historique devient linéaire, les fichiers restent les mêmes.
Est-ce que git rebase peut faire perdre du travail ?
Rarement sur tes propres commits : juste après un rebase, git reset --hard ORIG_HEAD remet ta branche dans son état d'avant (en effaçant aussi tes modifications non commitées), et git reflog garde la trace des anciens commits. Le vrai risque, ce sont les branches partagées.
Faut-il utiliser git pull --rebase ?
C'est un bon réflexe : pas de commit de fusion à chaque synchronisation, et seuls tes commits pas encore poussés sont rejoués. Pour l'activer partout : git config --global pull.rebase true.
Comment annuler un rebase en cours ?
Tape git rebase --abort : ta branche revient à son état d'avant le rebase, même si tu avais déjà résolu une partie des conflits.
Pourquoi git push est-il refusé après un rebase ?
Le dépôt distant a encore tes anciens commits, que ta branche ne contient plus. Si la branche n'est qu'à toi, pousse avec git push --force-with-lease. Si d'autres travaillent dessus, ne force pas : reviens à l'état d'avant le rebase et utilise merge.
Passe de la lecture à la pratique
Tape ces commandes pour de vrai dans le terminal simulé de GitQuest Academy : gratuit, sans rien installer, avec un certificat à la fin.
Pour aller plus loin
- git mergeFusionner des branches ; fast-forward ou commit de merge ; gérer les conflits.
- git rebaseRejouer des commits sur une nouvelle base ; rebase ou merge ; rebase interactif ; risques.
- Workflow de branchesbranch, switch, merge, rebase et cherry-pick ; merge ou rebase ; conventions de nommage.
- Résoudre un conflit de mergeRepérer, comprendre et résoudre proprement un conflit de merge.