Der praxisorientierte Nix-Pfad: Installation, nix-shell, Flakes, Packaging, dockerTools-Images, NixOS — sowie Caches, Secrets, disko und Tests.

Ein professionelles Referenzhandbuch für Git-Befehle, das von der grundlegenden Versionsverwaltung bis hin zu fortgeschrittenem Repository-Management und Workflow-Strategien reicht.

Konfiguration

Konfigurieren Sie Ihre Identität, globale Einstellungen, Aliase und Signaturschlüssel.

Benutzeridentität & globale Konfiguration

# Set global user name and email
git config --global user.name "John Doe"
git config --global user.email "john.doe@example.com"

# Set default branch name for new repos
git config --global init.defaultBranch main

# Set default editor (VS Code, Vim, Nano)
git config --global core.editor "code --wait"
git config --global core.editor "vim"
git config --global core.editor "nano"

# Set default pull strategy (rebase instead of merge)
git config --global pull.rebase true

# Enable color output for all Git commands
git config --global color.ui auto

# List all configuration settings
git config --list
git config --global --list
git config --local --list

# Get a specific config value
git config --get user.name
git config --get core.editor

# Set a local config (overrides global for this repo only)
git config user.email "local-dev@project.com"

Aliase

Git-Aliase ermöglichen es Ihnen, benutzerdefinierte Kürzel für häufig verwendete Befehle zu erstellen.

# Single-command aliases
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.unstage 'reset HEAD --'

# Multi-command aliases (must use ! prefix)
git config --global alias.amend 'commit --amend --no-edit'
git config --global alias.last 'log -1 HEAD --stat'

# Advanced log aliases
git config --global alias.lg "log --oneline --graph --decorate --all"
git config --global alias.ls "log --pretty=format:'%C(yellow)%h%Cred%d\\ %Creset%s%Cblue\\ [%cn]' --abbrev-commit"
git config --global alias.file-log "log --follow --patch -- "

# Alias for a diff with word-level changes
git config --global alias.wdiff "diff --word-diff"

Struktur der .gitconfig-Datei

Die globale ~/.gitconfig-Datei speichert all Ihre Konfigurationen in Abschnitten im INI-Stil:

# View the raw gitconfig file
cat ~/.gitconfig

# Example structure:
# [user]
#     name = John Doe
#     email = john.doe@example.com
# [core]
#     editor = code --wait
#     autocrlf = input
# [pull]
#     rebase = true
# [push]
#     default = current
#     autoSetupRemote = true
# [alias]
#     st = status
#     co = checkout
# [color]
#     ui = auto
# [init]
#     defaultBranch = main

SSH-Key-Einrichtung

# Generate a new Ed25519 SSH key (recommended)
ssh-keygen -t ed25519 -C "user@example.com"

# Generate with a specific file name
ssh-keygen -t ed25519 -C "user@example.com" -f ~/.ssh/id_ed25519_github

# Generate RSA key (legacy, 4096-bit minimum)
ssh-keygen -t rsa -b 4096 -C "user@example.com"

# Start the SSH agent and add your key
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Test SSH connection to GitHub
ssh -T git@github.com

# Copy public key to clipboard (macOS)
pbcopy < ~/.ssh/id_ed25519.pub

# Copy public key to clipboard (Linux)
xclip -sel clip < ~/.ssh/id_ed25519.pub

GPG-Commit-Signierung

Die GPG-Signierung beweist, dass ein Commit tatsächlich von Ihnen erstellt wurde und nicht manipuliert wurde.

# List available GPG keys
gpg --list-secret-keys --keyid-format=long

# Configure GPG program
git config --global gpg.program gpg

# Enable GPG signing for all commits
git config --global commit.gpgsign true

# Set your signing key (use the key ID from gpg --list-secret-keys)
git config --global user.signingkey 3AA5C34371567BD2

# Create a signed tag
git tag -s v1.0.0 -m "Signed release v1.0.0"

# Verify a signed tag
git tag -v v1.0.0

# Verify a commit's signature
git log --show-signature

# Sign a single commit without global signing enabled
git commit -S -m "feat: signed commit"

# Skip signing for one commit when global signing is on
git commit --no-gpg-sign -m "quick fix"

Repository-Setup

Initialisieren oder klonen Sie Repositories mit spezifischen Einschränkungen.

Initialisierung & Klonen

# Initialize a new local repository
git init
git init my-project

# Clone a repository (standard HTTPS)
git clone https://github.com/user/repo.git

# Clone via SSH
git clone git@github.com:user/repo.git

# Clone into a specific directory name
git clone https://github.com/user/repo.git my-folder

# Clone a specific branch only
git clone --branch feature/login --single-branch https://github.com/user/repo.git

# Shallow clone (last N commits — faster, smaller download)
git clone --depth 1 https://github.com/user/repo.git
git clone --depth 5 https://github.com/user/repo.git

# Unshallow a shallow clone later (fetch full history)
git fetch --unshallow

# Clone including submodules
git clone --recurse-submodules https://github.com/user/repo.git

# Create a bare repository (no working directory — for server hosting)
git init --bare project.git

# Mirror a repository (all refs, including remote-tracking)
git clone --mirror https://github.com/user/repo.git

Die drei Zustände

Git verfolgt Dateien über drei primäre Phasen. Das Verständnis dieses Modells ist essenziell, um Git effektiv zu nutzen.

