# Git — verteilte Versionskontrolle für deinen Quellcode

> Praxis-Guide zu Git — Konfiguration, Commits, Branching, Merge, Rebase, Remotes, Stash und History auf der Kommandozeile, mit Beispielen.

Source: https://www.jpkc.com/db/cheatsheets/version-control/git/

<!-- PROSE:intro -->
Git ist das verteilte Versionskontrollsystem, das die moderne Softwareentwicklung prägt: Jeder Klon eines Repositorys enthält die komplette Versions-Historie und funktioniert auch offline vollständig. Statt einzelne Unterschiede zu speichern, legt Git Snapshots deines gesamten Projekts an und verknüpft sie zu einem nachvollziehbaren Verlauf. Mit Branches probierst du Ideen risikofrei aus, mit Merge und Rebase führst du sie wieder zusammen. Dieser Guide zeigt dir die wichtigsten Kommandos für den Alltag – von der Erstkonfiguration über Commits und Branching bis zu Remotes, Stash und History.
<!-- PROSE:intro:end -->

## Konfiguration

`git config --global user.name "<name>"` — Setzt deinen globalen Benutzernamen für alle Repositories.

```bash
git config --global user.name "John Doe"
```

`git config --global user.email "<email>"` — Setzt deine globale E-Mail-Adresse für alle Repositories.

```bash
git config --global user.email "john@example.com"
```

`git config --list` — Listet alle Konfigurationseinstellungen auf.

`git config --global core.editor "<editor>"` — Legt den Standard-Editor für Commit-Messages fest.

```bash
git config --global core.editor "vim"
```

`git config --global init.defaultBranch <name>` — Legt den Standard-Branch-Namen für neue Repositories fest.

```bash
git config --global init.defaultBranch main
```

## Repository-Grundlagen

`git init` — Initialisiert ein neues Git-Repository im aktuellen Verzeichnis.

`git clone <url>` — Klont ein Remote-Repository auf deinen lokalen Rechner.

```bash
git clone https://github.com/user/repo.git
```

`git clone <url> <directory>` — Klont ein Repository in ein bestimmtes Verzeichnis.

```bash
git clone https://github.com/user/repo.git my-project
```

`git clone --depth <n> <url>` — Erstellt einen flachen Klon (Shallow Clone) mit begrenzter Versions-Historie.

```bash
git clone --depth 1 https://github.com/user/repo.git
```

`git status` — Zeigt den Status des Working Tree, inklusive gestagter, ungestagter und nicht versionierter Dateien.

## Staging & Commits

`git add <file>` — Stagt eine bestimmte Datei für den nächsten Commit.

```bash
git add index.html
```

`git add .` — Stagt alle Änderungen im aktuellen Verzeichnis und in den Unterverzeichnissen.

`git add -p` — Stagt einzelne Teile (Hunks) von Dateien interaktiv.

`git commit -m "<message>"` — Erstellt einen Commit mit einer Nachricht.

```bash
git commit -m "feat: add login page"
```

`git commit --amend` — Ändert den letzten Commit (Nachricht oder Inhalt).

`git commit --amend --no-edit` — Fügt gestagte Änderungen zum letzten Commit hinzu, ohne die Nachricht zu ändern.

`git reset HEAD <file>` — Nimmt eine Datei aus dem Staging und behält die Änderungen im Arbeitsverzeichnis.

```bash
git reset HEAD index.html
```

## Branching

`git branch` — Listet alle lokalen Branches auf. Der aktuelle Branch ist mit einem Sternchen markiert.

`git branch -a` — Listet alle Branches auf, inklusive der Remote-Tracking-Branches.

`git branch <name>` — Erstellt einen neuen Branch, ohne zu ihm zu wechseln.

```bash
git branch feature/login
```

`git checkout <branch>` — Wechselt zu einem bestehenden Branch.

```bash
git checkout main
```

`git checkout -b <branch>` — Erstellt einen neuen Branch und wechselt sofort zu ihm.

```bash
git checkout -b feature/login
```

`git switch <branch>` — Wechselt zu einem bestehenden Branch (moderne Alternative zu checkout).

```bash
git switch main
```

`git switch -c <branch>` — Erstellt einen neuen Branch und wechselt zu ihm.

```bash
git switch -c feature/login
```

`git branch -d <branch>` — Löscht einen Branch, der vollständig gemergt wurde.

```bash
git branch -d feature/login
```

`git branch -D <branch>` — Erzwingt das Löschen eines Branches, auch bei nicht gemergten Änderungen.

```bash
git branch -D feature/login
```

## Merging & Rebasing

`git merge <branch>` — Merged den angegebenen Branch in den aktuellen Branch.

```bash
git merge feature/login
```

`git merge --no-ff <branch>` — Merged mit einem Merge-Commit, selbst wenn ein Fast-Forward möglich wäre.

```bash
git merge --no-ff feature/login
```

`git merge --abort` — Bricht den laufenden Merge ab und stellt den Zustand davor wieder her.

`git rebase <branch>` — Rebaset den aktuellen Branch auf den angegebenen Branch.

```bash
git rebase main
```

`git rebase --abort` — Bricht einen laufenden Rebase ab und kehrt zum Ausgangszustand zurück.

`git cherry-pick <commit>` — Wendet einen bestimmten Commit aus einem anderen Branch an.

```bash
git cherry-pick a1b2c3d
```

## Remote-Repositories

`git remote -v` — Listet alle Remote-Repositories mit ihren URLs auf.

`git remote add <name> <url>` — Fügt ein neues Remote-Repository hinzu.

```bash
git remote add origin https://github.com/user/repo.git
```

