Git-Befehle Spickzettel 2026 - Komplett-Referenz

Einleitung: Git meistern im Jahr 2026

Git ist das weltweit am häufigsten verwendete Versionskontrollsystem und ein absolutes Muss für jeden Softwareentwickler. Ob Sie allein an einem persönlichen Projekt arbeiten oder in einem Team von hundert Entwicklern -- die Beherrschung von Git-Befehlen ist eine grundlegende Fähigkeit, die Ihre Produktivität und Zusammenarbeit erheblich verbessert.

Dieser umfassende Spickzettel deckt alle Git-Befehle ab, die Sie im Jahr 2026 kennen müssen. Von den absoluten Grundlagen bis hin zu fortgeschrittenen Techniken, die selbst erfahrene Entwickler manchmal nachschlagen müssen. Speichern Sie diese Seite als Lesezeichen -- Sie werden immer wieder darauf zurückkommen.

Grundlegende Konfiguration

Bevor Sie mit Git arbeiten, sollten Sie Ihre grundlegende Konfiguration einrichten. Diese Einstellungen werden bei jedem Commit verwendet.

# Benutzername und E-Mail konfigurieren
git config --global user.name "Ihr Name"
git config --global user.email "ihre.email@beispiel.de"

# Standard-Editor festlegen
git config --global core.editor "code --wait"

# Standard-Branch-Name ändern (von master auf main)
git config --global init.defaultBranch main

# Alle Konfigurationen anzeigen
git config --list

# Bestimmte Konfiguration anzeigen
git config user.name

# Farbausgabe aktivieren
git config --global color.ui auto

# Zeilenende-Behandlung (wichtig für plattformübergreifende Teams)
git config --global core.autocrlf input   # macOS/Linux
git config --global core.autocrlf true    # Windows

Repository erstellen und klonen

Neues Repository erstellen

# Neues lokales Repository initialisieren
git init

# Neues Repository mit spezifischem Branch-Namen
git init --initial-branch=main

# Neues Bare-Repository erstellen (für Server)
git init --bare projekt.git

Bestehendes Repository klonen

# Repository über HTTPS klonen
git clone https://github.com/benutzer/repository.git

# Repository über SSH klonen
git clone git@github.com:benutzer/repository.git

# In bestimmtes Verzeichnis klonen
git clone https://github.com/benutzer/repository.git mein-ordner

# Nur den neuesten Commit klonen (flacher Klon)
git clone --depth 1 https://github.com/benutzer/repository.git

# Bestimmten Branch klonen
git clone --branch develop https://github.com/benutzer/repository.git

# Rekursiv klonen (mit Submodulen)
git clone --recursive https://github.com/benutzer/repository.git

Änderungen verfolgen

Status und Unterschiede

# Aktuellen Status anzeigen
git status

# Kurzform des Status
git status -s

# Nicht-gestaged Änderungen anzeigen
git diff

# Gestaged Änderungen anzeigen
git diff --staged

# Änderungen zwischen zwei Branches vergleichen
git diff main..develop

# Änderungen zwischen zwei Commits vergleichen
git diff abc123..def456

# Nur geänderte Dateinamen anzeigen
git diff --name-only

# Statistik der Änderungen anzeigen
git diff --stat

Dateien zum Staging-Bereich hinzufügen

# Bestimmte Datei hinzufügen
git add datei.txt

# Mehrere Dateien hinzufügen
git add datei1.txt datei2.txt datei3.txt

# Alle Änderungen im aktuellen Verzeichnis hinzufügen
git add .

# Alle Änderungen im gesamten Repository hinzufügen
git add -A

# Interaktiv Teile einer Datei hinzufügen
git add -p datei.txt

# Alle Dateien mit bestimmter Endung hinzufügen
git add *.js

Commits erstellen

# Commit mit Nachricht
git commit -m "Beschreibende Commit-Nachricht"

# Commit mit mehrzeiliger Nachricht
git commit -m "Kurze Zusammenfassung" -m "Detaillierte Beschreibung der Änderungen"

# Alle geänderten (getrackte) Dateien hinzufügen und committen
git commit -am "Alle Änderungen committen"

