Wichtige Git-Befehle Spickzettel für Entwickler

31. März 2026 · 12 Min. Lesezeit

Git ist das Rückgrat der modernen Softwareentwicklung. Egal, ob Sie alleine arbeiten oder mit einem Team von Hunderten zusammenarbeiten, die Beherrschung von Git-Befehlen ist für eine effiziente Versionskontrolle und Code-Verwaltung unerlässlich.

Dieser umfassende Spickzettel deckt alles ab, von grundlegenden Operationen bis hin zu fortgeschrittenen Techniken. Setzen Sie ein Lesezeichen auf diese Seite und schauen Sie immer wieder nach, wenn Sie eine schnelle Referenz für Git-Befehle benötigen.

Einrichtung & Konfiguration

Bevor Sie Git verwenden, müssen Sie Ihre Identität und Einstellungen konfigurieren. Diese Einstellungen bestimmen, wie sich Git verhält und wie Ihre Commits zugeordnet werden.

Erstkonfiguration

Führen Sie diese Befehle einmal pro Rechner aus, um Ihre Git-Umgebung einzurichten:

# Setzen Sie Ihren Namen und Ihre E-Mail (erforderlich)
git config --global user.name "Ihr Name"
git config --global user.email "[email protected]"

# Setzen Sie den Standard-Branch-Namen auf 'main'
git config --global init.defaultBranch main

# Aktivieren Sie farbige Ausgabe für bessere Lesbarkeit
git config --global color.ui auto

# Setzen Sie Ihren bevorzugten Texteditor
git config --global core.editor "code --wait"  # VS Code
git config --global core.editor "vim"          # Vim
git config --global core.editor "nano"         # Nano

# Alle Konfigurationseinstellungen anzeigen
git config --list

# Spezifische Konfiguration anzeigen
git config user.name
git config user.email

Das --global-Flag wendet Einstellungen auf alle Repositories auf Ihrem Rechner an. Um Einstellungen für ein einzelnes Repository zu konfigurieren, navigieren Sie zu diesem Repo und lassen Sie das --global-Flag weg.

Konfigurationsebenen

Git hat drei Konfigurationsebenen, wobei jede die vorherige überschreibt:

Nützliche Konfigurationsoptionen

# Credential-Caching einrichten (wiederholte Passwortabfragen vermeiden)
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

# Automatische Zeilenende-Konvertierung aktivieren
git config --global core.autocrlf true   # Windows
git config --global core.autocrlf input  # Mac/Linux

# Aliase für häufige Befehle einrichten
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'

# Merge- und Diff-Tools konfigurieren
git config --global merge.tool vimdiff
git config --global diff.tool vimdiff

Grundlegende Git-Befehle

Dies sind die grundlegenden Befehle, die Sie täglich verwenden werden. Beherrschen Sie diese zuerst, bevor Sie zu erweiterten Operationen übergehen.

Repository-Initialisierung

# Ein neues Git-Repository initialisieren
git init

# Mit einem bestimmten Branch-Namen initialisieren
git init -b main

# Ein vorhandenes Repository klonen
git clone https://github.com/benutzer/repo.git
git clone [email protected]:benutzer/repo.git  # SSH
git clone https://github.com/benutzer/repo.git mein-ordner  # Benutzerdefinierter Ordnername

# Nur neueste Historie klonen (schneller für große Repos)
git clone --depth 1 https://github.com/benutzer/repo.git

Mit Änderungen arbeiten

# Status des Arbeitsverzeichnisses prüfen
git status
git status -s  # Kurzformat
git status -sb # Kurzformat mit Branch-Info

# Dateien für Commit bereitstellen
git add dateiname.js       # Einzelne Datei
git add src/               # Gesamtes Verzeichnis
git add .                  # Alle Änderungen im aktuellen Verzeichnis
git add -A                 # Alle Änderungen im gesamten Repo
git add -p                 # Interaktives Staging (Patch-Modus)
git add *.js               # Alle JavaScript-Dateien

# Dateien aus Staging entfernen
git reset dateiname.js     # Bestimmte Datei aus Staging entfernen
git reset                  # Alle Dateien aus Staging entfernen

