mitmario.dev

Git Cheat Sheet: Befehle und Lösungen bei Fehlern

Veröffentlicht am Aktualisiert am 12 Min Lesezeit Mario Laurich

Git ist ein hervorragendes Tool, aber auch leider oft zum verzweifeln. Es ist ein Versionskontrollsystem, das von Linus Torvalds entwickelt wurde. Es ist das am häufigsten verwendete Versionskontrollsystem und wird von vielen in der IT verwendet. In diesem Artikel möchte ich dir die wichtigsten Git Befehle und auch Lösungen für bekannte und häufige Probleme vorstellen.

Illustration: Junge liest einen Zettel mit der Aufschrift Git Cheat Sheet vor einer Holztür mit den Schildern Commit und Branch, über ihm leuchtet ein Schlüssel
Titelbild mit KI erstellt. Der Text entsteht mit KI-Hilfe, geprüft und überarbeitet von mir. Mehr dazu

Git Repository erstellen

Mit git init wird ein neues lokales Git Repository erstellt. Das heißt, dass Git nun alle Änderungen in diesem Ordner verfolgt. In einem Ordner, der schon ein Repository ist, passiert nichts Schlimmes: Git meldet nur, dass es neu initialisiert hat, die History bleibt. Willst du ein Projekt ohne seine History kopieren, löschst du in der Kopie den Ordner .git und startest mit git init neu.

git init

Den Status eines Projektes prüfen

Um den Status eines Projektes zu prüfen kannst du git status verwenden. Dieser Befehl zeigt dir alle Änderungen an, die du gemacht hast. Du kannst dir den Status auch in einem kompakteren Format anzeigen lassen. Dort zeigt die linke Spalte, was im Staging liegt (also für den nächsten Commit vorgemerkt ist), und die rechte, was nur im Arbeitsordner geändert wurde. Den Inhalt der vorgemerkten Änderungen zeigt dir git diff --staged, dazu weiter unten mehr.

# Gibt den Zustand aller Dateien zurück
git status
# Kompaktere Auflistung, links das Staging, rechts der Arbeitsordner
git status -s

# Mögliche Werte
# ?? Datei wurde hinzugefügt, aber noch nicht getrackt
# A  Datei wurde hinzugefügt und wird getrackt
# M  Datei wurde geändert (links: im Staging, rechts: nur im Arbeitsordner)
# D  Datei wurde gelöscht
# R  Datei wurde umbenannt
# C  Datei wurde kopiert
# U  Datei ist unmerged

Neue Änderungen ins Staging hinzufügen

Mit git add kannst du Dateien/Änderungen zu Git hinzufügen (Staging), welche du später für den nächsten Commit einbeziehen möchtest. Du kannst entweder einzelne Dateien, ganze Ordner oder einzelene Änderungen (Codezeilen) hinzufügen.

# Fügt eine Datei hinzu
git add <Dateiname>
# Fügt alle Dateien hinzu
git add .
# Fügt alle Dateien in einem Ordner hinzu
git add <Ordnername>
# Einzelne Änderungen/Hunks auswählen
git add --patch <Dateiname>

Änderungen im Staging commiten

Mit git commit kannst du deine Änderungen welche sich im Staging befinden in das lokale Repository übertragen. Du kannst deinem Commit eine Nachricht hinzufügen, um später nachvollziehen zu können, was du geändert hast.

# Erstellt eine neue Version aus den Dateien im Staging
git commit -m "Nachricht"
# Staged alle geänderten, schon getrackten Dateien selbst. Neue Dateien bleiben draußen
git commit -am "Nachricht"
# Ändert die Nachricht des letzten Commits
# Achtung! Ändert den Commit Hash. Nach einem Push nur mit Force-Push
git commit --amend -m "Neue Nachricht"

Die letzten Commits anzeigen

Mit git log kannst du dir die letzten Commits anzeigen lassen. Du kannst dir die Commits in verschiedenen Formaten anzeigen lassen. Du kannst dir die Commits auch in einem Graph anzeigen lassen. Das ist sehr hilfreich, wenn du mit mehreren Branches arbeitest.