1. Working Directory: Die tatsächlichen Dateien auf Ihrer Festplatte. Änderungen hier sind „unstaged“.
2. Staging Area (Index): Ein Snapshot dessen, was in den nächsten Commit einfließen wird. Dateien werden hier „staged“.
3. Repository (.git): Der permanente, versionierte Datensatz, der als Commit-Objekte gespeichert wird.

Working Directory  ──(git add)──>  Staging Area  ──(git commit)──>  Repository
       ^                                   |                             |
       └──────────── (git checkout) ───────┘                             |
                                           └──── (git reset) ────────────┘

# Check the state of your working directory and staging area
git status

# Short format (one line per file)
git status -s

# See changes in the working directory that are NOT yet staged
git diff

# See changes that ARE staged and ready to be committed
git diff --cached
git diff --staged

# See a word-level diff for readability
git diff --word-diff

# Compare two branches
git diff main..feature/login

# Compare a specific file between two commits
git diff abc123 def456 -- path/to/file.js

Basis-Befehle

Dateien stagen

# Eine einzelne Datei stagen
git add file.txt
git add path/to/file.ts

# Mehrere Dateien stagen
git add file1.txt file2.txt file3.txt

# Alle Änderungen im aktuellen Verzeichnis stagen
git add .

# Alle Änderungen im gesamten Projekt stagen
git add -A

# Änderungen interaktiv stagen (Hunk für Hunk – sehr empfehlenswert)
git add -p

# Nur Löschungen stagen
git add -u

# Eine Datei stagen, die bereits committet wurde, aber modifiziert werden soll
git add --edit file.txt

Committing

# Gestagte Änderungen mit einer Nachricht committen
git commit -m "feat: add login functionality"

# Commit mit einer detaillierten mehrzeiligen Nachricht
git commit -m "feat: add user authentication

- Add login form component
- Implement JWT token validation
- Add redirect on successful auth"

# Alle getrackten Dateien stagen und in einem Schritt committen
git commit -am "fix: correct typo in README"

# Den letzten Commit ändern (Nachricht korrigieren oder vergessene Dateien hinzufügen)
git add forgotten-file.ts
git commit --amend --no-edit

# Mit einer neuen Nachricht ändern
git commit --amend -m "feat: add login functionality and fix validation"

# Im Namen eines anderen Autors committen
git commit --author="Jane Doe <jane@example.com>" -m "update config"

# Einen leeren Commit erstellen (nützlich zum Auslösen von CI-Pipelines)
git commit --allow-empty -m "chore: trigger CI rebuild"

# Pre-Commit-Hooks überspringen
git commit --no-verify -m "hotfix: urgent patch"

Inspecting Files & Commits

# Den Inhalt einer Datei bei einem bestimmten Commit anzeigen
git show HEAD:path/to/file.js
git show abc123:path/to/file.js

# Den letzten Commit anzeigen
git show

# Einen spezifischen Commit anzeigen (Hash, Nachricht, Autor, Diff)
git show <commit_hash>

# Nur den Diff eines spezifischen Commits anzeigen
git show <commit_hash> --stat

# Die durch den letzten Commit eingeführten Änderungen anzeigen (Patch)
git show HEAD -p

Removing & Moving Files

# Eine Datei aus Git und dem Working Directory entfernen
git rm file.txt

# Eine Datei nur aus Git entfernen (auf der Festplatte als untracked behalten)
git rm --cached file.txt

# Ein gesamtes Verzeichnis entfernen
git rm -r directory_name/

# Eine Datei verschieben oder umbenennen (stagt die Änderung automatisch)
git mv old_name.js new_name.js

# Eine Datei in ein anderes Verzeichnis verschieben
git mv file.js src/components/file.js

Viewing History

# Einfaches einzeiliges Log
git log --oneline

# Die letzten N Commits anzeigen
git log --oneline -5
git log -n 10

# Detailliertes Log mit vollständigem Patch (Differenzen)
git log -p

# Log mit einem visuellen Graph aller Branches anzeigen
git log --oneline --graph --all --decorate

# Statistiken der Änderungen pro Commit anzeigen
git log --stat

# Log mit einem benutzerdefinierten Format anzeigen
git log --pretty=format:"%h - %s (%cr) <%an>"

# Nur Merge-Commits anzeigen
git log --merges

# Commits eines spezifischen Autors anzeigen
git log --author="John Doe"
# Commits seit einem bestimmten Datum anzeigen
git log --since="2026-01-01"

# Commits anzeigen, die eine bestimmte Datei geändert haben
git log -- path/to/file.js

# Dateihistorie auch über Umbenennungen hinweg verfolgen
git log --follow -- path/to/file.js

# Den Commit-Graph für einen bestimmten Branch anzeigen
git log --graph --oneline feature/login

Branching

Creating & Switching Branches

# Alle lokalen Branches auflisten
git branch

# Alle lokalen UND Remote-Branches auflisten
git branch -a

# Branches mit dem jeweils letzten Commit auflisten
git branch -v

# Einen neuen Branch erstellen (auf dem aktuellen Branch bleiben)
git branch feature/new-ui

# Einen neuen Branch erstellen und sofort zu diesem wechseln
git checkout -b feature/new-ui

# Moderne Alternative: git switch (Git 2.23+)
git switch -c feature/new-ui

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

# Zum vorherigen Branch zurückkehren
git switch -

# Einen Branch von einem bestimmten Commit aus erstellen
git branch feature/fix-from-commit abc1234

# Einen Branch von einem Remote-Tracking-Branch aus erstellen
git checkout -b feature/remote origin/feature/remote
git switch -c feature/remote origin/feature/remote

