Git Diff & Änderungen vergleichen | Programmieren Lernen

Bevor du einen Commit erstellst, moechtest du oft wissen: Was genau habe ich geaendert? git diff ist dein Werkzeug, um Aenderungen praezise zu sehen - Zeile fuer Zeile, Datei fuer Datei. In diesem Kapitel lernst du alle wichtigen Varianten dieses maechtigen Befehls.

git diff - Grundlagen

Unstaged Aenderungen anzeigen

Der einfachste Aufruf zeigt dir, was du seit dem letzten git add geaendert hast:

git diff

diff --git a/index.html b/index.html
index 1a2b3c4..5d6e7f8 100644
--- a/index.html
+++ b/index.html
@@ -8,7 +8,9 @@
 <body>
     <header>
-        <h1>Willkommen</h1>
+        <h1>Willkommen auf meiner Webseite</h1>
+        <p>Hier findest du meine Projekte und Blog-Posts.</p>
     </header>

Die Ausgabe lesen

Element	Bedeutung
`---a/index.html`	Die alte Version der Datei
`+++b/index.html`	Die neue Version der Datei
`@@ -8,7 +8,9 @@`	Position der Aenderung (Zeile 8)
Zeilen mit `-` (rot)	Entfernte Zeilen
Zeilen mit `+` (gruen)	Hinzugefuegte Zeilen
Zeilen ohne Zeichen	Unveraenderte Kontext-Zeilen

Staged Aenderungen anzeigen

Was wird beim naechsten Commit gespeichert?

git diff --staged

Das zeigt nur die Aenderungen, die du bereits mit git add zum Staging hinzugefuegt hast.

Alle Aenderungen anzeigen (staged + unstaged)

git diff HEAD

Das vergleicht dein Working Directory mit dem letzten Commit - egal ob Aenderungen gestaged sind oder nicht.

Vergleiche zwischen Zustaenden

Working Directory vs. Staging Area

# Was ist geaendert, aber noch nicht gestaged?
git diff

Staging Area vs. letzter Commit

# Was wird im naechsten Commit gespeichert?
git diff --staged

Working Directory vs. letzter Commit

# Alle Aenderungen seit dem letzten Commit
git diff HEAD

Zwischen zwei Commits vergleichen

# Zwischen zwei bestimmten Commits
git diff abc1234 def5678

# Zwischen dem vorletzten und letzten Commit
git diff HEAD~1 HEAD

Zwischen Branches vergleichen

# Was hat sich im Feature-Branch gegenueber main geaendert?
git diff main..feature/navigation

# Kurzform
git diff main feature/navigation

Diff fuer bestimmte Dateien

Eine bestimmte Datei vergleichen

# Aenderungen in einer bestimmten Datei
git diff index.html

# Staged Aenderungen in einer Datei
git diff --staged style.css

# Aenderungen einer Datei zwischen Commits
git diff abc1234 def5678 -- index.html

Mehrere Dateien

git diff -- index.html style.css

# Alle CSS-Dateien
git diff -- "*.css"

Nur bestimmte Ordner

git diff -- src/

Kompakte Diff-Ansichten

Nur Dateinamen anzeigen

git diff --name-only

index.html
style.css

Dateinamen mit Status

git diff --name-status

M       index.html
M       style.css
A       kontakt.html
D       alte-seite.html

Statistik-Ansicht

git diff --stat

 index.html   | 12 +++++++++---
 style.css    |  5 +++--
 kontakt.html | 25 +++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 5 deletions(-)

Kurzstatistik

git diff --shortstat

 3 files changed, 37 insertions(+), 5 deletions(-)

Erweiterte Diff-Optionen

Wort-fuer-Wort Diff

Statt ganzer Zeilen kannst du auch einzelne Woerter hervorheben:

git diff --word-diff

<h1>Willkommen [-auf meiner-]{+auf unserer+} Webseite</h1>

Geloeschte Woerter stehen in [-...-], hinzugefuegte in {+...+}.

Leerzeichen ignorieren