# Die letzten Commits
git log
# Die letzten Commits mit Änderungen
git log -p
# Die letzten Commits mit Änderungen und Statistiken
git log -p --stat
# Commits mit Graph
git log --graph
# Kompakte Übersicht aller Branches als Graph
git log --oneline --graph --decorate --all
# Die letzten 3 Commits
git log -n 3
# Die letzten 3 Commits mit Änderungen
git log -n 3 -p

Alle Aktivitäten anzeigen

Mit git reflog kannst du dir alle Aktionen anzeigen lassen, die du in deinem Repository gemacht hast. Das ist sehr hilfreich, wenn du einen Commit rückgängig machen möchtest. Das Reflog gilt für HEAD, also für alles, wohin dein HEAD gezeigt hat. Die Einträge bleiben nicht ewig (Standard: 90 Tage, bei nicht mehr erreichbaren Commits 30).

# Zeigt alle Aktionen an
git reflog
# Zeigt alle Aktionen mit Zeitstempel statt Nummer an
git reflog --date=iso

Die Unterschiede zwischen Commits und Dateien anzeigen

Mit git diff kannst du dir die Änderungen zwischen zwei Commits anzeigen lassen. Ohne Argumente zeigt es nur, was du noch nicht ins Staging gelegt hast. Alles seit dem letzten Commit zeigt git diff HEAD.

# Noch nicht vorgemerkte Änderungen (Arbeitsordner gegen Staging)
git diff
# Alles seit dem letzten Commit, vorgemerkt und nicht vorgemerkt
git diff HEAD
# Nur die vorgemerkten Änderungen (Staging gegen letzten Commit)
git diff --staged
# Änderungen zwischen zwei Commits
git diff <Commit 1> <Commit 2>

Die letzten Änderungen rückgangig machen

Mit git reset kannst du deinen Arbeitsstand zurücksetzen. Du kannst entweder den Arbeitsstand, den Index oder beides zurücksetzen. Du kannst entweder einzelne Dateien, ganze Ordner oder einzelene Änderungen (Codezeilen) zurücksetzen.

# Holt alle Dateien aus dem Staging
git reset
# Holt eine Datei aus dem Staging
git reset <Dateiname>
# Macht den letzten Commit rückgängig. Dateien bleiben im Staging
git reset --soft HEAD~
# Macht den letzten Commit rückgängig. Änderungen bleiben im Workspace erhalten
git reset --mixed HEAD~
# Verwirft den letzten Commit UND alle nicht committeten Änderungen. Vorsicht
git reset --hard HEAD~

Dateien aus dem Staging entfernen oder Änderungen rückgängig machen

Mit git restore kannst du Dateien aus dem Staging entfernen oder Änderungen rückgängig machen. Du kannst entweder einzelne Dateien, ganze Ordner oder einzelene Änderungen (Codezeilen) entfernen.

# Entfernt eine Datei aus dem Staging
git restore --staged <Dateiname>
# Du kannst einzelne Änderungen auswählen und aus dem Staging entfernen
git restore --staged --patch <Datei>
# Entfernt alle Dateien aus dem Staging
git restore --staged .
# Verwirft deine Änderungen an der Datei. Das lässt sich nicht zurückholen
git restore <Dateiname>

Eine Änderung dem letzten Commit hinzufügen

Wenn du eine Änderung vergessen hast, kannst du diese dem letzten Commit hinzufügen. Das ist nur unproblematisch, solange du den Commit noch nicht gepusht hast. Danach brauchst du einen Force-Push, und wer den alten Stand schon geholt hat, hat ein Problem. Wenn du den Commit bereits gepusht hast, solltest du git commit --amend deshalb nicht verwenden, da du damit den Commit Hash änderst.

# Die vergessene Änderung ins Staging
git add <Dateiname>
# Änderungen dem letzten Commit hinzufügen
git commit --amend --no-edit

Älteren Commit rückgängig machen

