Remote-Tracking Branches und Aufräumen

Das Problem: Geister-Branches

Nach dem Mergen von PRs siehst du möglicherweise Branches, die nicht mehr existieren:

$ git branch -a
  main
  remotes/origin/main
  remotes/origin/feature/old-pr  ← Wurde auf GitHub gelöscht!

Warum passiert das?

Git räumt Referenzen zu gelöschten Remote-Branches nicht automatisch auf.

Die drei Arten von Branches

Wenn du git branch -a ausführst, siehst du drei verschiedene Dinge:

$ git branch -a
  main                           ← Lokaler Branch
  feature/new-feature            ← Lokaler Branch
  remotes/origin/main            ← Remote-Tracking Branch
  remotes/origin/feature/xyz     ← Remote-Tracking Branch

Lass uns jede Art verstehen...

Typ 1: Lokale Branches

  main
  feature/new-feature

Lokale Branches:

• Deine eigenen Branches, an denen du arbeitest
• Existieren nur auf deinem Computer
• Du erstellst sie mit git checkout -b
• Du kontrollierst, wann sie erstellt und gelöscht werden

Typ 2: Remote-Tracking Branches

  remotes/origin/main
  remotes/origin/feature/xyz

Remote-Tracking Branches:

• Lokale Kopien dessen, was auf GitHub existiert
• Werden automatisch aktualisiert, wenn du git fetch oder git pull ausführst
• Du arbeitest nicht direkt an diesen – sie sind Lesezeichen, die den Zustand von GitHub zeigen
• Benannt mit remotes/origin/ Präfix

Typ 3: Das Remote-Repository (GitHub)

Die tatsächlichen Branches auf GitHub:

• Die zentrale Wahrheit
• Was dein Team sieht
• Wo PRs gemerged werden
• Wo Branches nach dem Mergen gelöscht werden

Die Lesezeichen-Analogie

Denke an Remote-Tracking Branches wie Lesezeichen in deinem Browser:

Das Problem: Wenn ein Branch auf GitHub gelöscht wird (nach dem Mergen eines PR), zeigt dein Lesezeichen immer noch darauf!

Warum veraltete Referenzen entstehen

Typischer Workflow:

1. Du erstellst einen Feature-Branch und pushst ihn zu GitHub
2. Du erstellst einen PR und er wird gemerged
3. GitHub löscht automatisch den Branch nach dem Merge
4. Dein lokales Git hat immer noch remotes/origin/feature/xyz (veraltet!)

Git entfernt diese Referenzen nicht automatisch, weil:

• Es nicht weiß, ob die Löschung beabsichtigt war
• Du offline gewesen sein könntest, als die Löschung stattfand
• Git auf der sicheren Seite bleibt und Informationen behält

Beispiel: Veraltete Referenzen in Aktion

Nachdem PR gemerged und Branch auf GitHub gelöscht wurde:

$ git branch -a
  main
  remotes/origin/main
  remotes/origin/feature/old-pr  ← Veraltet! Existiert nicht mehr auf GitHub

Das verursacht Verwirrung:

• git branch -a zeigt Branches, die nicht existieren
• Du könntest versehentlich versuchen, an gelöschten Branches zu arbeiten
• Repository sieht unübersichtlich aus

Lösung 1: git fetch --prune

Die --prune Flag sagt Git: "Entferne lokale Referenzen zu Remote-Branches, die nicht mehr existieren."

$ git fetch --prune

Was das macht:

1. Fetch: Neue Commits und Branches von GitHub herunterladen
2. Prune: Remote-Tracking Branches entfernen, die nicht mehr auf GitHub existieren

git fetch --prune Beispiel

Vor dem Pruning:

$ git branch -a
  main
  remotes/origin/main
  remotes/origin/feature/old-pr
  remotes/origin/feature/another-merged

Pruning ausführen:

$ git fetch --prune
From https://github.com/user/repo
 - [deleted]         (none)     -> origin/feature/old-pr
 - [deleted]         (none)     -> origin/feature/another-merged

Übersetzung: "Diese Remote-Tracking Branches wurden lokal gelöscht, weil sie nicht mehr auf GitHub existieren."

Lösung 2: git remote prune origin

Alternativer Befehl:

$ git remote prune origin

Unterschied zu git fetch --prune:

• git fetch --prune: Lädt neue Daten herunter UND entfernt veraltete Referenzen (empfohlen)
• git remote prune origin: Entfernt nur veraltete Referenzen (lädt keine neuen Daten herunter)

Vorschau vor dem Pruning

Sehe, was entfernt werden würde, ohne es tatsächlich zu entfernen:

$ git remote prune origin --dry-run
Pruning origin
URL: https://github.com/user/repo
 * [would prune] origin/feature/old-pr
 * [would prune] origin/feature/another-merged

Verwende dies, wenn du nicht sicher bist, was gelöscht wird!

Vollständiger Branch-Aufräum-Workflow

Nach dem Mergen eines PR und Löschen des Branches auf GitHub:

# Schritt 1: Zu main wechseln und aktualisieren (mit automatischem Pruning)
git checkout main
git pull --prune

# Schritt 2: Deinen lokalen Feature-Branch löschen
git branch -d feature/my-merged-feature

git pull --prune verstehen

git pull --prune macht DREI Dinge auf einmal:

1. Fetcht Updates von GitHub (aktualisiert origin/main Lesezeichen)
2. Mergt diese Updates in deinen lokalen main (bewegt main Pointer vorwärts)
3. Entfernt veraltete Remote-Tracking Branches (wie remotes/origin/feature/my-merged-feature)

Es ist der effizienteste Aufräum-Befehl!

Visuell: Vor dem Aufräumen

Dein lokales Git:
├── Lokale Branches:
│   ├── main
│   └── feature/old-pr (gemerged, aber du hast vergessen zu löschen)
└── Remote-Tracking Branches:
    ├── remotes/origin/main  (existiert auf GitHub)
    ├── remotes/origin/feature/old-pr  (gelöscht auf GitHub)
    └── remotes/origin/feature/another-old  (gelöscht auf GitHub)

Visuell: Nach dem Aufräumen

Dein lokales Git:
├── Lokale Branches:
│   └── main (sauber!)
└── Remote-Tracking Branches:
    └── remotes/origin/main  (existiert auf GitHub)

Viel sauberer!

Automatisches Pruning (Empfohlene Einrichtung)

Konfiguriere Git, um beim Fetchen immer zu prunen:

$ git config --global fetch.prune true

Jetzt wird jedes git fetch und git pull automatisch veraltete Referenzen aufräumen!

Vorteile:

• Eine Sache weniger, an die du denken musst
• Immer eine saubere Ansicht der Branches
• Keine veralteten Referenzen, die deine git branch -a Ausgabe überladen

Prüfe, ob Auto-Prune aktiviert ist

$ git config --global --get fetch.prune
true

Wenn es true zurückgibt, bist du startklar!

Wenn es nichts zurückgibt, aktiviere es:

$ git config --global fetch.prune true

Was ist mit lokalen Branches?

