Formations — 1 037 leçons en français

Accueil › Git & CI/CD › Fusionner ou rebaser : choisir, et assumer l'historique

Fusionner ou rebaser : choisir, et assumer l'historique

Branches, fusion et conflitsdebutant

Fusionner et rebaser répondent à la même question — comment réunir le travail de ma branche et celui de main ? — avec deux réponses opposées sur un seul point : ce qui arrive à l'historique déjà écrit.

git merge git rebase
Commits existants intacts recréés, autres empreintes
Ce qui est ajouté un commit de fusion à deux parents rien, la branche est déplacée
Historique conserve la forme réelle devient linéaire
Poussée normale --force-with-lease
Sur du code déjà publié toujours permis interdit
Point de départ                 main a reçu F pendant votre travail

  A───B───C───F  (main)
           ╲
            D───E  (ma-branche)
git merge ma-branche            git rebase main
(depuis main)                   (depuis ma-branche)

  A───B───C───F───M  (main)     A───B───C───F───D'───E'
           ╲     ╱                              ↑
            D───E                          ma-branche

À gauche, D et E existent toujours et M enregistre la rencontre. À droite, D et E ont disparu de la branche au profit de D' et E' : même contenu, empreintes différentes, parce que l'empreinte d'un commit inclut celle de son parent.

La règle d'or découle de là, et d'elle seule. Si personne n'a récupéré D et E, les remplacer ne gêne personne. Si quelqu'un les a, il garde l'ancienne version et vous avez désormais deux histoires contenant les mêmes changements. D'où la formulation exacte : on ne rebase pas ce qui a été publié, et non on ne rebase pas main. Une branche personnelle poussée et déjà relue est publiée.

La combinaison courante en équipe résout les deux à la fois :

git switch ma-branche
git fetch origin
git rebase origin/main          # je range ma branche : rebase
git push --force-with-lease     # elle n'appartient qu'à moi
# … revue … puis, côté main :
git merge --ff-only ma-branche  # j'intègre : plus rien à réécrire

Rebase vers l'intérieur de sa branche, fusion vers l'extérieur dans la branche commune.

Les termes à connaître

Historique linéaire

Un historique où chaque commit n'a qu'un seul parent : aucune bifurcation, aucun commit de fusion. C'est ce que produit le rebase, et ce que git log affiche sans avoir besoin de --graph.

git merge --ff-only

Fusion qui échoue si l'avance rapide est impossible, au lieu de créer un commit de fusion. C'est le garde-fou qui transforme une divergence silencieuse en erreur visible : Git refuse plutôt que d'inventer un commit que personne n'a demandé.

Fusion écrasante (squash merge)

Intégration qui remplace tous les commits de la branche par un seul commit ordinaire sur la cible. L'historique reste linéaire, mais le lien avec la branche d'origine est perdu : Git ne la considère pas comme fusionnée.

Premier parent

Le parent n° 1 d'un commit de fusion : celui de la branche dans laquelle on a fusionné. git log --first-parent ne suit que lui et donne la liste des intégrations, en ignorant le détail interne de chaque branche.

git revert -m 1

Annulation d'un commit de fusion. Comme il a deux parents, il faut dire par rapport auquel calculer l'annulation : -m 1 désigne le premier parent, c'est-à-dire « enlève ce que la branche a apporté ».

Règle d'or

On ne réécrit jamais un historique que d'autres ont déjà récupéré. Elle ne porte pas sur le nom de la branche mais sur le fait d'avoir été publié : une branche personnelle poussée et relue tombe déjà sous la règle.

Convention d'intégration

Le choix fait une fois pour l'équipe entre fusion, fusion écrasante et rebase, imposé par le réglage de la forge plutôt que décidé par chacun au moment de cliquer. C'est ce qui rend un historique lisible six mois plus tard.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.