Comparing Branches

# Commits auf feature anzeigen, die NICHT auf main sind
git log main..feature/login --oneline

# Commits auf main anzeigen, die NICHT auf feature sind
git log feature/login..main --oneline

# Commits anzeigen, die in einem der beiden Branches, aber nicht in beiden sind (Divergenz)
git log main...feature/login --oneline --left-right

# Diff der Working Trees von zwei Branches
git diff main..feature/login

# Dateien auflisten, die sich zwischen zwei Branches unterscheiden
git diff --name-only main..feature/login

Renaming & Deleting Branches

# Den aktuellen Branch umbenennen
git branch -m new-name

# Einen spezifischen Branch umbenennen
git branch -m old-name new-name

# Einen lokalen Branch löschen (nur wenn vollständig gemerged)
git branch -d feature/old-ui

# Einen lokalen Branch erzwingen löschen (auch wenn nicht gemerged)
git branch -D feature/experimental

# Einen Remote-Branch löschen
git push origin --delete feature/old-ui

# Remote-Tracking-Branches entfernen, die auf dem Remote nicht mehr existieren
git fetch --prune
git remote prune origin

Tracking Remote Branches

# Den Upstream-Branch für den aktuellen Branch festlegen
git branch --set-upstream-to=origin/main
git branch -u origin/main

# Einen neuen Branch pushen und das Upstream-Tracking in einem Schritt einrichten
git push -u origin feature/new-ui

# Anzeigen, welchen Remote-Branch der aktuelle Branch trackt
git branch -vv

switch vs checkout

Git 2.23+ introduced switch and restore as safer alternatives to the multi-purpose checkout:

# switch — ändert nur Branches (keine Nebenwirkungen bei der Dateiwiederherstellung)
git switch main
git switch -c new-branch

# restore — stellt nur Dateien wieder her (keine Nebenwirkungen beim Branch-Wechsel)
git restore file.txt           # Aus dem Staging Area wiederherstellen
git restore --source HEAD~2 file.txt  # Von einem bestimmten Commit wiederherstellen
git restore --staged file.txt   # Eine Datei aus dem Stage-Bereich entfernen

# checkout — funktioniert immer noch, übernimmt aber beide Aufgaben
git checkout main              # Branch wechseln
git checkout -- file.txt       # Datei wiederherstellen (verwirrende Syntax)

Branching Strategies

Merging & Rebasing

Merging

# Einen Branch in den aktuellen Branch mergen
git merge feature/login

# Fast-forward merge (nur möglich, wenn keine divergenten Commits vorliegen)
git merge --ff-only feature/login

# Einen Merge-Commit erzwingen, auch wenn Fast-forward möglich wäre
# (bewahrt die Branch-Historie visuell)
git merge --no-ff feature/login

# Squash merge: Alle Commits eines Branchs zu einem einzigen kombinieren
# (erstellt KEINEN Merge-Commit; Änderungen werden in den Stage-Bereich verschoben)
git merge --squash feature/new-ui
git commit -m "feat: add new UI components"

# Einen Merge mit Konflikten abbrechen
git merge --abort

# Merge mit einer benutzerdefinierten Merge-Nachricht
git merge feature/login -m "Merge feature/login into main"

Interactive Rebasing

Interactive rebase lets you rewrite, reorder, combine, or remove commits in your branch history.

# Interaktiven Rebase für die letzten 5 Commits starten
git rebase -i HEAD~5

# Interaktiven Rebase bis zu einem bestimmten Commit starten
git rebase -i abc1234

# Der interaktive Editor zeigt diese Aktionen:
# pick   — Commit wie er ist behalten
# reword — Commit behalten, aber Nachricht bearbeiten
# squash — Mit dem vorherigen Commit kombinieren (beide Nachrichten behalten)
# fixup  — Mit dem vorherigen Commit kombinieren (diese Nachricht verwerfen)
# drop   — Commit vollständig entfernen
# edit   — Pause einlegen, um den Inhalt des Commits zu ändern

Rebasing Examples

# Den aktuellen Branch auf main rebasen (Commits auf main aufsetzen)
git rebase main

# Rebase und automatisches Squashen von Fixup-Commits (erfordert Commits mit fixup!-Präfix)
git rebase -i --autosquash HEAD~10

# Nach der Lösung eines Rebase-Konflikts fortfahren
git add <resolved-file>
git rebase --continue

# Einen Commit überspringen, der Probleme verursacht
git rebase --skip

# Den Rebase vollständig abbrechen (Rückkehr zum ursprünglichen Zustand)
git rebase --abort

Merge vs Rebase — When to Use Which

# Gut: Den lokalen Feature-Branch auf den neuesten Stand von main rebasen
git checkout feature/login
git rebase main

# Schlecht: main oder einen gemeinsam genutzten Branch rebasen (schreibt gemeinsame Historie um)
# NICHT TUN: git checkout main && git rebase feature/login

Conflict Resolution Workflow

# Wenn ein Merge oder Rebase auf Konflikte stößt:

# 1. Prüfen, welche Dateien Konflikte haben
git status

# 2. Die konfliktbehaftete Datei öffnen und nach Konfliktmarkern suchen:
# <<<<<<< HEAD
# (eigene Änderungen)
# =======
# (eingehende Änderungen)
# >>>>>>> feature/login

# 3. Die Datei bearbeiten, um Konflikte zu lösen und die Marker zu entfernen