`git fetch <remote>` — Lädt Objekte und Refs von einem Remote herunter, ohne zu mergen.

```bash
git fetch origin
```

`git pull` — Holt Änderungen vom Remote-Tracking-Branch und merged sie.

`git pull --rebase` — Holt Änderungen und rebaset lokale Commits auf die Remote-Änderungen.

`git push <remote> <branch>` — Schiebt lokale Commits in einen Remote-Branch.

```bash
git push origin main
```

`git push -u <remote> <branch>` — Schiebt und setzt den Upstream-Tracking-Branch.

```bash
git push -u origin feature/login
```

`git push --tags` — Schiebt alle lokalen Tags ins Remote-Repository.

## Stash

`git stash` — Sichert nicht committete Änderungen temporär und säubert das Arbeitsverzeichnis.

`git stash push -m "<message>"` — Stasht Änderungen mit einer aussagekräftigen Nachricht.

```bash
git stash push -m "WIP: login form"
```

`git stash list` — Listet alle Stash-Einträge auf.

`git stash pop` — Wendet den neuesten Stash an und entfernt ihn aus der Stash-Liste.

`git stash apply stash@{<n>}` — Wendet einen bestimmten Stash an, ohne ihn zu entfernen.

```bash
git stash apply stash@{0}
```

`git stash drop stash@{<n>}` — Entfernt einen bestimmten Stash-Eintrag.

```bash
git stash drop stash@{0}
```

`git stash clear` — Entfernt alle Stash-Einträge.

## Log & History

`git log` — Zeigt die Commit-Historie des aktuellen Branches.

`git log --oneline` — Zeigt die Commit-Historie im kompakten Einzeiler-Format.

`git log --graph --oneline --all` — Zeigt einen visuellen ASCII-Graphen aller Branches.

`git log -n <count>` — Zeigt nur die letzten N Commits.

```bash
git log -n 5
```

`git log --author="<name>"` — Filtert Commits nach Autor.

```bash
git log --author="John"
```

`git show <commit>` — Zeigt Details und Diff eines bestimmten Commits.

```bash
git show a1b2c3d
```

`git blame <file>` — Zeigt, wer jede Zeile einer Datei zuletzt geändert hat.

```bash
git blame index.html
```

## Diff & Vergleich

`git diff` — Zeigt ungestagte Änderungen im Arbeitsverzeichnis.

`git diff --staged` — Zeigt Änderungen, die für den nächsten Commit gestagt sind.

`git diff <branch1> <branch2>` — Vergleicht zwei Branches.

```bash
git diff main feature/login
```

`git diff <commit1> <commit2>` — Vergleicht zwei bestimmte Commits.

```bash
git diff a1b2c3d e4f5g6h
```

## Änderungen rückgängig machen

`git checkout -- <file>` — Verwirft Änderungen an einer Datei und stellt den Stand des letzten Commits wieder her.

```bash
git checkout -- index.html
```

`git restore <file>` — Verwirft Änderungen im Arbeitsverzeichnis (moderne Alternative).

```bash
git restore index.html
```

`git restore --staged <file>` — Nimmt eine Datei aus dem Staging und behält die Änderungen.

```bash
git restore --staged index.html
```

`git revert <commit>` — Erstellt einen neuen Commit, der den angegebenen Commit rückgängig macht.

```bash
git revert a1b2c3d
```

`git reset --soft HEAD~<n>` — Macht die letzten N Commits rückgängig und behält die Änderungen gestagt.

```bash
git reset --soft HEAD~1
```

`git reset --hard HEAD~<n>` — Macht die letzten N Commits rückgängig und verwirft alle Änderungen. Mit Vorsicht verwenden!

```bash
git reset --hard HEAD~1
```

`git clean -fd` — Entfernt nicht versionierte Dateien und Verzeichnisse aus dem Working Tree. Unwiderruflich – vorher mit `git clean -nfd` (Dry-Run) prüfen!

## Tags

`git tag` — Listet alle Tags im Repository auf.

`git tag <name>` — Erstellt einen leichtgewichtigen Tag am aktuellen Commit.

```bash
git tag v1.0.0
```

`git tag -a <name> -m "<message>"` — Erstellt einen annotierten Tag mit einer Nachricht.

```bash
git tag -a v1.0.0 -m "Release version 1.0.0"
```

`git tag -d <name>` — Löscht einen lokalen Tag.

```bash
git tag -d v1.0.0
```

`git push origin --delete <tagname>` — Löscht einen Remote-Tag.

```bash
git push origin --delete v1.0.0
```

<!-- PROSE:outro -->
## Fazit

Git wirkt anfangs überladen, doch der Alltag stützt sich auf eine überschaubare Handvoll Kommandos: add, commit, push, pull, branch und merge. Wer zusätzlich Rebase, Stash und das Rückgängigmachen mit reset und revert beherrscht, behält auch in größeren Projekten die Kontrolle über die Versions-Historie. Lege dir aussagekräftige Commit-Messages und eine klare Branching-Strategie zu – dann wird Git vom Werkzeug zum verlässlichen Sicherheitsnetz.

## Weiterführende Links

- [Pro Git – das offizielle Buch](https://git-scm.com/book/de/v2) – umfassendes Standardwerk, kostenlos online
- [Git – offizielle Dokumentation](https://git-scm.com/doc) – Referenz und Manpages (englisch)
- [Git – Wikipedia](https://de.wikipedia.org/wiki/Git) – Hintergrund und Geschichte
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [gh](https://www.jpkc.com/db/cheatsheets/version-control/gh/) – GitHub-Workflows direkt aus der Kommandozeile