Git Praxisguide

1Konzepte & Das Drei-Ebenen-Modell

Git ist ein verteiltes Versionskontrollsystem. Es speichert nicht einfach Dateiversionen, sondern eine vollständige Geschichte aller Änderungen – wer was wann geändert hat – und erlaubt es mehreren Personen, gleichzeitig zu arbeiten.

Die wichtigsten Begriffe

Das Drei-Ebenen-Modell

Das ist das wichtigste Konzept in Git. Wenn du dieses Modell verstehst, macht alles andere Sinn:

2Erstkonfiguration

Vor dem ersten Commit müssen Name und E-Mail gesetzt werden – sie erscheinen in jedem Commit für immer.

Kopieren# Einmalig global setzen (für alle Projekte)
git config --global user.name "Dein Name"
git config --global user.email "deine@email.de"

# Farbige Ausgabe aktivieren
git config --global color.ui auto

# Standard-Editor (z.B. VS Code)
git config --global core.editor "code --wait"

# Konfiguration prüfen
git config --list

3Repository starten

Neues lokales Repository anlegen

Kopieren# Im gewünschten Ordner:
git init mein-projekt
cd mein-projekt

Vorhandenes Remote-Repository clonen einmalig

Kopierengit clone https://github.com/org/repo.git

# In einen bestimmten Ordner clonen:
git clone https://github.com/org/repo.git mein-ordner

4Täglicher Workflow

Dieser Abschnitt erklärt nicht nur was du tust, sondern warum, wann – und wann ausdrücklich nicht. Der Fokus liegt auf dem realen Arbeitsalltag mit einem zentralen Server-Repository und mehreren Branches.

4.1  Remote-Branches – was der Server weiß

Auf dem Server liegen Branches, die dein lokales Git kennt, aber nicht automatisch aktuell hält. Diese sogenannten Remote-Tracking-Branches haben das Präfix origin/:

4.2  Alle verfügbaren Branches anzeigen

Bevor du anfängst, verschaffe dir einen Überblick – besonders nach einem längeren Urlaub oder in einem neuen Projekt:

Kopierengit branch              # nur lokale Branches
# Ausgabe:  * main          ← * = aktueller Branch
#             feature/login

git branch -r            # nur Remote-Branches (was der Server hat)
# Ausgabe:  origin/main
#           origin/feature/login
#           origin/feature/payment

git branch -a            # alle: lokal + remote
# Ausgabe:  * main
#             feature/login
#           remotes/origin/main
#           remotes/origin/feature/login
#           remotes/origin/feature/payment  ← den kennst du noch nicht lokal!

# Übersichtlicher mit Tracking-Info (wer trackt wen?)
git branch -vv
# Ausgabe:  * main    a3f9d12 [origin/main] fix: Timeout erhöht
#             feature/login  b2e1c08 [origin/feature/login: ahead 2] feat: Formular

4.3  Einen Remote-Branch lokal auschecken

Der Server hat einen Branch (origin/feature/payment), den du lokal noch nicht hast. So holst du ihn:

Kopieren# Schritt 1: Erst sicherstellen, dass du den aktuellen Server-Stand kennst
git fetch origin

# Schritt 2: Remote-Branch lokal auschecken (Git erstellt automatisch Tracking)
git checkout feature/payment
# Git erkennt: "origin/feature/payment" existiert → erstellt lokalen Branch mit Tracking
# Ausgabe: Branch 'feature/payment' set up to track remote branch 'feature/payment' from 'origin'.

# Alternative (explizit, gleiche Wirkung):
git checkout -b feature/payment origin/feature/payment

4.4  fetch – schauen bevor man handelt

git fetch ist der sicherste Befehl beim Synchronisieren. Er holt alle neuen Commits und Branch-Informationen vom Server, verändert aber weder dein Working Directory noch deine lokalen Branches.

Kopierengit fetch origin                    # alle Branches vom Remote "origin" holen
git fetch --all                     # falls du mehrere Remotes hast
git fetch --prune                   # gelöschte Remote-Branches lokal aufräumen

# Nach dem Fetch: was ist neu auf dem Server?
git log --oneline origin/main ^main  # Commits, die origin/main hat, du aber noch nicht
git diff main origin/main            # Was würde sich ändern beim Merge?

4.5  pull – der Alltagsbefehl

git pull ist git fetch + git merge in einem Schritt. Er aktualisiert deinen aktuellen Branch mit dem Gegenstück auf dem Server.

Kopierengit pull                  # aktuellen Branch vom Tracking-Remote aktualisieren
git pull origin main      # explizit: von "origin" den Branch "main" holen

Kopierengit pull --rebase          # fetch + rebase statt merge
# Vorteil: keine Merge-Commits – sauberere, lineare Historie
# Nachteil: Commits werden neu "geschrieben" → SHA ändert sich
# Empfehlung: gut für Feature-Branches, vorsichtig auf shared main