# 4. Die gelösten Datei(en) in den Stage-Bereich verschieben
git add resolved-file.js
# 5. Merge oder Rebase fortsetzen
git merge --continue    # für merge
git rebase --continue   # für rebase

# 6. Oder abbrechen, wenn Sie aufgeben möchten
git merge --abort       # für merge
git rebase --abort      # für rebase

# Ein visuelles Merge-Tool zur Konfliktlösung verwenden
git mergetool

# Ein Merge-Tool konfigurieren
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

Stashing

Temporarily save uncommitted changes to clean your working directory without committing.

# Alle getrackten Änderungen zwischenspeichern (Standard)
git stash

# Stash mit einer beschreibenden Nachricht speichern
git stash save "work in progress: header redesign"

# Stash inklusive nicht getrackter Dateien (-u / --include-untracked)
git stash save "include new files" -u

# Alles zwischenspeichern (getrackte, nicht getrackte UND ignorierte Dateien)
git stash save "everything" --all

# Alle Stashes mit ihrem Index auflisten
git stash list

# Den neuesten Stash anwenden (bleibt in der Liste erhalten)
git stash apply

# Einen spezifischen Stash über den Index anwenden
git stash apply stash@{2}

# Stash anwenden und aus der Liste entfernen (pop)
git stash pop

# Stash auf einen anderen Branch anwenden als den, auf dem er erstellt wurde
git stash branch new-feature-branch stash@{1}

# Den Diff des neuesten Stashs anzeigen
git stash show

# Den vollständigen Diff (Patch) eines spezifischen Stashs anzeigen
git stash show -p stash@{0}

# Einen spezifischen Stash löschen (drop)
git stash drop stash@{2}

# Den neuesten Stash löschen
git stash drop

# ALLE Stashes auf einmal leeren
git stash clear

Remote Operations

Fetching & Pulling

# Alle Remotes und Branches abrufen (führt KEINEN Merge durch)
git fetch --all

# Von einem spezifischen Remote abrufen
git fetch origin

# Abrufen und gelöschte Remote-Branches bereinigen (prune)
git fetch --prune

# Pull (fetch + merge) vom getrackten Upstream-Branch
git pull

# Pull von einem spezifischen Remote und Branch
git pull origin main

# Pull mit Rebase statt Merge (sauberere Historie)
git pull --rebase origin main

# Nur Fast-Forward-Merges zulassen (verweigert Pull, wenn Rebase/Merge nötig ist)
git pull --ff-only

Pushing

# Aktuellen Branch an den getrackten Remote pushen
git push

# Einen spezifischen Branch an einen Remote pushen
git push origin feature/login

# Neuen Branch pushen und Upstream-Tracking setzen (-u / --set-upstream)
git push -u origin feature/login

# Alle lokalen Branches an einen Remote pushen
git push --all origin

# Einen Remote-Branch löschen
git push origin --delete feature/old-ui

# Force Push (überschreibt die Remote-Historie — GEFÄHRLICH)
git push --force origin main

# Force-with-lease: sicherere Alternative (schlägt fehl, wenn jemand anderes gepusht hat)
git push --force-with-lease origin main

# Tags zusammen mit Commits pushen
git push --follow-tags

# Dry Run: sehen, was gepusht würde, ohne es tatsächlich zu tun
git push --dry-run

Remote Management

# Alle Remotes mit ihren URLs auflisten
git remote -v

# Einen neuen Remote hinzufügen (üblich: upstream für Forks hinzufügen)
git remote add upstream https://github.com/original/repo.git

# Details eines Remotes anzeigen (Branches, HEAD, Push/Pull-URLs)
git remote show origin

# Einen Remote umbenennen
git remote rename origin old-origin

# Einen Remote vollständig entfernen
git remote remove origin

# Die URL eines Remotes ändern
git remote set-url origin git@github.com:user/new-repo.git

# Von allen Remotes gleichzeitig abrufen (Fetch)
git remote update

Fork Syncing Workflow

# Nach dem Forken eines Repos den Fork mit dem Upstream synchronisieren:
git remote add upstream https://github.com/original/repo.git
git fetch upstream
git checkout main
git merge upstream/main
git push origin main

Tags

Lightweight vs Annotated Tags

Creating & Managing Tags

# Lightweight Tag (nur ein Zeiger)
git tag v1.0.0

# Annotierter Tag (enthält Nachricht, Tagger, Datum)
git tag -a v1.1.0 -m "Release version 1.1.0 with new auth module"

# Einen spezifischen Commit taggen
git tag -a v1.0.0 abc1234 -m "Backport fix for critical bug"

# Einen Tag mit GPG signieren
git tag -s v2.0.0 -m "Signed release v2.0.0"

# Alle Tags auflisten
git tag

# Tags auflisten, die einem Glob-Pattern entsprechen
git tag -l "v1.*"
git tag -l "v2.*"

# Tag-Details anzeigen (annotierte Tags zeigen Nachricht + Commit)
git show v1.1.0

# Einen signierten Tag verifizieren
git tag -v v2.0.0

# Einen lokalen Tag löschen
git tag -d v1.1.0

# Einen Remote-Tag löschen
git push origin --delete v1.1.0
# Alternative Syntax
git push origin :refs/tags/v1.1.0

Pushing Tags

# Einen einzelnen Tag zum Remote pushen
git push origin v1.0.0

# Alle lokalen Tags zum Remote pushen
git push origin --tags

# Tags automatisch beim Pushen von Commits mitsenden
git push --follow-tags

