Git-Branches: Parallel arbeiten ohne Konflikte

Was sind Zweige und warum braucht man sie?

Ein Zweig in Git ist eine unabhängige Entwicklungslinie. Technisch gesehen ist ein Branch nur ein Zeiger auf einen bestimmten Commit. Dies macht das Erstellen von Branches zu einem unglaublich schnellen und einfachen Prozess.

Die wichtigsten Szenarien für die Verwendung von Zweigen:

• Entwicklung neuer Funktionen isoliert vom Hauptcode

• Fehlerkorrektur ohne Beeinträchtigung der aktuellen Entwicklung

• Experimentieren mit Code ohne das Risiko, etwas zu beschädigen

• Parallele Arbeit mehrerer Entwickler an verschiedenen Aufgaben

  

Grundlegende Vorgänge mit Zweigen

Neuen Thread erstellen

Sie können einen Thread mit dem folgenden Befehl erstellen:

git branch feature-auth

Dieser Befehl erstellt einen neuen Zweig, wechselt jedoch nicht zu ihm. Um einen Zweig zu erstellen und sofort zu ihm zu wechseln, verwenden Sie:

git checkout -b feature-auth

Oder in einer moderneren Syntax:

git switch -c feature-auth

Zwischen Zweigen wechseln

Um zu einem bestehenden Zweig zu wechseln, verwenden Sie:

git checkout main

Oder:

git switch main

Der Befehl git switch wurde in Git 2.23 eingeführt und wurde speziell für das Umschalten von Branches entwickelt, um die Syntax verständlicher zu machen. git checkout führt viele verschiedene Operationen aus, was manchmal verwirrend ist.

Liste der Zweige anzeigen

Um alle lokalen Zweige zu sehen:

git branch

Der aktuelle Thread wird mit einem Sternchen markiert. So zeigen Sie alle Threads an, einschließlich gelöschter:

git branch -a

Ein nützlicher Befehl zum Anzeigen von Zweigen mit zusätzlichen Informationen:

git branch -v

Es wird der letzte Commit in jedem Zweig angezeigt.

Zusammenführung von Zweigen

Nachdem Sie die Arbeit an der Funktion in einem separaten Zweig abgeschlossen haben, muss sie wieder in den Hauptzweig eingefügt werden. Verwenden Sie dazu den Befehl git merge.

Fast-forward merge

Der einfachste Fall ist, wenn es nach dem Erstellen Ihres Feature-Zweigs keine neuen Commits im Hauptzweig gab:

git checkout main
git merge feature-auth

In diesem Fall verschiebt Git einfach den Zeiger des Zweigs main nach vorne. Dies wird als Fast-Forward-Zusammenführung bezeichnet.

Three-way merge

Wenn nach dem Erstellen eines Feature-Zweigs neue Commits im Hauptzweig erscheinen, erstellt Git einen Merge-Commit, der Änderungen aus beiden Zweigen zusammenführt:

git checkout main
git merge feature-user-profile

Git erstellt automatisch einen Merge-Commit mit einer Nachricht wie "Merge branch 'feature-user-profile'".

Konfliktlösung

Konflikte treten auf, wenn dieselben Zeilen in Dateien in verschiedenen Zweigen geändert werden. Git kann nicht automatisch entscheiden, welche Änderungen beibehalten werden sollen, und bittet Sie um Hilfe.

Wenn ein Konflikt auftritt, markiert Git die Problembereiche in den Dateien:

<<<<<<< HEAD
const apiUrl = 'https://api.example.com/v1';
=======
const apiUrl = 'https://api.newdomain.com/v2';
>>>>>>> feature-api-update

Der Block zwischen <<<<<<< HEAD und ======= enthält Änderungen aus dem aktuellen Zweig, und der Block zwischen ======= und >>>>>>> feature-api-update enthält Änderungen aus dem zusammenzuführenden Zweig.

Um den Konflikt zu lösen:

1. Öffnen Sie die Datei und wählen Sie die gewünschten Änderungen aus, indem Sie die Konfliktmarkierungen löschen

2. Speichern Sie die Datei

3. Fügen Sie die Datei zum Staging-Bereich hinzu: git add filename.js

4. Fusion abschließen: git commit

Viele IDEs und Code-Editoren verfügen über integrierte Tools zur visuellen Lösung von Konflikten, was den Prozess erheblich vereinfacht.

Rebase: eine Alternative zu merge

Neben merge gibt es eine weitere Möglichkeit, Änderungen zu integrieren — rebase. Es verschiebt Ihren Zweig an die Spitze eines anderen Zweigs und schreibt die Commit-Historie neu.

git checkout feature-payment
git rebase main

Dieser Befehl nimmt alle Commits von feature-payment und wendet sie auf den letzten Commit in main an.

