# Git CheatSheet

Übersicht der wichtigsten Git-Befehle mit praktischen Beispielen.

---

## Repository erstellen & klonen

```bash
# Neues Repository im aktuellen Verzeichnis initialisieren
git init

# Neues Repository mit Verzeichnis erstellen
git init mein-projekt

# Bestehendes Repository klonen
git clone https://github.com/user/repo.git

# Klonen in ein bestimmtes Verzeichnis
git clone https://github.com/user/repo.git mein-ordner

# Nur den neuesten Commit klonen (shallow clone)
git clone --depth 1 https://github.com/user/repo.git
```

---

## Konfiguration

```bash
# Benutzername setzen (global)
git config --global user.name "Max Mustermann"

# E-Mail setzen (global)
git config --global user.email "max@example.com"

# Konfiguration nur für aktuelles Repo
git config user.name "Max Mustermann"

# Alle Einstellungen anzeigen
git config --list

# Standard-Branch-Name setzen
git config --global init.defaultBranch main

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

# Aliase erstellen
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --all"
```

---

## Status & Änderungen

```bash
# Aktuellen Status anzeigen
git status

# Kurzform des Status
git status -s

# Änderungen anzeigen (noch nicht gestaged)
git diff

# Änderungen anzeigen (bereits gestaged)
git diff --staged

# Änderungen einer bestimmten Datei
git diff datei.txt

# Vergleich zwischen zwei Branches
git diff main..feature-branch

# Vergleich zwischen zwei Commits
git diff abc123 def456
```

---

## Dateien hinzufügen (Staging)

```bash
# Einzelne Datei hinzufügen
git add datei.txt

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

# Alle Dateien im aktuellen Verzeichnis
git add .

# Alle Änderungen (inkl. gelöschte Dateien)
git add -A

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

# Dateien nach Muster hinzufügen
git add *.js
git add src/
```

---

## Commits

```bash
# Commit mit Nachricht
git commit -m "Kurze Beschreibung der Änderung"

# Alle geänderten Dateien committen (ohne git add)
git commit -am "Änderungen committen"

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

# Leeren Commit erstellen (z.B. für CI-Trigger)
git commit --allow-empty -m "Trigger CI"

# Commit mit mehrzeiliger Nachricht
git commit -m "Titel" -m "Detaillierte Beschreibung"
```

---

## Branches

```bash
# Alle lokalen Branches anzeigen
git branch

# Alle Branches (lokal + remote)
git branch -a

# Neuen Branch erstellen
git branch feature-login

# Branch erstellen und wechseln
git checkout -b feature-login
# oder (neuere Syntax)
git switch -c feature-login

# Zu einem Branch wechseln
git checkout main
# oder
git switch main

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

# Branch löschen (lokal)
git branch -d feature-login

# Branch löschen (forciert, auch ungemergte)
git branch -D feature-login

# Remote-Branch löschen
git push origin --delete feature-login
```

---

## Merging

```bash
# Branch in aktuellen Branch mergen
git merge feature-login

# Merge ohne Fast-Forward (behält Branch-Historie)
git merge --no-ff feature-login

# Merge abbrechen (bei Konflikten)
git merge --abort

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

---

## Rebasing

```bash
# Aktuellen Branch auf main rebasen
git rebase main

# Interaktives Rebase (letzte 3 Commits)
git rebase -i HEAD~3

# Rebase abbrechen
git rebase --abort

# Nach Konfliktlösung fortfahren
git rebase --continue

# Einzelnen Commit überspringen
git rebase --skip
```

---

## Remote-Repositories

```bash
# Remote-Repositories anzeigen
git remote -v

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

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

# Remote entfernen
git remote remove origin

# Remote umbenennen
git remote rename origin upstream
```

---

## Push & Pull

```bash
# Änderungen pushen
git push origin main

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

# Danach reicht:
git push

# Force-Push (Vorsicht!)
git push --force
# Sicherer:
git push --force-with-lease

# Änderungen holen und mergen
git pull

# Änderungen holen ohne Merge
git fetch

# Alle Remotes fetchen
git fetch --all

# Mit Rebase statt Merge
git pull --rebase
```

---

## Stashing (Änderungen zwischenspeichern)

```bash
# Aktuelle Änderungen stashen
git stash

# Stash mit Beschreibung
git stash save "Arbeit an Feature X"

# Auch untracked Dateien stashen
git stash -u

# Stash-Liste anzeigen
git stash list

# Letzten Stash anwenden und behalten
git stash apply

# Letzten Stash anwenden und löschen
git stash pop

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

# Stash löschen
git stash drop stash@{0}

# Alle Stashes löschen
git stash clear

# Stash als neuen Branch
git stash branch neuer-branch
```

---

## Historie & Logs

```bash
# Commit-Historie anzeigen
git log

# Kompakte Ansicht
git log --oneline

# Mit Graph
git log --oneline --graph --all

# Letzte n Commits
git log -5

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

# Commits in Zeitraum
git log --since="2024-01-01" --until="2024-12-31"

# Commits mit bestimmtem Text
git log --grep="bugfix"

# Änderungen in Datei verfolgen
git log -p datei.txt

# Wer hat welche Zeile geändert
git blame datei.txt

# Kurze Statistik
git log --stat