# Letzten Commit ändern (Nachricht oder Dateien)
git commit --amend -m "Korrigierte Commit-Nachricht"

# Leeren Commit erstellen (z.B. für CI/CD-Trigger)
git commit --allow-empty -m "CI/CD-Build auslösen"

# Commit mit spezifischem Datum
git commit --date="2026-03-15T10:00:00" -m "Rückdatierter Commit"

Branch-Verwaltung

Branches sind eines der leistungsstärksten Features von Git. Sie ermöglichen parallele Entwicklung, ohne den Hauptcode zu beeinflussen.

# Alle lokalen Branches auflisten
git branch

# Alle Branches (lokal und remote) auflisten
git branch -a

# Neuen Branch erstellen
git branch feature/neues-feature

# Branch erstellen und sofort wechseln
git checkout -b feature/neues-feature
# oder mit dem moderneren Befehl:
git switch -c feature/neues-feature

# Zu einem Branch wechseln
git checkout develop
# oder:
git switch develop

# Branch umbenennen
git branch -m alter-name neuer-name

# Aktuellen Branch umbenennen
git branch -m neuer-name

# Branch löschen (nur wenn gemergt)
git branch -d feature/erledigtes-feature

# Branch erzwungen löschen
git branch -D feature/experimentelles-feature

# Remote-Branch löschen
git push origin --delete feature/erledigtes-feature

# Branches anzeigen, die bereits gemergt sind
git branch --merged

# Branches anzeigen, die noch nicht gemergt sind
git branch --no-merged

Merging und Rebasing

Merging

# Branch in aktuellen Branch mergen
git merge feature/neues-feature

# Merge mit expliziter Merge-Commit-Nachricht
git merge feature/neues-feature -m "Feature X implementiert"

# Fast-Forward-Merge erzwingen (wenn möglich)
git merge --ff-only feature/neues-feature

# Merge ohne Fast-Forward (immer Merge-Commit erstellen)
git merge --no-ff feature/neues-feature

# Merge abbrechen
git merge --abort

# Merge-Konflikte anzeigen
git diff --name-only --diff-filter=U

Rebasing

# Aktuellen Branch auf main rebasen
git rebase main

# Interaktives Rebase für die letzten 3 Commits
git rebase -i HEAD~3

# Rebase abbrechen
git rebase --abort

# Rebase nach Konfliktlösung fortsetzen
git rebase --continue

# Rebase überspringen (aktuellen Commit)
git rebase --skip

Merge-Konflikte lösen

Wenn Git einen Merge-Konflikt meldet, sehen die betroffenen Dateien so aus:

<<<<<<< HEAD
Ihr Code (aktueller Branch)
=======
Eingehender Code (zu mergender Branch)
>>>>>>> feature/neues-feature

Schritte zur Lösung:

Öffnen Sie die konfliktbehaftete Datei
Entscheiden Sie, welchen Code Sie behalten möchten
Entfernen Sie die Konflikt-Markierungen (<<<<<<<, =======, >>>>>>>)
Fügen Sie die gelöste Datei zum Staging hinzu: git add datei.txt
Schließen Sie den Merge ab: git commit

Remote-Repositories

Remote-Verwaltung

# Remote-Repositories auflisten
git remote -v

# Remote hinzufügen
git remote add origin https://github.com/benutzer/repo.git

# Remote-URL ändern
git remote set-url origin https://github.com/benutzer/neues-repo.git

# Remote entfernen
git remote remove origin

# Remote umbenennen
git remote rename origin upstream

Push und Pull

# Änderungen zum Remote pushen
git push origin main

# Ersten Push mit Upstream-Tracking
git push -u origin main

# Alle Branches pushen
git push --all origin

# Tags pushen
git push --tags

# Force-Push (Vorsicht! Überschreibt Remote-History)
git push --force origin main

# Sicherer Force-Push
git push --force-with-lease origin main

# Änderungen vom Remote holen
git fetch origin

# Alle Remotes fetchen
git fetch --all

# Änderungen holen und mergen
git pull origin main