Cherry-pick

Apply the changes from specific commits to your current branch.

# Einen einzelnen Commit cherry-picken
git cherry-pick abc1234

# Mehrere spezifische Commits cherry-picken
git cherry-pick abc1234 def5678

# Einen Bereich von Commits cherry-picken (exklusive des ersten)
git cherry-pick abc1234..def5678

# Cherry-pick ohne Commit (Änderungen bleiben im Staging Area)
git cherry-pick --no-commit abc1234

# Cherry-pick und Commit-Nachricht bearbeiten
git cherry-pick -e abc1234

# Nach Behebung von Cherry-pick-Konflikten fortfahren
git add <resolved-file>
git cherry-pick --continue
# Den Cherry-Pick-Prozess vollständig abbrechen
git cherry-pick --abort

# Cherry-Pick beenden, aber teilweise angewendete Änderungen beibehalten
git cherry-pick --quit

Reset & Revert

Understanding the Three Reset Modes

Reset Examples

# Soft Reset: Letzten Commit rückgängig machen, Änderungen im Stage behalten
# Nützlich zum Kombinieren oder Ergänzen von Commits
git reset --soft HEAD~1

# Mixed Reset (Standard): Letzten Commit rückgängig machen, Änderungen aus dem Stage entfernen
# Änderungen bleiben im Working Directory erhalten
git reset --mixed HEAD~1
git reset HEAD~1

# Hard Reset: Letzten Commit und alle Änderungen vollständig verwerfen
# WARNUNG: Nicht rückgängig zu machen, außer über den reflog
git reset --hard HEAD~1

# Reset auf einen spezifischen Commit
git reset --hard abc1234

# Eine einzelne Datei aus dem Stage entfernen (vom Stage zurück ins Working Directory)
git reset HEAD file.txt
# Moderne Alternative (Git 2.23+)
git restore --staged file.txt

# Den Index zurücksetzen, aber alle Änderungen im Working Directory behalten
git reset

Revert Examples

Revert creates a new commit that undoes the changes of a previous commit. Safe for shared branches.

# Einen spezifischen Commit rückgängig machen (erstellt einen neuen Undo-Commit)
git revert abc1234

# Den aktuellsten Commit rückgängig machen
git revert HEAD

# Mehrere Commits auf einmal rückgängig machen
git revert abc1234 def5678

# Einen Bereich von Commits rückgängig machen (erstellt einzelne Revert-Commits)
git revert HEAD~3..HEAD

# Einen Merge-Commit rückgängig machen (der Parent-Commit, zu dem zurückgekehrt werden soll, muss angegeben werden)
git revert -m 1 <merge_commit_hash>

# Revert ohne Auto-Commit (den Revert-Commit manuell bearbeiten)
git revert --no-commit abc1234

Reflog

The reflog (reference log) records every move of HEAD and branch tips. It is the ultimate safety net for recovering "lost" commits — even after resets, amends, or failed rebases.

# Reflog für den aktuellen Branch anzeigen
git reflog

# Reflog für einen spezifischen Branch anzeigen
git reflog show main

# Eine bestimmte Anzahl an Einträgen anzeigen
git reflog -10

# Reflog mit einem benutzerdefinierten Format anzeigen
git reflog --pretty=format:'%h %gd %gs %cr'

# Szenario: Einen "verlorenen" Commit nach einem Hard Reset wiederherstellen

# 1. Sie haben versehentlich ausgeführt: git reset --hard HEAD~3
# 2. Reflog prüfen, um den verlorenen Commit zu finden
git reflog
# Ausgabe:
# abc1234 HEAD@{0}: reset: moving to HEAD~3
# def5678 HEAD@{1}: commit: add important feature
# ...

# 3. Reset auf den Hash des verlorenen Commits
git reset --hard def5678

# Szenario: Wiederherstellung nach einem fehlerhaften Rebase
git reflog
# Den Zustand vor dem Rebase finden und darauf zurücksetzen
git reset --hard HEAD@{5}

# Reflog-Einträge löschen, die älter als 30 Tage sind
git reflog expire --expire=30.days.ago --all

# Alle nicht mehr erreichbaren Reflog-Einträge sofort löschen
git reflog expire --expire=now --all

# Nicht erreichbare Objekte nach dem Ablauf des Reflogs bereinigen
git gc --prune=now

Worktrees

Worktrees let you check out multiple branches into separate directories simultaneously, enabling parallel work without git stash or git checkout.

# Worktree für einen bestehenden Branch hinzufügen
git worktree add ../hotfix-dir hotfix/critical-bug

# Worktree hinzufügen und gleichzeitig einen neuen Branch erstellen
git worktree add -b feature/sidebar ../sidebar-dir

# Worktree an einem spezifischen Commit hinzufügen (detached HEAD)
git worktree add ../temp-dir abc1234

# Alle aktiven Worktrees auflisten
git worktree list

# Worktree entfernen (muss "clean" sein — keine uncommitteten Änderungen)
git worktree remove ../hotfix-dir

# Worktree erzwingen zu entfernen (uncommittete Änderungen werden verworfen)
git worktree remove --force ../hotfix-dir

# Veraltete Worktree-Administrationsdateien bereinigen
git worktree prune

# Worktree sperren (verhindert Pruning oder Entfernung)
git worktree lock ../hotfix-dir

# Worktree entsperren
git worktree unlock ../hotfix-dir

Bisect

Use binary search to find the exact commit that introduced a bug.