Kopieren# Du willst wissen, was auf einem anderen Branch neu ist,
# ohne selbst zu wechseln → fetch reicht:
git fetch origin feature/payment

# Den Stand von main in deinen aktuellen Feature-Branch einpflegen:
git merge origin/main     # aus Remote-Tracking direkt mergen

# NICHT empfohlen: git pull origin main auf einem Feature-Branch
# (macht dasselbe, ist aber weniger explizit)

4.6  Was du nicht tun solltest

4.7  Täglicher Workflow – Solo auf eigenem Branch

Du arbeitest an feature/login, der Server hat einen gemeinsamen main. Ziel: täglich aktuell bleiben, ohne deinen Branch zu gefährden.

Kopierengit fetch origin
# Zeigt: remote: Enumerating objects: 5, done.
# Jetzt weißt du: es gibt Neues, aber deine Dateien sind unverändert

# Optional: Was ist neu auf main?
git log --oneline origin/main ^feature/login
# → zeigt alle Commits auf main, die dein Branch noch nicht hat

Kopierengit checkout feature/login      # sicherstellen, dass du auf deinem Branch bist
git merge origin/main            # Remote-main direkt einpflegen (kein Checkout nötig!)
# → Falls Konflikte: lösen, dann git add + git commit

Kopieren# Zwischendurch jederzeit:
git status                   # Überblick
git diff                     # Was hat sich konkret geändert?

# Gezielte Dateien stagen:
git add src/login.py
git diff --staged            # nochmal prüfen bevor Commit
git commit -m "feat: Passwortfeld validierung"

Kopierengit push                     # wenn Tracking schon eingerichtet

# Erster Push eines neuen Branches (Tracking einrichten):
git push -u origin feature/login
# -u = --set-upstream: zukünftige pulls/pushes auf diesem Branch kennen das Ziel

4.8  Täglicher Workflow – Im Team, mehrere Branches

Der Server hat viele Branches. Kollegen arbeiten parallel. So behältst du den Überblick:

Kopieren# Alle Branches, die auf dem Server existieren:
git fetch --all --prune
git branch -a

# Wer hat wann was commitet? (grafisch, alle Branches)
git log --oneline --graph --all --decorate
# Sehr nützlich: zeigt, wie die Branches auseinanderlaufen

# Nur die Remote-Branches:
git branch -r --sort=-committerdate
# Sortiert nach letztem Commit – aktive Branches oben

Kopieren# Kollege hat feature/payment auf dem Server – du willst es ansehen:
git fetch origin
git checkout feature/payment     # Git erstellt lokalen Tracking-Branch

# Nur ansehen ohne zu wechseln (read-only Blick):
git log origin/feature/payment --oneline -10
git diff main origin/feature/payment  # was hat der Branch gegenüber main?

# Zurück zu deinem Branch:
git checkout feature/login

Kopieren# Feature ist fertig, Review OK – jetzt in main mergen:

# 1. main aktualisieren
git checkout main
git pull origin main

# 2. Feature-Branch mergen
git merge feature/login

# 3. Konfliktfrei? Dann pushen
git push origin main

# 4. Feature-Branch aufräumen (lokal + remote)
git branch -d feature/login               # lokal löschen
git push origin --delete feature/login    # auf dem Server löschen

4.9  Kurzreferenz: Das tägliche Minimum

5Status & Diff

Die wichtigsten Befehle zum Nachschauen, bevor man handelt.

Kopieren$ git status
On branch main
Your branch is up to date with 'origin/main'.

Changes to be committed:
  (use "git restore --staged <file>" to unstage)
        modified:   src/login.py   ← gestaged (kommt in nächsten Commit)

Changes not staged for commit:
        modified:   config/local.cfg  ← geändert, aber noch nicht gestaged

Untracked files:
        notes.txt   ← neu, Git kennt diese Datei noch nicht

6Staging & Commit

Dateien stagen

Commit erstellen

Kopierengit commit -m "feat: Suchfunktion implementiert"

# Alle bereits getrackten Dateien direkt committen (überspringt git add):
git commit -am "fix: Tippfehler in Fehlermeldung korrigiert"

# Letzten Commit nachträglich korrigieren (Nachricht oder vergessene Datei):
git commit --amend

Kopieren# Kompletter Ablauf:
git status                          # Überblick
git diff                            # Was hat sich geändert?
git add src/login.py               # Datei stagen
git diff --staged                   # Staged-Änderungen prüfen
git commit -m "feat: Login hinzugefügt"

7Push, Pull & Fetch

Der Unterschied im Überblick

Praktische Sync-Szenarien

Kopieren# Täglich aktuell halten (einfachster Weg):
git pull

# Explizit: Remote-Stand ansehen, dann mergen:
git fetch origin
git log --oneline origin/main -5    # Was gibt's Neues?
git merge origin/main

Kopieren# Du hast lokale Änderungen → erst stashen, dann pullen:
git stash
git pull
git stash pop