# Pull mit Rebase statt Merge
git pull --rebase origin main

Commit-History

Log anzeigen

# Commit-History anzeigen
git log

# Kompakte Einzeilenansicht
git log --oneline

# Grafische Darstellung der Branches
git log --oneline --graph --all

# Log mit Dateiänderungen
git log --stat

# Log mit vollständigen Diffs
git log -p

# Letzte N Commits anzeigen
git log -5

# Commits eines bestimmten Autors
git log --author="Max Mustermann"

# Commits in einem Zeitraum
git log --after="2026-01-01" --before="2026-03-15"

# Commits die bestimmten Text enthalten
git log --grep="Bugfix"

# Log für eine bestimmte Datei
git log -- datei.txt

# Log mit hübschem Format
git log --pretty=format:"%h - %an, %ar : %s"

Blame und Bisect

# Zeile für Zeile Autor anzeigen
git blame datei.txt

# Blame für bestimmte Zeilen
git blame -L 10,20 datei.txt

# Bisect starten (Bug suchen)
git bisect start
git bisect bad           # Aktueller Commit ist fehlerhaft
git bisect good abc123   # Dieser Commit war noch in Ordnung
# Git wählt einen Commit zum Testen...
git bisect good   # oder git bisect bad
# Wiederholen bis der fehlerhafte Commit gefunden ist
git bisect reset  # Bisect beenden

Änderungen rückgängig machen

Dateien zurücksetzen

# Nicht-gestaged Änderungen einer Datei verwerfen
git checkout -- datei.txt
# oder moderner:
git restore datei.txt

# Datei aus dem Staging entfernen
git reset HEAD datei.txt
# oder moderner:
git restore --staged datei.txt

# Alle nicht-gestaged Änderungen verwerfen
git checkout -- .
# oder:
git restore .

Commits zurücksetzen

# Letzten Commit rückgängig machen (Änderungen behalten)
git reset --soft HEAD~1

# Letzten Commit und Staging rückgängig machen (Änderungen behalten)
git reset --mixed HEAD~1

# Letzten Commit komplett rückgängig machen (ACHTUNG: Datenverlust!)
git reset --hard HEAD~1

# Bestimmten Commit rückgängig machen (neuer Gegencommit)
git revert abc123

# Mehrere Commits revertieren
git revert abc123..def456

Stashing: Änderungen zwischenspeichern

Git Stash ist äußerst nützlich, wenn Sie schnell den Branch wechseln müssen, ohne Ihre aktuellen Änderungen zu committen.

# Aktuelle Änderungen stashen
git stash

# Stash mit Beschreibung
git stash push -m "Work in Progress: Login-Feature"

# Nur bestimmte Dateien stashen
git stash push -m "Teilweise Änderungen" datei1.txt datei2.txt

# Auch ungetrackte Dateien stashen
git stash -u

# Stash-Liste anzeigen
git stash list

# Neuesten Stash anwenden (und behalten)
git stash apply

# Neuesten Stash anwenden und löschen
git stash pop

# Bestimmten Stash anwenden
git stash apply stash@{2}

# Stash als neuen Branch anwenden
git stash branch neuer-branch stash@{0}

# Bestimmten Stash löschen
git stash drop stash@{1}

# Alle Stashes löschen
git stash clear

Tags: Versionen markieren

# Leichtgewichtigen Tag erstellen
git tag v1.0.0

# Annotierten Tag erstellen (empfohlen)
git tag -a v1.0.0 -m "Version 1.0.0 Release"

# Tag für älteren Commit erstellen
git tag -a v0.9.0 abc123 -m "Version 0.9.0"

# Alle Tags auflisten
git tag

# Tags mit Muster filtern
git tag -l "v1.*"

# Tag-Details anzeigen
git show v1.0.0

# Tag pushen
git push origin v1.0.0

# Alle Tags pushen
git push origin --tags

# Tag löschen (lokal)
git tag -d v1.0.0

# Tag löschen (remote)
git push origin --delete v1.0.0

Fortgeschrittene Techniken

Cherry-Pick

# Einen bestimmten Commit in den aktuellen Branch übernehmen
git cherry-pick abc123