Falls du einen Commit rückgängig machen möchtest, kannst du das mit git revert machen. Du musst dafür den Commit noch nicht gepusht haben. Wenn du den Commit bereits gepusht hast, solltest du dennoch git revert verwenden, da du damit den Commit Hash nicht änderst.

# Finde den betreffenden Commit
# Verwende die Pfeiltasten um in der History zu scrollen und kopiere dir den Hash des betreffenden Commits
git log
# Änderungen des Commits rückgängig machen
# git erstellt einen neuen Commit, der den gewählten Commit rückgängig macht. Du musst dafür noch eine Commit-Message eingeben oder einfach abspeichern
git revert <Commit>

Änderungen einer einzelnen Datei Rückgängig machen

Falls du eine Datei geändert hast und einen älteren Stand dieser Datei wiederherstellen möchtest, kannst du das mit git restore machen. Die Datei liegt danach im alten Stand in deinem Ordner. Mit git add und git commit hältst du das fest.

# Finde den Hash eines Commits vor deinen Änderungen
git log
# Alten Stand der Datei in den Arbeitsordner holen
git restore --source=<Commit> -- <pfad/zur/datei>
# Die alte Version liegt jetzt im Ordner. Jetzt festhalten
git add <pfad/zur/datei>
git commit -m "Nachricht"

Das ältere Pendant, das du in vielen Anleitungen siehst, ist git checkout <Commit> -- <pfad/zur/datei>. Das legt die Datei gleich ins Staging, git add fällt dann weg.

Etwas komplett verkackt? So rettest du dein Repo mit reflog

Damit kannst du Dateien zurückholen, die du gelöscht hast, oder Dinge rückgängig machen, die dein Repo zerstört haben, oder einen nicht geglückten Merge oder einfach zu einem Stand zurückkehren, als bestimmte Dinge noch funktioniert haben.

# Zeigt alle Aktionen an
# Du siehst eine Liste von allem, wohin dein HEAD in den letzten Wochen gezeigt hat. Jeder Eintrag hat einen Index: HEAD@{index}
# Finde den Eintrag VOR demjenigen, der alles kaputt gemacht hat.
git reflog
# Setze Branch und Arbeitsordner auf den Eintrag VOR demjenigen, der alles kaputt gemacht hat.
# Achtung: --hard verwirft auch alles, was seit dem Eintrag noch nicht committet war
git reset --hard HEAD@{index}
# Alles ist jetzt wieder so, wie es vorher war.

Ohne --hard springt nur der Branch zurück, der Arbeitsordner bleibt, wie er ist. Eine gelöschte Datei wäre dann weiter gelöscht, erst git restore . holt sie zurück.

Branches erstellen, wechseln und löschen

Anzeigen, Erstellen und Löschen von Branches. Branches sind eine Möglichkeit, um an einem Projekt zu arbeiten, ohne den Hauptzweig zu beeinträchtigen. Ein Branch ist nur ein Zeiger auf einen Commit. Es wird nichts kopiert: Du hast danach eine zweite Linie, auf der neue Commits landen, ohne den Hauptzweig zu beeinflussen. Wenn du fertig bist, kannst du deine Änderungen in den Hauptzweig übernehmen. Ich schreibe hier main, so heißt der Hauptzweig auf GitHub bei neuen Repositories seit Oktober 2020. In älteren Repositories heißt er oft noch master, und git init legt lokal bei der Git-Version, mit der ich das hier geprüft habe (2.43), auch noch master an. Ob main oder master: Die Befehle sind dieselben.

# Zeigt alle Branches an
git branch
# Erstellt einen neuen Branch
git branch <Branchname>
# Löscht einen Branch
git branch -d <Branchname>

Branches wechseln oder Dateien aus einem anderen Branch kopieren

Mit git switch wechselst du zwischen Branches. Du kannst auch einen neuen Branch erstellen und direkt in diesen wechseln. Einzelne Dateien aus einem anderen Branch holst du mit git restore --source.

# Wechselt in einen Branch
git switch <Branchname>
# Erstellt einen neuen Branch und wechselt in diesen
git switch -c <Branchname>
# Kopiert eine Datei aus einem anderen Branch in deinen aktuellen Branch
git restore --source=<Branchname> -- <Dateiname>