Wichtig: Remote-Pruning betrifft nur Remote-Tracking Branches (remotes/origin/*), nicht deine lokalen Branches.

Du musst lokale Branches manuell löschen:

$ git branch -d feature/my-merged-feature   # Löschen wenn gemerged
$ git branch -D feature/my-merged-feature   # Erzwungenes Löschen

Warum Git lokale Branches behält:

• Du könntest uncommittete Arbeit haben
• Du möchtest den Branch später vielleicht referenzieren
• Es ist sicherer, explizites Löschen zu verlangen

Häufiges Szenario 1: "Not Fully Merged" Fehler

$ git branch -d feature/xyz
error: The branch 'feature/xyz' is not fully merged.
hint: If you are sure you want to delete it, run 'git branch -D feature/xyz'.

Warum das passiert:
PR wurde mit "Squash and merge" oder "Rebase and merge" gemerged – das erstellt neue Commits anstatt deine originalen Commits zu verwenden.

Lösung: Verwende großes -D zum erzwungenen Löschen:

$ git branch -D feature/xyz

Prüfe zuerst, dass der PR tatsächlich auf GitHub gemerged wurde, bevor du erzwungen löschst!

Häufiges Szenario 2: Welche Branches sind gemerged?

Zeige Branches, die in den aktuellen Branch gemerged wurden:

$ git branch --merged

Zeige Branches, die in main gemerged wurden:

$ git branch --merged main

Zeige Branches, die NOCH NICHT gemerged wurden:

$ git branch --no-merged

Häufiges Szenario 3: Massen-Aufräumen

Lösche alle lokalen Branches, die in main gemerged wurden:

$ git branch --merged main | grep -v "^\* main" | xargs git branch -d

Warnung: Führe dies nur aus, wenn du sicher bist, dass alle aufgelisteten Branches tatsächlich gemerged sind!

Besserer Ansatz: Lösche Branches einzeln, um sicher zu sein.

Warum Aufräumen wichtig ist

Vorteile sauberer Branches:

Klarheit: git branch -a zeigt nur Branches, die tatsächlich existieren
Schneller: Weniger Unordnung bedeutet einfacher zu finden, was du brauchst
Professionell: Zeigt, dass du Gits Architektur verstehst
Verhindert Fehler: Du wirst nicht versehentlich an gelöschten Branches arbeiten

Es ist nicht kritisch: Veraltete Referenzen brechen nichts – sie verursachen nur Verwirrung.

Die Drei-Ebenen-Synchronisation verstehen

GitHub (zentrale Wahrheit)
    ↓ git fetch/pull
Remote-Tracking Branches (lokale Lesezeichen)
    ↓ git merge/checkout
Lokale Branches (deine Arbeit)

Jede Ebene braucht separates Aufräumen:

• GitHub: Branches werden automatisch nach PR-Merge gelöscht
• Remote-Tracking: Verwende git fetch --prune oder git pull --prune
• Lokal: Verwende git branch -d manuell

Kurzreferenz: Aufräum-Befehle

# Alle Branches anzeigen (inkl. Remote-Tracking)
git branch -a

# Vorschau, was gepruned würde
git remote prune origin --dry-run

# Veraltete Remote-Tracking Branches entfernen
git fetch --prune

# Oder nur prunen ohne fetchen
git remote prune origin

# Gemergten lokalen Branch löschen
git branch -d feature/merged-branch

# Lokalen Branch erzwungen löschen (wenn squash gemerged)
git branch -D feature/merged-branch

# Automatisches Pruning aktivieren (empfohlen)
git config --global fetch.prune true

Der vollständige Post-PR Workflow

Nachdem dein PR auf GitHub gemerged wurde:

# 1. Zu main wechseln
git checkout main

# 2. Neueste Änderungen holen und Remote-Tracking Branches aufräumen
git pull --prune

# 3. Deinen lokalen Feature-Branch löschen
git branch -d feature/my-merged-feature
# (oder git branch -D wenn squash gemerged)

# 4. Aufräumen verifizieren
git branch -a

Sauberes Repository, bereit für das nächste Feature!

Wichtigste Erkenntnisse

1. Remote-Tracking Branches sind lokale Lesezeichen zu GitHubs Branches
2. Veraltete Referenzen entstehen, wenn Branches auf GitHub gelöscht werden
3. git fetch --prune entfernt diese veralteten Referenzen
4. Lokale Branches müssen separat mit git branch -d gelöscht werden
5. Aktiviere automatisches Pruning mit git config --global fetch.prune true
6. Aufräumen ist optional, hält aber dein Repository aufgeräumt

Denke an Branch-Aufräumen wie an das Aufräumen deines Schreibtischs – deine Arbeit hängt nicht davon ab, aber es macht alles klarer!

Übungsaufgabe

Probiere diesen Workflow aus:

1. Erstelle einen Feature-Branch und mache einen Commit
2. Pushe zu GitHub und erstelle einen PR
3. Merge den PR (GitHub löscht den Branch)
4. Führe git branch -a aus (siehe veraltete Referenz)
5. Führe git fetch --prune aus (siehe, wie sie entfernt wird)
6. Lösche lokalen Branch mit git branch -d
7. Aktiviere Auto-Prune: git config --global fetch.prune true

Du wirst nie wieder veraltete Referenzen haben!

Fragen?

Häufige Fragen:

F: "Wird Pruning meine Arbeit löschen?"
A: Nein! Es entfernt nur Lesezeichen zu Branches, die nicht auf GitHub existieren.

F: "Was wenn ich versehentlich prune?"
A: Nichts Schlimmes passiert – du entfernst nur veraltete Lesezeichen.

F: "Sollte ich immer Auto-Prune aktivieren?"
A: Ja! Es ist eine Best Practice und hat keine Nachteile.

Zusätzliche Ressourcen

Aus der Vorlesung:

• Abschnitt 10.4: Aufräumen - Remote-Tracking Branches verstehen

Offizielle Dokumentation:

• Git Branching - Remote Branches
• git-fetch Dokumentation

Profi-Tipp:
Füge dies zu deinem täglichen Workflow hinzu – nach jedem gemergten PR führe git pull --prune aus und räume lokale Branches auf!

Zusammenfassung

Du verstehst jetzt:

• Den Unterschied zwischen lokalen Branches, Remote-Tracking Branches und Remote-Branches
• Warum veraltete Referenzen nach dem Mergen von PRs entstehen
• Wie man git fetch --prune und git pull --prune verwendet
• Wie man automatisches Pruning aktiviert
• Den vollständigen Aufräum-Workflow

Deine Git-Repositories werden sauber und organisiert bleiben!