Git Rebase vs Merge : Quand utiliser chacun (avec exemples visuels)

Le débat rebase vs merge est l'une des discussions les plus courantes dans les workflows Git. Les deux commandes intègrent les changements d'une branche dans une autre, mais de manières fondamentalement différentes.

Comment fonctionne Git Merge

Git merge crée un nouveau "commit de merge" qui lie les historiques des deux branches.

Git trouve l'ancêtre commun des deux branches, puis crée un nouveau commit combinant les changements.

          A---B---C  feature
         /         \
    D---E---F---G---H  main (merge commit)

$ git checkout main
$ git merge feature

Comment fonctionne Git Rebase

Git rebase déplace (ou "rejoue") vos commits au-dessus d'une autre branche, créant une séquence linéaire.

Git retire temporairement vos commits, met à jour la branche, puis réapplique chaque commit un par un.

Before rebase:
          A---B---C  feature
         /
    D---E---F---G  main

After rebase:
                    A'--B'--C'  feature
                   /
    D---E---F---G  main

$ git checkout feature
$ git rebase main

Comparaison visuelle

╔═══════════════════════════════════════════╗
║              MERGE RESULT                 ║
║                                           ║
║    D---E---F---G---H  main                ║
║         \       /                          ║
║          A---B---C  feature               ║
║                                           ║
║  ✓ Preserves all commits                  ║
║  ✓ Shows merge point                      ║
║  ✗ Non-linear history                     ║
╚═══════════════════════════════════════════╝

╔═══════════════════════════════════════════╗
║              REBASE RESULT                ║
║                                           ║
║    D---E---F---G---A'--B'--C'  main       ║
║                                           ║
║  ✓ Clean linear history                   ║
║  ✓ Easy to read                           ║
║  ✗ Rewrites commit hashes                 ║
╚═══════════════════════════════════════════╝

Quand utiliser Merge

• Branches publiques/partagées — Merge ne réécrit jamais l'historique.
• Préserver le contexte — Le commit de merge montre quand une branche a été intégrée.
• Collaboration d'équipe — Quand plusieurs personnes travaillent sur la même branche.
• Branches de release — Préserve le point d'intégration exact.

# Merge with merge commit (recommended for main)
$ git checkout main
$ git merge --no-ff feature
$ git push origin main

Quand utiliser Rebase

• Branches feature (avant merge dans main) — Crée un historique linéaire propre.
• Rester à jour — Rebase votre branche feature sur main sans commits de merge.
• Avant soumission de PR — Des commits propres sont plus faciles à reviewer.
• Nettoyer les commits locaux — Rebase interactif pour squash, réordonner, éditer.

# Update feature branch with latest main
$ git checkout feature
$ git rebase main

# If conflicts occur, resolve them, then:
$ git add .
$ git rebase --continue

Rebase interactif : squash, fixup, réordonner

Le rebase interactif (git rebase -i) est l'une des fonctionnalités les plus puissantes de Git.

$ git rebase -i HEAD~4

# Editor opens:
pick a1b2c3d Add user authentication
pick e4f5g6h Fix typo in auth
pick i7j8k9l Add password validation
pick m0n1o2p Fix lint error

# Change to:
pick a1b2c3d Add user authentication
fixup e4f5g6h Fix typo in auth       # merge into previous, discard message
pick i7j8k9l Add password validation
fixup m0n1o2p Fix lint error          # merge into previous, discard message

# Result: 2 clean commits instead of 4

# Commands:
# pick   = use commit as-is
# squash = merge into previous commit, keep message
# fixup  = merge into previous commit, discard message
# reword = use commit but edit message
# drop   = remove commit entirely

Règle d'or : Ne jamais Rebase les branches publiques

Si une branche a été poussée et d'autres y travaillent, NE PAS la rebase.

# ❌ DANGEROUS: Rebasing a shared branch
$ git checkout main
$ git rebase feature  # NEVER do this!

# ✅ SAFE: Rebasing your own feature branch
$ git checkout my-feature    # only I work on this
$ git rebase main            # safe!
$ git push --force-with-lease origin my-feature

Merge vs Rebase : Comparaison complète

Workflows Git courants

Feature Branch Workflow

Créer branche → développer → rebase sur main → merge avec --no-ff.

$ git checkout -b feature/login
# ... develop ...
$ git rebase main              # clean up history
$ git checkout main
$ git merge --no-ff feature/login  # merge with commit
$ git branch -d feature/login

Gitflow Workflow

Utilise develop, feature, release, hotfix. Toujours merge entre branches longue durée.

# Always merge between long-lived branches
$ git checkout develop
$ git merge --no-ff feature/login
$ git checkout release/1.0
$ git merge --no-ff develop
$ git checkout main
$ git merge --no-ff release/1.0
$ git tag v1.0

Trunk-Based Development

Branches feature courtes (< 1 jour). Rebase fréquent, merge rapide.

# Short-lived branch, rebase often
$ git checkout -b fix/typo
# ... quick fix ...
$ git rebase main
$ git checkout main
$ git merge fix/typo    # fast-forward
$ git push

Scénarios dangereux

Questions fréquemment posées