git switch und git restore gibt es seit Git 2.23 (August 2019). Vorher hat git checkout beides erledigt, und das funktioniert bis heute: git checkout <Branchname>, git checkout -b <Branchname> und git checkout <Branchname> -- <Dateiname>. Du siehst es deshalb in vielen Anleitungen. Es tut zwei verschiedene Dinge unter einem Namen, und genau deshalb wurde es aufgeteilt.

Branches zusammenführen

Mit git merge übernimmst du die Änderungen eines Branches in deinen aktuellen Branch. Du wechselst also erst in den Branch, der die Änderungen bekommen soll, und holst den anderen hinein.

# Wechsle in den Branch, der die Änderungen bekommen soll
git switch <Zielbranch>
# Mergt einen Branch in deinen aktuellen Branch
git merge <Branchname>

Einen zweiten Branchnamen hinter git merge <Branchname> anzuhängen, bringt dir nicht, was du vielleicht erwartest: Git führt dann beide Branches in den aktuellen zusammen (ein sogenannter Octopus-Merge). Probierst du es in einem Test-Repo aus, entsteht auf main ein Commit “Merge branches …”.

Ausversehen auf main (oder master) commited: Commit in neuen Branch verschieben

Wenn du ausversehen auf main (oder master) commited hast, kannst du das mit folgenden Befehlen rückgängig machen. Das geht auch nach einem Push, dann aber nur mit Force-Push, und der trifft alle, die den Branch schon haben. Der Befehl git reset --hard verwirft dabei auch nicht committete Änderungen an getrackten Dateien, schau also vorher mit git status, ob da noch etwas liegt.

# Erstelle einen neuen Branch
git branch <NeuerBranchname>
# Entferne den letzten Commit vom Hauptzweig
git reset HEAD~ --hard
# In den neuen Branch wechseln
git switch <NeuerBranchname>
# Dein Commit lebt jetzt in dem neuen Branch weiter

In den falschen Branch commited

Wenn du in den falschen Branch commited hast, aber die Änderungen noch behalten möchtest um diese in den richtigen Branch zu commiten dann kannst du das mit folgenden Befehlen rückgängig machen. Das geht auch nach einem Push, dann aber nur mit Force-Push, und der trifft alle, die den Branch schon haben.

# Entferne den letzten Commit vom falschen Branch
git reset HEAD~ --soft
# Speichere die Änderungen in den Stash
git stash
# Wechsle in den richtigen Branch
git switch <RichtigerBranch>
# Hole die Änderungen aus dem Stash
git stash pop
# Füge die Änderungen dem Staging hinzu
git add .
# Commit
git commit -m "Nachricht"
# Jetzt sind deine Änderungen im richtigen Branch

Hier eine Alternative, wenn du die Änderungen nicht im Stash speichern möchtest.

# Wechsle in den richtigen Branch
git switch <RichtigerBranch>
# Hole die Änderungen aus dem falschen Branch
git cherry-pick <falscherBranch>
# Entferne den Commit vom falschen Branch
git switch <falscherBranch>
git reset HEAD~ --hard

Das arbeiten mit Remote Repositories

Mit git remote kannst du dir alle Remotes anzeigen lassen. Du kannst auch einen Remote hinzufügen oder entfernen. Remotes sind Verknüpfungen zu einem Remote Repository. Diese Verknüpfungen werden verwendet, um deine Änderungen in ein Remote Repository zu übertragen.

# Zeigt alle Remotes an
git remote
# Fügt einen Remote hinzu
git remote add <Name> <URL>
# Entfernt einen Remote
git remote remove <Name>
# Nennt einen Remote um
git remote rename <AlterName> <NeuerName>
# Zeigt alle Remotes mit URLs an
git remote -v
# Zeigt alle Informationen zu einem Remote an
git remote show <Name>
# Zeigt die URL eines Remotes an
git remote get-url <Name>
# Setzt die URL eines Remotes
git remote set-url <Name> <URL>

Kopieren eines Remote Repository in ein lokales Repository