# Änderungen pro Autor
git shortlog -sn
```

---

## Rückgängig machen

```bash
# Unstaged Änderungen verwerfen
git checkout -- datei.txt
# oder (neuere Syntax)
git restore datei.txt

# Staged Datei zurück zu unstaged
git reset HEAD datei.txt
# oder
git restore --staged datei.txt

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

# Letzten Commit rückgängig (verwirft Änderungen)
git reset --hard HEAD~1

# Zu bestimmtem Commit zurück
git reset --hard abc1234

# Commit rückgängig machen (neuer Commit)
git revert abc1234

# Alle lokalen Änderungen verwerfen
git checkout .
git clean -fd
```

---

## Tags

```bash
# Alle Tags anzeigen
git tag

# Lightweight Tag erstellen
git tag v1.0.0

# Annotated Tag mit Nachricht
git tag -a v1.0.0 -m "Version 1.0.0 Release"

# Tag für älteren Commit
git tag -a v0.9.0 abc1234 -m "Nachträglicher Tag"

# Tags 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

# Zu Tag wechseln
git checkout v1.0.0
```

---

## Cherry-Pick

```bash
# Einzelnen Commit in aktuellen Branch übernehmen
git cherry-pick abc1234

# Mehrere Commits
git cherry-pick abc1234 def5678

# Cherry-Pick ohne Commit (nur Änderungen übernehmen)
git cherry-pick -n abc1234

# Bei Konflikten fortfahren
git cherry-pick --continue

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

---

## Suchen

```bash
# In Dateien suchen
git grep "suchbegriff"

# Mit Zeilennummern
git grep -n "suchbegriff"

# In bestimmtem Commit suchen
git grep "suchbegriff" abc1234

# Commit finden, der einen Bug eingeführt hat
git bisect start
git bisect bad                  # Aktueller Commit ist kaputt
git bisect good abc1234         # Dieser Commit war noch OK
# Git führt dich durch die Commits
git bisect reset                # Beenden
```

---

## Aufräumen

```bash
# Untracked Dateien anzeigen
git clean -n

# Untracked Dateien löschen
git clean -f

# Auch Verzeichnisse
git clean -fd

# Auch ignorierte Dateien
git clean -fdx

# Nicht mehr existierende Remote-Branches entfernen
git fetch --prune

# Alte Objekte aufräumen
git gc

# Aggressive Aufräumung
git gc --aggressive
```

---

## Submodules

```bash
# Submodule hinzufügen
git submodule add https://github.com/user/lib.git libs/lib

# Submodules beim Klonen initialisieren
git clone --recurse-submodules https://github.com/user/repo.git

# Submodules nachträglich initialisieren
git submodule init
git submodule update

# Alle Submodules aktualisieren
git submodule update --remote

# Submodule entfernen
git submodule deinit libs/lib
git rm libs/lib
```

---

## Nützliche Kombinationen

```bash
# Letzten Commit-Hash anzeigen
git rev-parse HEAD

# Aktuellen Branch-Namen anzeigen
git branch --show-current

# Anzahl Commits zählen
git rev-list --count HEAD

# Alle Dateien eines Commits auflisten
git diff-tree --no-commit-id --name-only -r abc1234

# Änderungen seit letztem Tag
git log $(git describe --tags --abbrev=0)..HEAD --oneline

# Dateien im Staging-Bereich anzeigen
git diff --cached --name-only

# Lokale Branches ohne Remote löschen
git fetch -p && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -D
```

---

## .gitignore Beispiele

```gitignore
# Verzeichnisse
node_modules/
vendor/
.idea/
.vscode/

# Dateitypen
*.log
*.tmp
*.cache

# Spezifische Dateien
.env
.DS_Store
Thumbs.db

# Ausnahmen (nicht ignorieren)
!wichtig.log

# Muster
**/logs/
debug[0-9].log
```

---

## Häufige Workflows

### Feature-Branch Workflow

```bash
git checkout main
git pull
git checkout -b feature/neue-funktion
# ... Änderungen ...
git add .
git commit -m "Neue Funktion implementiert"
git push -u origin feature/neue-funktion
# Pull Request erstellen, dann:
git checkout main
git pull
git branch -d feature/neue-funktion
```

### Hotfix Workflow

```bash
git checkout main
git pull
git checkout -b hotfix/kritischer-bug
# ... Fix ...
git commit -am "Kritischen Bug behoben"
git checkout main
git merge hotfix/kritischer-bug
git tag -a v1.0.1 -m "Hotfix Release"
git push origin main --tags
git branch -d hotfix/kritischer-bug
```

### Rebase vor Merge

```bash
git checkout feature-branch
git fetch origin
git rebase origin/main
# Konflikte lösen falls nötig
git push --force-with-lease
```

---

## Tipps

- **Commit oft**: Kleine, fokussierte Commits sind besser als große.
- **Aussagekräftige Nachrichten**: Was wurde geändert und warum?
- **Branches nutzen**: Nie direkt auf main/master entwickeln.
- **Vor Push prüfen**: `git log origin/main..HEAD` zeigt ausstehende Commits.
- **Backup vor Reset**: Bei `--hard` gehen Änderungen verloren!
- **Force-Push vermeiden**: Nur auf eigenen Feature-Branches.

---

*Erstellt: 04 Februar 2026*