Git — verteilte Versionskontrolle für deinen Quellcode

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.

Konfiguration

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

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

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

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.

git config --global core.editor "vim"

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

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.

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

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

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.

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.

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.

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.

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.

git branch feature/login

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

git checkout main

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

git checkout -b feature/login

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

git switch main

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

git switch -c feature/login

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

git branch -d feature/login

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

git branch -D feature/login

Merging & Rebasing

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

git merge feature/login

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

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.

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.

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.

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.

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.

git push origin main

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

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.

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.

git stash apply stash@{0}

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

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.

git log -n 5

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

git log --author="John"

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

git show a1b2c3d

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

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.

git diff main feature/login

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

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.

git checkout -- index.html

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

git restore index.html

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

git restore --staged index.html

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

git revert a1b2c3d

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

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!

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!

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 – umfassendes Standardwerk, kostenlos online
Git – offizielle Dokumentation – Referenz und Manpages (englisch)
Git – Wikipedia – Hintergrund und Geschichte