# Eine Bisect-Session starten
git bisect start

# Den aktuellen (bekanntlich fehlerhaften) Commit markieren
git bisect bad

# Einen bekanntlich funktionierenden Commit markieren
git bisect good v1.0.0

# Git checkt einen Commit aus, der genau in der Mitte zwischen "good" und "bad" liegt.
# Testen und anschließend als gut oder schlecht markieren:
git bisect good    # Bug ist hier nicht vorhanden
git bisect bad     # Bug ist hier vorhanden

# Automatisiertes Bisect: Ein Skript ausführen, das 0 für "good" und einen Nicht-Null-Wert für "bad" zurückgibt
git bisect start HEAD v1.0.0
git bisect run npm test

# Den Fortschritt des Bisects in gitk visualisieren
git bisect visualize

# Das Bisect-Log anzeigen
git bisect log

# Eine Bisect-Session aus einer Log-Datei wiederholen
git bisect replay bisect-log.txt

# Die Bisect-Session beenden und zum ursprünglichen Branch zurückkehren
git bisect reset

Blame & History Search

git blame

# Anzeigen, wer zuletzt jede einzelne Zeile einer Datei geändert hat
git blame src/components/Login.tsx

# Blame mit Commit-Hash und Autor anzeigen
git blame -e src/components/Login.tsx

# Blame auf spezifische Zeilennummern beschränken
git blame -L 10,30 src/components/Login.tsx

# Whitespace-Änderungen im Blame ignorieren
git blame -w src/components/Login.tsx

# Den ursprünglichen Commit vor einem Verschieben/Umbenennen anzeigen
git blame -M src/components/Login.tsx

# Den ursprünglichen Commit über Dateikopien hinweg anzeigen
git blame -C -C src/components/Login.tsx

History Search (Pickaxe)

# Pickaxe-Suche: Commits finden, die einen spezifischen String hinzugefügt oder entfernt haben
git log -S "function handleLogin"

# Pickaxe mit Regex-Unterstützung
git log -S "handleLogin" --pickaxe-regex

# Grep-Suche: Commits finden, deren Diff mit einem Regex übereinstimmt
git log -G "TODO|FIXME|HACK"

# Finden, welcher Commit einen spezifischen String hinzugefügt hat
git log -S "API_KEY" --oneline

# Commits finden, die einen spezifischen Dateipfad geändert haben
git log --all -- path/to/file.js

# Den vollständigen Diff für Pickaxe-Treffer anzeigen
git log -p -S "search_term"

shortlog

# Commits nach Autor zusammenfassen
git shortlog

# Zusammenfassung inklusive E-Mail-Adressen
git shortlog -e

# Anzahl der Commits pro Autor anzeigen (nach Anzahl sortiert)
git shortlog -sn

# Zusammenfassung eines spezifischen Branches
git shortlog feature/login

Submodules

Manage external repositories embedded within your project.

# Submodule an einem spezifischen Pfad hinzufügen
git submodule add https://github.com/user/library.git vendor/library

# Submodule an einem spezifischen Branch/Tag hinzufügen
git submodule add -b v2.0 https://github.com/user/library.git vendor/library

# In .gitmodules registrierte Submodules initialisieren
git submodule init

# Repo klonen und alle Submodules in einem Schritt initialisieren
git clone --recurse-submodules https://github.com/user/repo.git

# Submodules auf die im Parent-Repo registrierten Commits aktualisieren
git submodule update

# Initialisieren UND Aktualisieren in einem Schritt
git submodule update --init

# Alle verschachtelten Submodules rekursiv initialisieren und aktualisieren
git submodule update --init --recursive

# Alle Submodules auf ihre neuesten Remote-Versionen aktualisieren
git submodule update --remote

# Ein spezifisches Submodule auf die neueste Remote-Version aktualisieren
git submodule update --remote vendor/library

# Einen Befehl in jedem Submodule ausführen
git submodule foreach 'git pull origin main'
git submodule foreach 'echo $path'
git submodule foreach 'git log --oneline -1'

# Status aller Submodules anzeigen
git submodule status

# Ein Submodule vollständig entfernen
git submodule deinit vendor/library
git rm vendor/library
rm -rf .git/modules/vendor/library

Hooks

Hooks are scripts that Git runs automatically before or after events like commit, push, and receive.

Hook Locations

# Verfügbare Hooks im aktuellen Repo auflisten
ls .git/hooks/

# Ein benutzerdefiniertes Hooks-Verzeichnis festlegen (via Version Control mit dem Team geteilt)
git config --global core.hooksPath .githooks

# Alle Hooks für einen einzelnen Befehl überspringen
git commit --no-verify -m "emergency fix"

pre-commit Hook Example

Runs before the commit is created. Common uses: linting, formatting, running tests.

# .githooks/pre-commit
#!/bin/bash
# Linter ausführen
npm run lint
if [ $? -ne 0 ]; then
  echo "Linting failed. Commit aborted."
  exit 1
fi

# Tests ausführen
npm test
if [ $? -ne 0 ]; then
  echo "Tests failed. Commit aborted."
  exit 1
fi

# Auf große Dateien prüfen (>5MB)
MAX_FILE_SIZE=5242880
find . -type f -not -path './.git/*' -size +${MAX_FILE_SIZE}c | while read file; do
  echo "File too large for commit: $file"
  exit 1
done

echo "Pre-commit checks passed."

commit-msg Hook Example

Validates the commit message format.