# Bereitgestellte Änderungen committen
git commit -m "feat: Benutzerauthentifizierung hinzufügen"
git commit -am "fix: Login-Bug beheben"  # Stage + Commit verfolgte Dateien
git commit --amend         # Letzten Commit ändern
git commit --amend --no-edit  # Ändern ohne Nachricht zu ändern

# Unterschiede anzeigen
git diff                   # Nicht bereitgestellte Änderungen
git diff --staged          # Bereitgestellte Änderungen
git diff HEAD              # Alle Änderungen seit letztem Commit
git diff main..feature     # Zwischen Branches
git diff --stat            # Zusammenfassung der Änderungen

Dateien entfernen und verschieben

# Dateien entfernen
git rm dateiname.js        # Aus Arbeitsverzeichnis entfernen und Löschung bereitstellen
git rm --cached dateiname.js # Aus Git entfernen, aber im Arbeitsverzeichnis behalten
git rm -r verzeichnis/     # Verzeichnis rekursiv entfernen

# Dateien verschieben oder umbenennen
git mv alter-name.js neuer-name.js
git mv src/datei.js lib/datei.js  # In anderes Verzeichnis verschieben

Wenn Sie git mv oder git rm verwenden, werden die Änderungen automatisch bereitgestellt. Dies ist bequemer als reguläre Shell-Befehle zu verwenden und dann die Änderungen separat bereitzustellen.

Verzweigung & Zusammenführung

Branches sind Gits Killer-Feature. Sie ermöglichen es Ihnen, gleichzeitig an mehreren Features zu arbeiten, ohne die Hauptcodebasis zu beeinträchtigen.

Branch-Verwaltung

# Branches auflisten
git branch                 # Lokale Branches
git branch -r              # Remote-Branches
git branch -a              # Alle Branches (lokal + remote)
git branch -v              # Mit letzter Commit-Info
git branch --merged        # In aktuellen Branch zusammengeführte Branches
git branch --no-merged     # Noch nicht zusammengeführte Branches

# Branches erstellen
git branch feature-login   # Neuen Branch erstellen
git checkout -b feature-login  # Erstellen und zu neuem Branch wechseln
git switch -c feature-login    # Moderne Alternative zu checkout

# Branches wechseln
git checkout main          # Zu main-Branch wechseln
git switch main            # Moderne Alternative
git checkout -            # Zu vorherigem Branch wechseln

# Branches umbenennen
git branch -m alter-name neuer-name  # Branch umbenennen
git branch -M neuer-name   # Aktuellen Branch zwangsweise umbenennen

# Branches löschen
git branch -d feature-login     # Zusammengeführten Branch löschen
git branch -D feature-login     # Zwangsweise löschen (auch wenn nicht zusammengeführt)
git push origin --delete feature-login  # Remote-Branch löschen

Merge-Strategien

# Branches zusammenführen
git merge feature-login    # feature-login in aktuellen Branch zusammenführen
git merge --no-ff feature-login  # Merge-Commit auch für Fast-Forward erstellen
git merge --squash feature-login # Alle Commits in einen zusammenfassen

# Merge abbrechen
git merge --abort

# Nach Konfliktlösung fortfahren
git merge --continue

Rebasing

Rebasing schreibt die Commit-Historie um, indem Ihr Branch auf einen neuen Basis-Commit verschoben wird. Dies erzeugt eine sauberere, lineare Historie, sollte aber vorsichtig verwendet werden.

# Aktuellen Branch auf main rebasen
git rebase main

# Interaktives Rebase (Commits bearbeiten, zusammenfassen, neu ordnen)
git rebase -i HEAD~3       # Letzte 3 Commits
git rebase -i main         # Alle Commits seit Abzweigung von main

# Nach Konfliktlösung fortfahren
git rebase --continue

# Aktuellen Commit überspringen
git rebase --skip

# Rebase abbrechen
git rebase --abort

Merge-Konflikte lösen

Wenn Git Änderungen nicht automatisch zusammenführen kann, müssen Sie Konflikte manuell lösen:

