Git Rebase vs Merge: Wann welches verwenden (mit visuellen Beispielen)

Die Rebase-vs-Merge-Debatte ist eine der häufigsten Diskussionen im Git-Workflow. Beide Befehle integrieren Änderungen von einem Branch in einen anderen, aber auf grundlegend unterschiedliche Weise.

Wie Git Merge funktioniert

Git merge erstellt einen neuen "Merge-Commit", der die Historien beider Branches verbindet.

Git findet den gemeinsamen Vorfahren und erstellt einen neuen Commit, der die Änderungen beider kombiniert.

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

$ git checkout main
$ git merge feature

Wie Git Rebase funktioniert

Git rebase verschiebt Ihre Commits auf einen anderen Branch und erstellt eine lineare Sequenz.

Git entfernt Ihre Commits temporär, aktualisiert den Branch und wendet jeden Commit einzeln wieder an.

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

Visueller Vergleich

╔═══════════════════════════════════════════╗
║              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                 ║
╚═══════════════════════════════════════════╝

Wann Merge verwenden

• Öffentliche/geteilte Branches — Merge schreibt nie die Historie um.
• Kontext bewahren — Der Merge-Commit zeigt den Integrationszeitpunkt.
• Teamarbeit — Wenn mehrere Personen am selben Branch arbeiten.
• Release-Branches — Bewahrt den genauen Integrationspunkt.

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

Wann Rebase verwenden

• Feature-Branches (vor dem Merge in main) — Saubere lineare Historie.
• Aktuell bleiben — Rebase auf main ohne Merge-Commits.
• Vor PR-Einreichung — Saubere Commits sind leichter zu reviewen.
• Lokale Commits aufräumen — Interaktives Rebase zum Squashen und Umordnen.

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

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

Interaktives Rebase: squash, fixup, umordnen

Interaktives Rebase (git rebase -i) ist eine der mächtigsten Git-Funktionen.

$ 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

Goldene Regel: Öffentliche Branches nie rebasen

Wenn ein Branch gepusht wurde und andere daran arbeiten, NICHT rebasen.

# ❌ 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: Vollständiger Vergleich

Gängige Git-Workflows

Feature Branch Workflow

Feature-Branch erstellen → entwickeln → auf main rebasen → mit --no-ff mergen.

$ 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

Nutzt develop, feature, release, hotfix. Zwischen langlebigen Branches immer merge.

# 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

Kurzlebige Feature-Branches (< 1 Tag). Häufiges Rebase, schnelles Merge.

# 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

Gefährliche Szenarien

Häufig gestellte Fragen