# Cherry-Pick ohne automatischen Commit
git cherry-pick --no-commit abc123

# Mehrere Commits cherry-picken
git cherry-pick abc123 def456 ghi789

# Cherry-Pick abbrechen
git cherry-pick --abort

Worktrees

# Neuen Worktree erstellen
git worktree add ../hotfix-branch hotfix/kritischer-bug

# Worktrees auflisten
git worktree list

# Worktree entfernen
git worktree remove ../hotfix-branch

# Verwaiste Worktrees bereinigen
git worktree prune

Reflog: Die Rettungsleine

Das Reflog zeichnet jede Änderung am HEAD auf und ist Ihre Rettung, wenn etwas schiefgeht.

# Reflog anzeigen
git reflog

# Zu einem bestimmten Reflog-Eintrag zurückkehren
git reset --hard HEAD@{5}

# Gelöschten Branch wiederherstellen
git checkout -b wiederhergestellter-branch HEAD@{3}

Git Clean

# Ungetrackte Dateien anzeigen, die gelöscht würden
git clean -n

# Ungetrackte Dateien löschen
git clean -f

# Ungetrackte Dateien und Verzeichnisse löschen
git clean -fd

# Auch ignorierte Dateien löschen
git clean -fdx

Git-Aliase für mehr Produktivität

Sparen Sie Tipparbeit mit benutzerdefinierten Aliasen:

# Nützliche Aliase einrichten
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.lg "log --oneline --graph --all --decorate"
git config --global alias.last "log -1 HEAD --stat"
git config --global alias.unstage "restore --staged"
git config --global alias.amend "commit --amend --no-edit"

.gitignore -- Dateien ausschließen

Eine gute .gitignore-Datei ist essentiell. Hier ein universelles Beispiel:

# Betriebssystem-Dateien
.DS_Store
Thumbs.db

# IDE-Dateien
.idea/
.vscode/
*.swp
*.swo

# Abhängigkeiten
node_modules/
vendor/
.venv/

# Build-Ausgaben
dist/
build/
*.o
*.exe

# Umgebungsvariablen
.env
.env.local
.env.production

# Logs
*.log
logs/

# Temporäre Dateien
tmp/
*.tmp

Best Practices für Git-Workflows

Commit-Nachrichten richtig schreiben

Gute Commit-Nachrichten folgen einer klaren Struktur:

feat: Benutzerregistrierung implementiert

- E-Mail-Validierung hinzugefügt
- Passwort-Hashing mit bcrypt
- Bestätigungsmail-Versand integriert

Closes #123

Verwenden Sie konventionelle Prefixe:

feat: -- Neues Feature
fix: -- Bugfix
docs: -- Dokumentation
style: -- Formatierung (kein Codewechsel)
refactor: -- Code-Umstrukturierung
test: -- Tests hinzufügen oder ändern
chore: -- Wartungsarbeiten

Branch-Strategie

Eine bewährte Branch-Strategie für Teams:

main -- Produktionscode, immer stabil
develop -- Entwicklungsbranch, Integration neuer Features
feature/* -- Feature-Branches, von develop abgezweigt
hotfix/* -- Dringende Fixes, von main abgezweigt
release/* -- Release-Vorbereitung

Nützliche Git-Werkzeuge

Ergänzen Sie Ihre Git-Kenntnisse mit diesen Werkzeugen:

Verwenden Sie unseren JSON-Formatierer zum Formatieren von Konfigurationsdateien
Nutzen Sie den Regex-Tester für .gitignore-Muster
Der Base64-Kodierer kann bei der Arbeit mit Git-Hooks nützlich sein

Fazit

Git ist ein mächtiges Werkzeug, das weit mehr kann als nur add, commit und push. Indem Sie die fortgeschrittenen Befehle und Techniken in diesem Spickzettel beherrschen, werden Sie in der Lage sein, komplexe Entwicklungsszenarien souverän zu bewältigen. Speichern Sie diese Seite als Referenz und üben Sie die Befehle regelmäßig -- mit der Zeit werden sie zur zweiten Natur.