1. Führen Sie git status aus, um zu sehen, welche Dateien Konflikte haben
2. Öffnen Sie konfliktbehaftete Dateien und suchen Sie nach Konfliktmarkierungen (<<<<<<<, =======, >>>>>>>)
3. Bearbeiten Sie die Datei, um Konflikte zu lösen, und entfernen Sie die Markierungen
4. Stellen Sie die gelösten Dateien mit git add bereit
5. Schließen Sie den Merge mit git commit oder git merge --continue ab

# Merge-Tools zur Konfliktlösung verwenden
git mergetool

# Alle Änderungen von einer Seite akzeptieren
git checkout --ours dateiname.js    # Ihre Version behalten
git checkout --theirs dateiname.js  # Deren Version behalten

Remote-Operationen

Remote-Repositories ermöglichen Zusammenarbeit. Diese Befehle helfen Ihnen, Ihre lokale Arbeit mit Remote-Servern wie GitHub, GitLab oder Bitbucket zu synchronisieren.

Remotes verwalten

# Remote-Repositories auflisten
git remote
git remote -v              # Mit URLs

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

# Remote-URL ändern
git remote set-url origin [email protected]:benutzer/repo.git

# Remote entfernen
git remote remove origin

# Remote umbenennen
git remote rename origin upstream

# Remote-Details anzeigen
git remote show origin

Fetchen und Pullen

# Änderungen von Remote abrufen (führt nicht zusammen)
git fetch origin
git fetch --all            # Von allen Remotes abrufen
git fetch --prune          # Gelöschte Remote-Branches entfernen

# Änderungen pullen (fetch + merge)
git pull origin main
git pull --rebase origin main  # Fetch + Rebase statt Merge
git pull --ff-only         # Nur Fast-Forward, fehlschlagen wenn Merge nötig

# Pull mit automatischem Stash
git pull --autostash

Der Unterschied zwischen fetch und pull ist wichtig. Fetch lädt Änderungen herunter, ändert aber nicht Ihr Arbeitsverzeichnis, während Pull die Änderungen automatisch zusammenführt.

Änderungen pushen

# Zu Remote pushen
git push origin main
git push -u origin feature-login  # Upstream setzen und pushen
git push --all             # Alle Branches pushen
git push --tags            # Alle Tags pushen

# Force Push (mit Vorsicht verwenden!)
git push --force           # Remote-Historie überschreiben
git push --force-with-lease # Sicherer Force Push, schlägt fehl wenn Remote aktualisiert

# Remote-Branch löschen
git push origin --delete feature-login
git push origin :feature-login  # Alternative Syntax

Tracking-Branches

# Upstream-Branch setzen
git branch --set-upstream-to=origin/main main
git branch -u origin/main  # Kurzform

# Tracking-Branch erstellen
git checkout -b feature origin/feature
git checkout --track origin/feature  # Automatische Benennung

# Tracking-Beziehungen anzeigen
git branch -vv

Änderungen zwischenspeichern

Stashing legt Änderungen vorübergehend ab, damit Sie an etwas anderem arbeiten können, ohne unvollständige Arbeit zu committen.

# Aktuelle Änderungen stashen
git stash
git stash save "work in progress an Login-Feature"
git stash -u               # Nicht verfolgte Dateien einschließen
git stash -a               # Nicht verfolgte und ignorierte Dateien einschließen

# Stashes auflisten
git stash list

# Gestashte Änderungen anwenden
git stash apply            # Neuesten Stash anwenden
git stash apply stash@{2}  # Bestimmten Stash anwenden
git stash pop              # Anwenden und aus Stash-Liste entfernen

# Stash-Inhalte anzeigen
git stash show
git stash show -p          # Vollständiges Diff anzeigen
git stash show stash@{1}   # Bestimmten Stash anzeigen

# Branch aus Stash erstellen
git stash branch feature-name

# Stashes entfernen
git stash drop stash@{1}   # Bestimmten Stash entfernen
git stash clear            # Alle Stashes entfernen

Stashing ist perfek