Unterschiede zwischen merge und rebase

Merge speichert den vollständigen Verlauf und erstellt einen zusätzlichen Merge-Commit. Die Geschichte ist nicht linear, spiegelt aber den tatsächlichen Entwicklungsprozess wider.

Rebase erstellt eine lineare Geschichte, indem es Commits umschreibt. Dies macht die Geschichte sauberer und leichter verständlich, aber Informationen darüber, wann genau die Zweige parallel existierten, gehen verloren.

Wichtige Regel: Führen Sie niemals ein Rebase von öffentlichen Branches durch, mit denen andere Entwickler arbeiten. Dies überschreibt die Historie und verursacht Probleme für das gesamte Team.

Strategien für die Arbeit mit Zweigen

Git Flow

Ein beliebtes Verzweigungsmodell, vorgeschlagen von Vincent Driessen. Hauptzweige:

• main — stabiler Produktionscode

• develop — Integrationszweig für die Entwicklung

• feature/* — Branches für neue Funktionen

• release/* — Vorbereitung auf die Veröffentlichung

• hotfix/* — dringende Korrekturen in der Produktion

GitHub Flow

Ein vereinfachtes Modell, das in Continuous Delivery-Teams beliebt ist:

• main — immer bereit zum Einsatz

• Feature-Branches werden von main erstellt

• Nach der Überprüfung werden die Änderungen über eine Pull-Anfrage wieder in die Hauptversion eingefügt

• Die Bereitstellung erfolgt unmittelbar nach der Zusammenführung

Trunk-Based Development

Minimalistischer Ansatz:

• Ein Hauptzweig (trunk/main)

• Entwickler verpflichten sich direkt zu main oder erstellen kurzlebige Zweige

• Feature Flags werden verwendet, um unvollständige Funktionen auszublenden

• Erfordert hohe Disziplin und gute Autotests

Praktische Tipps

Benennen von Zweigen

Verwenden Sie verständliche und strukturierte Namen:

feature/user-authentication
bugfix/login-redirect
hotfix/payment-gateway
refactor/api-endpoints

Regelmäßige Synchronisierung mit dem Hauptzweig

Wenn Sie längere Zeit an einem Feature-Branch arbeiten, ziehen Sie regelmäßig Änderungen aus dem Main-Branch:

git checkout feature-dashboard
git merge main

Dies wird dazu beitragen, größere Konflikte bei der endgültigen Fusion zu vermeiden.

Verzweigungen entfernen

Nach dem Zusammenführen des Zweigs kann er gelöscht werden:

git branch -d feature-auth

So erzwingen Sie das Entfernen eines nicht zusammengefügten Zweigs:

git branch -D experimental-feature

Entfernen eines entfernten Zweigs:

git push origin --delete feature-auth

Verlauf der Zweige anzeigen

Visualisierung der Commit-Historie mit Branches:

git log --oneline --graph --all

Dieser Befehl zeigt einen Commit-Baum mit allen Zweigen in einem kompakten Format an.

Arbeiten mit Remote-Branches

Lokalen Zweig an den Server senden

git push -u origin feature-api

Die Option -u stellt eine Verbindung zwischen dem lokalen und dem entfernten Zweig her.

Abrufen von entfernten Zweigen

Um neue Zweige vom Server zu sehen:

git fetch origin

Erstellen eines lokalen Zweigs basierend auf einem Remote-Zweig:

git checkout -b feature-api origin/feature-api

Oder kurz gesagt:

git checkout --track origin/feature-api

Befund

Git-Branches sind ein leistungsstarkes Tool zur Organisation paralleler Arbeiten an einem Projekt. Sie ermöglichen es, die Entwicklung neuer Funktionen zu isolieren, sicher mit Code zu experimentieren und effektiv im Team zu arbeiten. Das Verständnis der Grundlagen der Arbeit mit Branches, Merging und Konfliktlösung ist eine notwendige Fähigkeit für jeden modernen Entwickler.

Fangen Sie einfach an: Erstellen Sie für jede neue Aufgabe einen eigenen Zweig, nehmen Sie regelmäßig Änderungen vor und fügen Sie die fertigen Funktionen wieder in den Hauptzweig ein. Mit der Erfahrung wirst du den Workflow finden, der am besten zu dir und deinem Team passt.

Anlage Kodik bietet strukturierte Programmierkurse für Entwickleranfänger. Die Schulung basiert auf praktischen Beispielen und realen Aufgaben, mit denen Sie schnell mit dem Schreiben von Code beginnen können.

Schließen Sie sich unserem Telegram-Kanal, wo wir regelmäßig nützliche Artikel und Analysen komplexer Themen veröffentlichen und Fragen von Programmieranfängern beantworten. Gemeinsam lernt man einfacher und effektiver!