# Alle Leerzeichenaenderungen ignorieren
git diff -w

# Nur Aenderungen in der Einrueckung ignorieren
git diff --ignore-space-change

Kontext-Zeilen anpassen

# Mehr Kontext anzeigen (Standard: 3 Zeilen)
git diff -U5

# Weniger Kontext
git diff -U1

Farbige Ausgabe erzwingen

git diff --color

Diff-Tools verwenden

Externes Diff-Tool konfigurieren

# VS Code als Diff-Tool
git config --global diff.tool vscode
git config --global difftool.vscode.cmd 'code --wait --diff $LOCAL $REMOTE'

Diff-Tool starten

git difftool

Das oeffnet die Aenderungen in deinem konfigurierten Tool mit einer grafischen Ansicht.

Praktische Szenarien

Szenario 1: “Was habe ich heute geaendert?”

git diff HEAD --stat

 index.html   | 15 ++++++++++-----
 style.css    |  8 ++++----
 script.js    | 22 ++++++++++++++++++++++
 3 files changed, 36 insertions(+), 9 deletions(-)

Szenario 2: “Was ist im Staging, was nicht?”

# Staged
git diff --staged --name-only

# Unstaged
git diff --name-only

Szenario 3: “Was hat sich seit dem letzten Release geaendert?”

git diff v1.0..HEAD --stat

Szenario 4: “Hat jemand die Config-Datei geaendert?”

git diff HEAD~5 HEAD -- config.json

Szenario 5: Vor dem Commit pruefen

# 1. Was werde ich committen?
git diff --staged

# 2. Sieht gut aus? Dann committen!
git commit -m "feat: Neue Funktion hinzugefuegt"

Diff in der Praxis: Ein Beispiel

Du arbeitest an deiner Webseite und hast verschiedene Aenderungen gemacht:

# Status pruefen
git status -s

 M index.html
 M style.css
?? neue-seite.html

# Alle Aenderungen anschauen
git diff

diff --git a/index.html b/index.html
--- a/index.html
+++ b/index.html
@@ -3,6 +3,7 @@
 <head>
     <title>Meine Webseite</title>
+    <meta name="description" content="Portfolio von Max Mustermann">
     <link rel="stylesheet" href="style.css">
 </head>

diff --git a/style.css b/style.css
--- a/style.css
+++ b/style.css
@@ -1,5 +1,6 @@
 body {
     font-family: Arial, sans-serif;
+    max-width: 1200px;
+    margin: 0 auto;
 }

Jetzt kannst du entscheiden, welche Aenderungen zusammengehoeren und sie gezielt stagen.

Uebungen

Aendere eine Datei und nutze git diff, um die Aenderungen zu sehen
Stage die Datei und nutze git diff --staged, um die gestagten Aenderungen zu pruefen
Vergleiche zwei Commits mit git diff commit1 commit2
Nutze git diff --stat, um eine Zusammenfassung zu sehen
Probiere git diff --word-diff aus, um Wort-Aenderungen zu sehen

Was kommt als Naechstes?

Im naechsten Kapitel lernst du Branches kennen - eines der maechtigsten Features von Git. Du wirst verstehen, wie du parallel an verschiedenen Features arbeiten kannst, ohne dich gegenseitig zu stoeren.

Zusammenfassung

git diff zeigt unstaged Aenderungen an
git diff --staged zeigt staged Aenderungen an
git diff HEAD zeigt alle Aenderungen seit dem letzten Commit
Du kannst zwischen Commits, Branches und Dateien vergleichen
--stat gibt eine kompakte Uebersicht der Aenderungen
--word-diff hebt einzelne Wort-Aenderungen hervor
Pruefe mit git diff --staged immer vor dem Commit, was du speicherst

Pro-Tipp: Mache es dir zur Gewohnheit, vor jedem Commit git diff --staged auszufuehren. So erwischst du Debug-Ausgaben, Tippfehler oder versehentliche Aenderungen, bevor sie in die Historie gelangen. Die paar Sekunden sind gut investiert!