Aller au contenu principal
Télécharger
Branches

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é :

Terminal
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'accueil
Deux historiques Git : à gauche, merge crée un commit de fusion qui réunit les branches ; à droite, rebase rejoue les commits pour obtenir une ligne droite.
Mêmes fichiers à la fin, historique différent.

git merge : un commit de fusion

Depuis main, git merge réunit les deux branches dans un nouveau commit, qui a deux parents :

Terminal
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'accueil

Git 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 :

Terminal
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'accueil

Regarde 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 mergegit rebase
Historique obtenuBifurcations et commits de fusionUne seule ligne droite
Commits existantsInchangésRecopiés, avec de nouveaux identifiants
ConflitsRésolus une fois, dans le commit de fusionRésolus commit par commit
Sur une branche partagéeSans risqueÀ éviter
Pour pousser ensuitegit pushgit 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 :

Terminal
git rebase main# (sortie raccourcie)CONFLICT (content): Merge conflict in index.htmlerror: could not apply da8b1ed... Ajoute le lien vers le formulaire

Les 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.

Terminal
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 :

Terminal
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 :

Terminal
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'accueil

Ce 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é :

Terminal
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 :

Terminal
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 :

  1. Tout en merge : chaque branche est intégrée par un commit de fusion (git merge --no-ff le crée même quand une avance rapide est possible). Rien n'est réécrit : idéal pour une équipe qui débute.
  2. Rebase, puis avance rapide : chacun·e rebase sa branche sur main, puis l'intègre avec git merge --ff-only, qui refuse si la branche n'est pas à jour. main reste une ligne droite.
  3. 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.

A

GitQuest est conçu par Anaïs (nouvelle fenêtre), développeuse web et responsable pédagogique, spécialisée en formations tech et accessibilité numérique.