# .githooks/commit-msg
#!/bin/bash
# Conventional Commits Format erzwingen: type(scope): message
MSG_FILE=$1
MSG=$(cat "$MSG_FILE")

if ! echo "$MSG" | grep -qE "^(feat|fix|docs|style|refactor|perf|test|chore|build|ci)(\(.+\))?: .+"; then
  echo "Invalid commit message format."
  echo "Expected: type(scope): description"
  echo "Types: feat, fix, docs, style, refactor, perf, test, chore, build, ci"
  echo "Example: feat(auth): add login validation"
  exit 1
fi
### Beispiel für einen pre-push Hook

Wird vor dem Push an ein Remote-Repository ausgeführt. Häufige Anwendungsfälle: Ausführen der vollständigen Test-Suite.

```bash
# .githooks/pre-push
#!/bin/bash
echo "Running full test suite before push..."
npm run test:all
if [ $? -ne 0 ]; then
  echo "Tests failed. Push aborted."
  exit 1
fi
echo "All tests passed. Pushing."

Verwendung von Husky (beliebter Hook-Manager)

# Install Husky
npm install husky --save-dev

# Initialize Husky (creates .husky/ directory)
npx husky init

# Add a pre-commit hook
echo "npm test" > .husky/pre-commit

# Add a commit-msg hook
echo 'npx --no -- commitlint --edit "$1"' > .husky/commit-msg

# Add a pre-push hook
echo "npm run test:ci" > .husky/pre-push

Bereinigung (Cleaning)

Entfernt nicht verfolgte (untracked) Dateien und Verzeichnisse aus dem Arbeitsverzeichnis.

# Dry run: preview what would be deleted (SAFE — no files are removed)
git clean -n

# Dry run with directories included
git clean -nd

# Remove untracked files
git clean -f

# Remove untracked files AND directories
git clean -fd

# Remove untracked files AND ignored files (respecting .gitignore)
git clean -fX

# Remove everything: untracked files, directories, AND ignored files
git clean -fdx

# Remove files only in a specific directory
git clean -fd src/temp/

# Interactive cleaning (choose which files to delete)
git clean -i

# Discard all local changes (staged + unstaged) and untracked files
git reset --hard && git clean -fd

Änderungen verwerfen

# Discard changes in a single file (restore to last committed version)
git checkout -- file.txt
# Modern alternative
git restore file.txt

# Discard ALL changes in the working directory
git checkout -- .
git restore .

# Unstage a file (keep changes, but remove from staging)
git reset HEAD file.txt
git restore --staged file.txt

# Discard everything and start fresh from last commit
git reset --hard HEAD
git clean -fd

.gitignore

Geben Sie Git an, welche Dateien und Verzeichnisse ignoriert werden sollen.

# Check if a file is ignored and which rule ignores it
git check-ignore -v node_modules/

# Create a global gitignore (applies to all repos)
git config --global core.excludesfile ~/.gitignore_global

# Gängige .gitignore-Muster
# Abhängigkeiten
node_modules/
vendor/

# Build-Output
dist/
build/
*.min.js
*.min.css

# Umgebungsvariablen-Dateien
.env
.env.local
.env.*.local

# IDE- und Editor-Dateien
.vscode/

.idea/ *.swp *.swo

OS-Dateien

.DS_Store Thumbs.db

Logs

*.log logs/

Große Dateien

*.zip *.tar.gz *.psd

## Troubleshooting

### Detached HEAD

You get a detached HEAD when you check out a specific commit instead of a branch. Any commits you make will be "orphaned" when you switch away.

```bash
# Aktuellen Status prüfen
git status
# "HEAD detached at abc1234"

# Option 1: Einen Branch erstellen, um die Arbeit zu speichern
git checkout -b fix-from-detached

# Option 2: Zu einem bestehenden Branch zurückkehren
git checkout main

# Option 3: Einen Branch auf den detached Commit verschieben
git branch -f main HEAD
git checkout main

Merge Conflicts

# Prüfen, welche Dateien Konflikte aufweisen
git status
git diff --name-only --diff-filter=U

# Konfliktdateien öffnen und Marker auflösen:
# <<<<<<< HEAD
# (eigene Änderungen)
# =======
# (eingehende Änderungen)
# >>>>>>> feature/login

# Ein visuelles Merge-Tool verwenden
git mergetool

# Nach der Auflösung aller Konflikte
git add .
git commit -m "merge: resolve conflicts in feature/login"

# Den Merge vollständig abbrechen
git merge --abort

Force Push Recovery

If someone force-pushed and you lost commits, you can recover them.

# Reflog-Eintrag vor dem Force-Push finden
git reflog

# Auf den Commit vor dem Force-Push zurücksetzen
git reset --hard HEAD@{2}

# Erneut pushen (Vorsicht: dies kann zu weiteren Konflikten führen)
git push --force-with-lease

Corrupted Repository

# Integrität des Repositorys prüfen
git fsck

# Prüfung mit vollständiger Ausgabe
git fsck --full

# Nach "dangling objects" suchen
git fsck --dangling

# Dangling Commits wiederherstellen
git fsck --lost-found

# Korrupte Objekte entfernen und neu packen
git gc --prune=now

# Wenn das .git-Verzeichnis wirklich beschädigt ist, letzter Ausweg:
# Repository neu klonen
git clone https://github.com/user/repo.git repo-recovered
# Nicht committete Arbeit aus dem beschädigten Klon kopieren

Large Files & Git LFS