# Oder: erst committen, dann pullen:
git add . && git commit -m "WIP: zwischenstand"
git pull

8Branches

Ein Branch ist ein paralleler Entwicklungsstrang. Änderungen in einem Branch beeinflussen andere nicht – bis man sie zusammenführt.

Wann einen Branch anlegen?

• Neues Feature → eigener Branch, damit main stabil bleibt
• Bugfix → isoliert, leicht revertierbar
• Experiment → ausprobieren ohne Risiko
• Teamarbeit → jeder hat seinen Branch, merged zurück

Branch-Befehle

Typischer Branch-Workflow

Kopieren# 1. Auf aktuellem main starten:
git checkout main
git pull

# 2. Neuen Feature-Branch erstellen:
git checkout -b feature/benutzer-login

# 3. Arbeiten, committen...
git add . && git commit -m "feat: Login-Formular"

# 4. Branch zum Remote pushen:
git push -u origin feature/benutzer-login

# 5. Nach Review: zurück nach main und mergen:
git checkout main
git merge feature/benutzer-login
git push

# 6. Aufräumen:
git branch -d feature/benutzer-login

9Merge & Konflikte

Merge – zwei Branches zusammenführen

Kopieren# Stehe auf Branch A, pflege Branch B ein:
git checkout main
git merge feature/benutzer-login

# Remote-Stand direkt in aktuellen Branch mergen:
git merge origin/main

Was ist ein Merge-Konflikt?

Ein Konflikt entsteht, wenn zwei Personen dieselbe Zeile in derselben Datei geändert haben. Git kann nicht automatisch entscheiden, welche Version richtig ist – das entscheidest du.

So sieht ein Konflikt aus

Kopieren<<<<<<< HEAD
DB_HOST = "localhost"       # ← deine Version
=======
DB_HOST = "db-server-01"   # ← eingehende Version (origin/main)
>>>>>>> origin/main

Konflikt lösen – Schritt für Schritt

Kopierengit status   # Zeigt alle Dateien mit "both modified"

Kopierengit add datei.py        # "gelöst" markieren
git commit               # Merge-Commit erstellen

Kopierengit merge --abort        # Alles zurücksetzen wie vorher

10Stash – Arbeit schnell weglegen

Stash speichert alle nicht-committeten Änderungen in einem temporären Speicher und setzt das Working Directory auf einen sauberen Zustand zurück. Ideal, wenn du plötzlich den Branch wechseln oder pullen musst.

Typischer Stash-Workflow

Kopieren# Du arbeitest, musst aber kurz pullen:
git stash push -m "halbfertiger Login-Fix"
git pull
git stash pop

# Falls Konflikte entstehen: normal lösen (git add + git commit)

11Befehlsreferenz

Alle wichtigen Befehle auf einen Blick. Für vollständige Dokumentation: git-scm.com/docs ↗

Projekt starten

Status & Information

Dateien verwalten

Commits

Branches

Remote / Synchronisation

Stash

Notfall-Befehle

12Git GUI – Die grafische Oberfläche

Die Git GUI wird zusammen mit Git for Windows installiert und ist besonders nützlich für Übersicht und Merge-Vorgänge. Starten: Rechtsklick im Projektordner → Git GUI Here.

Fensteraufbau

Menüübersicht

Schaltflächen im Hauptfenster

13Häufige Fehler & Lösungen

„Your local changes would be overwritten by merge"

Git weigert sich zu pullen, weil uncommitted Änderungen vorhanden sind.

Kopieren# Lösung A – Stash:
git stash
git pull
git stash pop

# Lösung B – erst committen:
git add . && git commit -m "WIP: zwischenstand"
git pull

„detached HEAD state"

Du bist auf einem einzelnen Commit gelandet, nicht auf einem Branch. Neue Commits gehen verloren!

Kopieren# Sofort auf einen Branch wechseln:
git checkout main
# oder eigenen Branch retten:
git checkout -b rescue-branch  # sichert die Commits

„fatal: not a git repository"

Du bist im falschen Verzeichnis.

Kopierencd C:\Projekte\mein-projekt
git status  # jetzt sollte es funktionieren

„CONFLICT (content): Merge conflict in datei.py"

Kopierengit status       # alle Konflikte anzeigen
# Dateien manuell editieren (Marker entfernen)
git add datei.py # als gelöst markieren
git commit       # Merge abschließen

Ich will den letzten Commit rückgängig machen!

Kopieren# Commit aufheben, Dateien behalten (gestaged):
git reset --soft HEAD~1

# Commit sicher rückgängig als neuen Commit (empfohlen für gepushte Commits!):
git revert HEAD

Ich habe versehentlich mit --hard zurückgesetzt!

Kopieren# reflog zeigt alle Aktionen der letzten Wochen:
git reflog
# Dann auf den gewünschten Stand zurück:
git checkout HEAD@{2}