Mit git clone kannst du ein Repository klonen. Du kannst entweder ein Repository von GitHub oder von einem anderen Git Server klonen. Du kannst auch ein lokales Repository klonen.

# Klonen eines Repositories von GitHub oder einem anderen Git Server
git clone <URL>
# Klonen eines lokalen Repositories
git clone <Pfad>
# Den Namen des Zielordners ändern
git clone <URL> <Zielordner>
# Das Repository wird in den aktuellen Ordner geklont (der Ordner muss leer sein)
git clone <URL> .

Lokale Änderungen in ein Remote Repository übertragen

Mit git push kannst du deine Änderungen in ein Remote Repository übertragen. Du kannst deine Änderungen in einen bestimmten Branch übertragen. Du kannst auch alle Branches auf einmal übertragen.

# Überträgt deine Änderungen in den aktuellen Branch, sobald der einen Upstream hat
git push
# Beim ersten Push eines neuen Branches: legt den Upstream fest
git push -u origin
# Überträgt deine Änderungen in einen bestimmten Branch
git push <Remote> <Branch>
# Überträgt alle Branches
git push --all

Den Stand eines Remote Repositorys in ein lokales Repository übertragen

Mit git fetch kannst du dir alle Änderungen aus einem Remote Repository herunterladen. Du kannst dir auch alle Branches herunterladen. Du kannst dir auch alle Tags herunterladen. Jedoch werden die Änderungen nicht in deinen lokalen Branches übernommen. Du musst die Änderungen mit git merge oder git rebase in deine lokalen Branches übernehmen.

# Lädt alle Änderungen und alle Branches von origin herunter
git fetch
# Holt von allen eingetragenen Remotes, nicht nur von origin
git fetch --all
# Lädt alle Tags aus einem Remote Repository herunter
git fetch --tags
# Merge die Änderungen in deinen lokalen Branch (bei älteren Repos origin/master)
git merge origin/main
# Rebase die Änderungen in deinen lokalen Branch
git rebase origin/main

Den Stand eines Remote Repositorys in ein lokales Repository übertragen und zusammenführen

Mit git pull lädst du Änderungen aus einem Remote Repository herunter und übernimmst sie in deinen aktuellen Branch. Es ist ein git fetch mit anschließendem Merge (oder Rebase).

# Lädt die Änderungen des Branches herunter und übernimmt sie in deinen aktuellen Branch
git pull <Remote> <Branch>
# Holt von allen Remotes, übernimmt aber nur den Upstream deines aktuellen Branches
git pull --all

git pull <Remote> --all gibt es nicht, Git bricht mit fetch --all does not take a repository argument ab. Tags holst du mit git fetch --tags. Ein git pull <Remote> --tags holt sie auch, merged aber zusätzlich wie jeder Pull.

Haben dein Branch und der auf dem Server beide neue Commits, will Git wissen, wie es sie zusammenbringen soll, und bricht mit Need to specify how to reconcile divergent branches ab. Über diese Meldung stolpert man oft beim ersten Pull. Einmal git config --global pull.rebase false (Merge) oder true (Rebase) setzen, dann ist Ruhe.

Fazit

Das waren die wichtigsten Git Befehle. Ich hoffe, dass ich dir mit diesem Artikel weiterhelfen konnte. Wenn du noch Fragen hast, kannst du mir gerne auf X oder LinkedIn schreiben. Den Verlauf siehst du auch in einer Oberfläche, mehr dazu in der Liste meiner VS Code Plugins. Ich wünsche dir noch einen schönen Tag. Bis zum nächsten Mal. 👋

Newsletter

einmal die Woche, kostenlos

Neue Artikel und Videos, was sich auf der Lernplattform tut, und ab und zu ein Sonderpreis zum Kursstart. Kurz genug, dass du es auch liest.

Zuletzt verschickt · KW 47

Lektionen jetzt auch mit Video

Danach kommt eine Mail mit Bestätigungslink, erst dann bist du eingetragen. Abmelden geht unten in jeder Ausgabe. Mehr dazu in der Datenschutzerklärung.