# Große Dateien im aktuellen Tree finden
find . -type f -size +1M | head -20

# Die größten Dateien in der Git-Historie finden
git rev-list --objects --all | \
  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | \
  awk '/^blob/ {print substr($0,6)}' | \
  sort -n -k2 | tail -10

# Git LFS installieren
git lfs install

# Spezifische Dateitypen mit LFS tracken
git lfs track "*.psd"
git lfs track "*.zip"
git lfs track "*.mp4"
git lfs track "datasets/*.csv"

# Dateien über einer bestimmten Größe tracken
git lfs track "*.bin" --attr

# Angezeigte Patterns prüfen
cat .gitattributes

# LFS-Dateien zum Remote-Repository pushen
git push origin main --all

# LFS-Dateien pullen
git lfs pull

# Bestehende große Dateien zu LFS migrieren
git lfs migrate import --include="*.psd,*.zip" --everything

Shallow Clone Issues

# Sie haben einen Shallow Clone, benötigen aber die vollständige Historie

# Unshallow: Die komplette Historie abrufen
git fetch --unshallow

# Falls unshallow fehlschlägt (Server unterstützt es nicht), erneut klonen
git clone https://github.com/user/repo.git repo-full

# Shallow Clones schränken die Möglichkeiten ein:
# git log --full-history      # funktioniert nicht
# git blame                   # eingeschränkt
# git rebase -i HEAD~10       # kann fehlschlagen, wenn depth < 10

# Zusätzliche Tiefe abrufen
git fetch --depth=50

Committed to Wrong Branch

# Den letzten Commit rückgängig machen, aber Änderungen im Stage behalten
git reset --soft HEAD~1

# Zum korrekten Branch wechseln
git checkout correct-branch

# Die Änderungen dort committen
git commit -m "feat: add the feature"

# Alternativ: Den Commit auf den korrekten Branch cherry-picken
git checkout correct-branch
git cherry-pick wrong-branch
git checkout wrong-branch
git reset --hard HEAD~1

Undo an Accidental Commit (Sensitive Data)

# Falls Sie Secrets, Passwörter oder Token committet haben:

# 1. Datei aus dem Git-Tracking entfernen
git rm --cached config/secrets.json

# 2. Zur .gitignore hinzufügen
echo "config/secrets.json" >> .gitignore

# 3. Die Entfernung committen
git commit -m "chore: remove secrets from tracking"

# 4. Falls bereits gepusht, MÜSSEN die Zugangsdaten sofort rotiert werden
# 5. Anschließend aus der Historie entfernen mit git-filter-repo oder BFG:
pip install git-filter-repo
git filter-repo --invert-paths --path config/secrets.json

Tips & Aliases

Essential Aliases

# Navigation
git config --global alias.st status
git config --global alias.br branch
git config --global alias.co checkout
git config --global alias.sw switch

# Committing
git config --global alias.ci commit
git config --global alias.amend 'commit --amend --no-edit'
git config --global alias.unstage 'reset HEAD --'

# Diffing
git config --global alias.df diff
git config --global alias.wdiff 'diff --word-diff'

# Logging
git config --global alias.lg "log --oneline --graph --decorate --all"
git config --global alias.last 'log -1 HEAD --stat'
git config --global alias.aliases 'config --get-regexp alias'

# Stash
git config --global alias.sl 'stash list'
git config --global alias.sp 'stash pop'

Productivity Tips

# Automatische Korrektur von falsch geschriebenen Befehlen
git config --global help.autocorrect 1

# Upstream automatisch setzen beim Pushen eines neuen Branchs
git config --global push.autoSetupRemote true

# git status -s für eine kompakte Ausgabe verwenden
git status -s
# M  modified.txt       (staged modification)
# M  unstaged.txt       (unstaged modification)
# A  newfile.txt        (added)
# D  deleted.txt        (deleted)
# ?? untracked.txt      (untracked)

# git add -p für präzises Staging verwenden (jeden Hunk einzeln prüfen)
git add -p

# Diff der gestagten Änderungen schnell anzeigen
git diff --cached

# Anzeigen, auf welchem Branch man sich befindet und was geändert wurde (Einzeiler)
git status -sb

# Herausfinden, welcher Branch einen bestimmten Commit enthält
git branch --contains abc1234

# Commit-Nachrichten durchsuchen
git log --all --grep="fix crash" --oneline

# Commits anzeigen, die eine bestimmte Zeile einer Datei geändert haben
git log -L 42,42:src/app.ts

Conventional Commits Quick Reference

Nächste Schritte

• Docker CLI Cheat Sheet — Container-Befehle für die moderne Entwicklung
• Kubernetes kubectl Cheat Sheet — Essenzielle kubectl-Befehle für die Orchestrierung
• Helm CLI Cheat Sheet — Referenz für den Kubernetes Package Manager
• Bash CLI Tools Cheat Sheet — Unix-Kommandozeilen-Utilities

Ressourcen & Verwandte Plattformen

• tobias-weiss.org - Weitere Cheat Sheets, Artikel und Shop-Produkte
• graphwiz.ai - KI, Knowledge Graphs und agentische Entwicklung
• courses.graphwiz.ai - Interaktive Übungsprüfungen und Lernleitfäden
• ki-kompetenz-training.org - EU AI Act konformes KI-Kompetenztraining

Verwandte Cheat Sheets

• CI/CD Cheat Sheet - Delivery mit Git automatisieren
• Bash CLI Tools Cheat Sheet - Unix-Kommandozeilen-Utilities