Git: Branch wechseln – ein Leitfaden mit Praxisbeispielen

Namen vorhandener Branches herausfinden

Um alle verfügbaren Branches aufzulisten, nutzen wir git branch. Der aktuelle Branch wird mit einem Stern markiert. Haben wir etwa drei lokale Branches namens main, feature-x und bug-z und befinden uns auf main, sähe die Ausgabe so aus:

* main
feature-x
bug-z

Zu einem Remote-Branch wechseln

Mit dem vorherigen Befehl wechseln wir zu einem Branch, der bereits lokal vorhanden ist. Um auf einen Branch aus dem Remote-Repository zu wechseln, müssen wir zuerst eine lokale Kopie davon anlegen. Das geht so:

git switch -c <local-branch-name> origin/<remote-branch-name>

Hier ist <local-branch-name> der gewünschte lokale Name und <remote-branch-name> der Name des Remote-Branches. Meistens verwenden wir denselben Namen, um Verwechslungen zu vermeiden. Falls wir feature-x lokal noch nicht haben, können wir die lokale Version erzeugen und direkt wechseln:

git switch -c feature-x origin/feature-x

Wenn der Name identisch ist, gibt es eine Kurzform mit der Option --track. Der obige Befehl entspricht dann:

git switch --track origin/feature-x

Remote-Branches lassen sich mit git branch -r auflisten.

Das lokale Repository verfolgt Remote-Branches nicht automatisch. Daher sollten wir vor dem Auflisten oder Wechseln zu einem Remote-Branch mit git fetch aktualisieren.

Einen neuen Branch erstellen und direkt wechseln

Wenn wir ein neues Feature starten, erstellen wir einen komplett neuen Branch. Dafür nutzen wir die Option -c:

git switch -c <new-branch-name>

Wir ersetzen <new-branch-name durch den gewünschten Namen. Um zum Beispiel feature-y zu erstellen, verwenden wir:

git switch -c feature-y

Zurück zum vorherigen Branch wechseln

Häufig möchten wir nach einem Zwischenschritt wieder zum zuvor bearbeiteten Branch zurück. Git bietet dafür eine Abkürzung:

git switch -

Git Switch vs. Git Checkout

Den Befehl git checkout gibt es seit Beginn von Git. Vor der Einführung von git switch im Jahr 2019 nutzten wir git checkout, um Branches zu wechseln. Der Funktionsumfang von git checkout geht jedoch deutlich darüber hinaus. Hier die wichtigsten Unterschiede:

• git switch: Liefert eine intuitivere Möglichkeit, Branches zu wechseln und neue zu erstellen. Ziel ist, den Befehlssatz zu vereinfachen und Verwirrung zu reduzieren.
• git checkout: Vielseitiger Befehl, der neben dem Wechseln von Branches auch einzelne Dateien auschecken und Inhalte aus verschiedenen Commits oder Branches wiederherstellen kann.

Das Design von git switch erschwert es, Änderungen versehentlich zu überschreiben. Die Syntax für das Wechseln und Erstellen von Branches ist expliziter.

Da git checkout mehrere Aufgaben abdeckt (Branches wechseln, Dateien wiederherstellen etc.), ist die Fehlergefahr bei der Nutzung höher.

Git Switch: Häufige Fehler

Beim Branch-Management können typische Probleme auftreten. Eines davon ist der Versuch, einen Branch zu erstellen, der lokal bereits existiert. Ein weiteres häufiges Problem entsteht beim Wechseln mit uncommitteten Änderungen. Beginnen wir mit dem ersten Fall.

Der Branch existiert lokal bereits

Jeder lokale Branch braucht einen eindeutigen Namen. Du kannst mit git switch auf zwei Arten lokale Branches erstellen:

1. Einen Remote-Branch tracken:

git switch --track origin/<branch-name>

2. Einen neuen lokalen Branch erstellen:

git switch -c <branch-name>

In beiden Fällen wirft Git einen Fehler, wenn lokal bereits ein Branch namens <branch-name> existiert:

fatal: a branch named '<branch-name>' already exists

In diesem Fall wechseln wir einfach ohne Neuanlage mit git switch <branch-name> auf den Branch.

Der aktuelle Branch hat uncommittete Änderungen

Git erlaubt keinen Branchwechsel, wenn dadurch uncommittete Änderungen überschrieben würden. Dann erscheint folgende Fehlermeldung:

Please commit your changes or stash them before you switch branches.

Wie die Meldung sagt, committen wir die Änderungen zuerst oder legen sie auf den Stash. Sind die Änderungen reif für das Repository, committen wir sie mit:

git commit -m "Commit message"

Wenn wir die Änderungen behalten wollen, aber noch nicht committen, speichern wir sie vorübergehend mit dem git stash-Befehl:

git stash

Wenn wir die Änderungen vor dem Wechseln stashen und sie nach der Rückkehr in den ursprünglichen Branch wieder anwenden wollen, nutzen wir git stash pop.

Alternativ können wir die Änderungen auch verwerfen – mit dem Flag --discard-changes:

git switch --discard-changes <branch-name>

Vorsicht: Diese Option löscht die Änderungen dauerhaft.

Git Switch: Fortgeschrittene Nutzung

Wenn du Branches von bestimmten Punkten in der Projektgeschichte aus erstellen oder spezielle Szenarien abbilden willst, bietet git switch erweiterte Funktionen.

Abzweigen von einem bestimmten Punkt

Standardmäßig startet ein neuer Branch, der mit git switch erstellt wird, am HEAD des aktuell aktiven Branches.

Angenommen, wir wollen von einem bestimmten früheren Commit aus einen neuen Branch starten. Jeder Commit hat einen eindeutigen <hash>, den wir mit git switch nutzen können, um von genau diesem Commit zu verzweigen. So geht’s:

switch -c feature-y <hash>

Ersetze <hash> durch den tatsächlichen Commit-Hash.

In einen Detached-HEAD wechseln

Wenn wir einen bestimmten Commit erkunden oder experimentieren möchten, ohne den aktuellen Branch zu verändern oder einen neuen zu erstellen, können wir in den Detached-HEAD-Zustand wechseln:

git switch --detach <hash>

Mit einem Detached HEAD können wir den Zustand des Repositories zu einem bestimmten Commit sicher inspizieren, Tests ausführen oder temporäre Änderungen vornehmen – ohne Risiko, diese versehentlich in den aktuellen Arbeits-Branch zu committen. Häufige Anwendungsfälle sind:

• Einen alten Stand ansehen: Wir können einen älteren Commit überprüfen oder testen, ohne Änderungen am aktuellen Branch vorzunehmen.
• Temporäre Änderungen: Wir können gefahrlos experimentieren, ohne einen Branch zu beeinflussen. Beachte: Neue Commits in diesem Zustand gehören zu keinem Branch. Falls wir sie behalten möchten, sollten wir anschließend einen neuen Branch erstellen.
• Build-/Test-Zwecke: Manchmal müssen wir Software zu einem bestimmten Commit bauen oder testen. Ein Detached HEAD an diesem Commit ermöglicht das, ohne die Branch-Struktur zu beeinflussen.

Den Wechsel erzwingen

Wir haben gelernt: Git lässt keinen Branchwechsel zu, wenn uncommittete Änderungen mit dem Ziel-Branch kollidieren könnten. Wenn wir die Änderungen bewusst verwerfen und trotzdem wechseln wollen, können wir den Wechsel mit der Option -f erzwingen:

git switch -f <branch-name>

Dabei gibt es wichtige Hinweise zu beachten. 

• Alle uncommitteten Änderungen gehen ohne Warnung verloren. Nicht gesicherte Arbeit kann damit unwiederbringlich verschwinden. 
• Wer -f unbedacht nutzt, unterläuft saubere Versionskontrollpraktiken wie Stashen oder Committen von WIP-Änderungen. Das kann die Historie verwässern und die Zusammenarbeit erschweren. git switch -f ist schnell und bequem – setze es mit Bedacht ein und kenne die Risiken.

Fazit

Mit git switch ist das Wechseln und Erstellen von Branches einfacher als mit dem älteren git checkout.

Der Befehl vereinfacht den Prozess und reduziert Fehler – ideal, um Codebasen effizient zu verwalten.

So lassen sich typische Stolperfallen vermeiden, etwa versehentliches Überschreiben von Änderungen oder die Verwechslung der unterschiedlichen Funktionen von git checkout.

Wer git switch einsetzt, navigiert Git-Branches intuitiver und verbessert die Zusammenarbeit im Team.