Git Diff erklärt: Ein kompletter Leitfaden mit Beispielen

Tutorials
Git

Git diff ist Ihr Fenster zu den Änderungen, die in Ihrem Code-Repository stattfinden. Im Kern ist es ein Befehl, der die Unterschiede zwischen verschiedenen Zuständen Ihrer Dateien anzeigt — ob das nun der Vergleich Ihrer aktuellen Arbeit mit dem ist, was Sie bereits vorbereitet haben, oder der Vergleich von Änderungen zwischen Branches und Commits. Denken Sie daran, dass es Gits Antwort auf die Frage „Was hat sich geändert?“ ist. Wenn Sie git diff ausführen, analysiert Git den Inhalt der Dateien zeilenweise, erkennt, was hinzugefügt, entfernt oder geändert wurde, und präsentiert diese Informationen in einem standardisierten Format, das genau hervorhebt, was sich geändert hat und wo.

Git diff hilft Entwicklern, die Codequalität sicherzustellen, indem es einen klaren Überblick über die Änderungen bietet, bevor sie festgeschrieben werden. Hier werden wir behandeln, wie man diesen wesentlichen Befehl effektiv nutzt, von grundlegenden Vergleichen bis hin zu fortgeschrittenen Techniken, die Ihren Entwicklungsworkflow und die Zusammenarbeit im Team verbessern.

Voraussetzungen

Um diesem Tutorial folgen zu können, sollten Sie mit diesen Git-Konzepten vertraut sein:

  • Grundlegendes Git-Workflow (init, add, commit)
  • Git-Repositories und deren Struktur
  • Zweige und wie sie funktionieren
  • Commits und Commit-Verlauf
  • Der Zwischenspeicher (Index)

Wenn Sie sich in diesen Konzepten noch etwas unsicher fühlen, können Ihnen diese Ressourcen helfen:

Sie benötigen Git installiert auf Ihrem System, um den Beispielen folgen zu können. Alle Befehle können in einem Terminal oder einer Eingabeaufforderung ausgeführt werden.

Warum Git Diff für Entwickler unverzichtbar ist

Jeder Entwickler muss wissen, was sich in seinem Code geändert hat, egal ob er alleine arbeitet oder in einem Team von Hunderten. Ohne git diff müssten Sie raten, welche Zeilen Sie geändert haben, was Fehlerbehebung und Zusammenarbeit nahezu unmöglich machen würde.

Git diff ist für das Änderungsmanagement unerlässlich und dient als Grundlage für den Aufbau qualitativ hochwertiger Software durch effektive Überprüfungsprozesse. Beim Untersuchen von Änderungen liefert git diff den Kontext, der nicht nur zeigt, was geändert wurde, sondern auch warum diese Änderungen wichtig sind.

Diese direkte Sichtbarkeit in die Code-Entwicklung hilft Teams, Standards aufrechtzuerhalten und zu verhindern, dass Fehler die Produktion erreichen.

Wenn Projekte an Komplexität zunehmen, wird git diff aus mehreren wichtigen Gründen wirklich unverzichtbar:

  • Änderungsüberprüfung: Bestätigen Sie genau, was Sie gerade übernehmen möchten, um die versehentliche Einbeziehung von Debugging-Code oder nicht zusammenhängenden Änderungen zu verhindern
  • Wissenstransfer: Verstehen, was Teammitglieder getan haben, ohne die gesamten Dateien lesen zu müssen
  • Konfliktlösung: Genau identifizieren, wo und wie Konflikte bei Zusammenführungen auftreten
  • Historische Analyse: Nachverfolgen, wann bestimmte Änderungen eingeführt wurden, um Fehler zu beheben oder die Entwicklung von Funktionen zu verstehen
  • Zielgerichtete Code-Reviews :  Lenken Sie die Aufmerksamkeit auf die Teile des Codes, die tatsächlich geändert wurden, sparen Sie Zeit und verbessern Sie die Qualität der Überprüfung

Um git diff effektiv zu nutzen, ist es notwendig, die zugrunde liegende Architektur zu verstehen, die diese Vergleiche ermöglicht – das „Three-Tree“-Modell von Git.

Die Three-Tree-Architektur von Git

Um git diff zu verstehen, müssen Sie zunächst die grundlegende „Three-Tree“-Architektur von Git begreifen. Trotz des Namens handelt es sich hierbei nicht um tatsächliche Bäume im Dateisystem, sondern um drei verschiedene Zustände, in denen Ihr Code existiert. 

Betrachte diese Zustände als drei verschiedene Versionen deines Projekts, die Git gleichzeitig verfolgt: das Arbeitsverzeichnis (deine tatsächlichen Dateien), die Staging-Area (oder Index, wo Änderungen für das Commit vorbereitet werden) und das Repository (die festgeschriebene Historie deines Projekts, die im .git Verzeichnis gespeichert ist).

Quelle: Hashnode

Das Arbeitsverzeichnis enthält die Dateien, die du aktiv bearbeitest — hier schreibst du Code, nimmst Änderungen vor und testest deine Arbeit. Die Staging-Area fungiert als Vorbereitungszone, in der du auswählst, welche Änderungen in deinem nächsten Commit enthalten sein sollen . Du kannst es dir wie einen Ladebereich vorstellen, in dem Pakete (deine Änderungen) organisiert werden, bevor sie versendet werden.

Schließlich speichert das Repository die vollständige Historie Ihres Projekts als eine Reihe von Commits, Schnappschüsse Ihres Codes zu bestimmten Zeitpunkten, die miteinander verknüpft sind, um eine historische Kette zu bilden.

Git diff funktioniert, indem es diese drei Zustände in verschiedenen Kombinationen vergleicht. Wenn Sie git diff ohne Argumente ausführen, vergleicht es Ihr Arbeitsverzeichnis mit dem Staging-Bereich und zeigt Änderungen an, die Sie vorgenommen, aber noch nicht gestaged haben.

Die Verwendung von git diff --staged vergleicht den Staging-Bereich mit dem letzten Commit und zeigt, was in Ihren nächsten Commit aufgenommen wird.

Und git diff HEAD vergleicht Ihr Arbeitsverzeichnis direkt mit dem letzten Commit und zeigt alle nicht bestätigten Änderungen unabhängig vom Staging-Status an.

Diese Vergleichspunkte bilden die Grundlage für alle Diff-Operationen in Git:

  • Arbeitsverzeichnis ↔ Staging-Bereich: Welche Änderungen habe ich gemacht, aber noch nicht gestaged? (git diff)
  • Arbeitsbereich ↔ Repository: Welche Änderungen habe ich ins Staging übernommen, die als nächstes committet werden? (git diff --staged)
  • Arbeitsverzeichnis ↔ Repository: Was ist der Gesamtunterschied zwischen meinen Arbeitsdateien und dem letzten Commit? (git diff HEAD)
  • Zwischen Commits: Wie hat sich der Code zwischen bestimmten Punkten in der Historie entwickelt? (git diff commit1-hash commit2-hash)

Das Verständnis dieser Architektur vermittelt Ihnen das mentale Modell, das Sie benötigen, um git diff effektiv einzusetzen, um genau festzustellen, was, wo und wann in Ihrem Codebase geändert wurde.

Mit diesem architektonischen Verständnis können wir nun erkunden, wie man git diff-Befehle in der Praxis einsetzt, um Einblicke in die Entwicklung Ihres Codes über diese drei Zustände hinweg zu gewinnen.

Grundlegende Verwendung von Git Diff

Lasst uns ein Beispielprojekt zur Datenanalyse erstellen, um git diff in Aktion zu demonstrieren. Wir werden ein kleines Repository mit Python-Skripten, CSV-Daten und Textdateien einrichten, die wir während dieses Tutorials modifizieren können.

# Erstelle und initialisiere unser Projekt
mkdir data-analysis-project
cd data-analysis-project
git init

# Erstelle die Anfangsdateien
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality." > README.md
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()" > analysis.py
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30" > data.csv
echo "DEBUG=False\nDATABASE_PATH=./data/" > config.txt
echo "def normalize_data(data):\n return (data - data.min()) / (data.max() - data.min())" > utils.py

# Mache unser erstes Commit
git add .
git commit -m "Initial commit with basic project structure"

# Überprüfe die Verzeichnisstruktur
> tree

.
├── README.md
├── analysis.py
├── config.txt
├── data.csv
└── utils.py

Unser Projekt hat jetzt fünf Dateien unter Versionskontrolle, was uns eine Grundlage bietet, um verschiedene Diff-Szenarien zu demonstrieren. Im Laufe des Fortschritts werden wir diese Dateien modifizieren, um zu zeigen, wie git diff Änderungen in verschiedenen Kontexten offenbart.

Die Ergebnisse von git diff verstehen

Wenn Sie einen git diff-Befehl ausführen, folgt die Ausgabe einem standardisierten Format, das klar zeigt, was sich geändert hat. Lassen Sie uns unsere analysis.py-Datei ändern, um einen Diff in Aktion zu sehen:

# Aktualisiere analysis.py mit einer neuen Funktion
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()\n\ndef visualize_data(data):\n return data.plot(kind='bar')" > analysis.py

Jetzt lassen Sie uns den resultierenden git diff untersuchen:

git diff

Sie werden eine Ausgabe sehen, die dieser ähnelt:

Hinweis: Um die git diff-Ausgabe zu beenden, drücken Sie „q“ in Ihrem Terminal.

Lassen Sie uns diese Ausgabe aufschlüsseln:

  1. Die Kopfzeile (diff --git a/analysis.py b/analysis.py) zeigt, welche Datei verglichen wird, nämlich analysis.py
  2. Die Dateimetadaten (index db0e049..a7a7ab0 100644) zeigen interne Git-Identifikatoren für die vorherige und die nachfolgende Version
  3. Die Dateimarker (--- a/analysis.py und +++ b/analysis.py) geben die „vorherigen“ und „nachherigen“ Dateien an
  4. Die Hunk-Überschrift (@@ -5,3 +5,6 @@) zeigt, welche Zeilen betroffen waren. Diese Notation kann wie folgt interpretiert werden:
  • -5,3 bedeutet, dass ab Zeile 5 in der Originaldatei 3 Zeilen im Diff angezeigt werden
  • +5,6 bedeutet, dass ab Zeile 5 in der geänderten Datei 6 Zeilen im Diff angezeigt werden
  • Der Unterschied zwischen diesen Zahlen zeigt an, dass 3 Zeilen hinzugefügt wurden

5. Die Inhaltsänderungen mit Zeilen, die mit + beginnen, zeigen Hinzufügungen

In größeren Dateien gruppiert git diff Änderungen in „Hunks“ – Abschnitte der Datei, die Änderungen enthalten. Jeder Hunks hat einen eigenen Header mit Zeilennummern, um Ihnen bei der Lokalisierung der Änderungen in der Datei zu helfen.

Vergleich von Arbeitsverzeichnis und Zwischenablage

Ausführen von git diff ohne Argumente vergleicht Ihr Arbeitsverzeichnis (aktueller Zustand der Dateien) mit der Zwischenablage (Änderungen, die bereit sind, übernommen zu werden). Dies ist nützlich, um zu überprüfen, was Sie geändert haben, aber noch nicht für Ihren nächsten Commit vorbereitet haben.

Ändern wir mehrere Dateien, um dies zu demonstrieren:

# README.md aktualisieren
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality.\n\n## Installation\nRun \pip install -r requirements.txt" > README.md

# data.csv aktualisieren
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30\n4,delta,40" > data.csv

Jetzt inszenieren wir nur die Änderungen an README.md:

git add README.md

Das Ausführen von git diff zeigt jetzt nur die nicht gestagten Änderungen an data.csv und der analysis.py Datei oben:

Das hilft Ihnen, sich auf das zu konzentrieren, was Sie noch nicht gestagt haben. Wenn Sie sehen möchten, was Sie bereits gestagt haben:

git diff --staged # or git diff --cached (they're synonyms)

Dies zeigt die Änderungen an README.md, die gestagt und bereit zum Commit sind. Dieser Workflow ist entscheidend für das Erstellen von sauberen, logischen Commits. Sie können Teile Ihrer Arbeit, die zusammenpassen, stagieren, die gestagten Unterschiede überprüfen, um sicherzustellen, dass es sich um eine kohärente Einheit von Änderungen handelt, und dann committen.

Vergleich des Staging-Bereichs und des letzten Commits

Der Befehl git diff --staged vergleicht Ihren Staging-Bereich mit Ihrem letzten Commit. Dies zeigt Ihnen genau, was in Ihrem nächsten Commit enthalten sein wird, wenn Sie jetzt git commit ausführen.

Lassen Sie uns die Änderungen an data.csv ins Staging bringen und prüfen, was sich dort befindet:

git add data.csv
git diff --staged

Die Ausgabe zeigt nun Änderungen sowohl an README.md als auch an data.csv, da beide gestaged wurden. Dieser Überprüfungsschritt ist vor dem Commit entscheidend – er dient als Ihre letzte Verteidigungslinie gegen das Commiten unbeabsichtigter Änderungen.

Ein häufiger Workflow könnte so aussehen:

  1. Änderungen an mehreren Dateien vornehmen
  2. Führen Sie git diff aus, um alle Änderungen zu überprüfen
  3. Verwenden Sie git add <Datei> selektiv, um logische Gruppen von Änderungen zu erfassen
  4. Führen Sie git diff --staged aus, um zu überprüfen, was demnächst committed wird
  5. Commiten Sie die erfassten Änderungen mit git commit -m "Ihre Nachricht"
  6. Wiederholen Sie dies für andere logische Änderungsgruppierungen

Dieser methodische Ansatz hilft dabei, einen sauberen, aussagekräftigen Commit-Verlauf aufrechtzuerhalten, der es erleichtert zu verstehen, wie sich Ihr Projekt entwickelt hat und wo Probleme eingeführt worden sein könnten. Mit zunehmender Erfahrung werden diese Diff-Befehle zur zweiten Natur, die Ihnen im Entwicklungsprozess ständig zur Seite stehen.

Lassen Sie uns unsere Commits machen, bevor wir zur nächsten Stufe übergehen:

# data.csv und README.md sind zu committen
git commit -m "Modify data.csv and README.md files"

# Stagen und Committen von analysis.py
git add analysis.py
git diff --staged  # Review the changes one more time
git commit -m "Add a new function to analysis.py"

Intermediate Git Diff Techniken

Jetzt, da wir die Grundlagen von git diff verstehen, wollen wir leistungsfähigere Techniken erkunden, die Ihre Fähigkeit verbessern werden, Änderungen in Ihren Projekten zu verfolgen und zu analysieren. Wir werden weiter an unserem Datenanalyse-Projekt arbeiten, um diese fortgeschrittenen Konzepte zu demonstrieren.

Vergleichen zwischen verschiedenen Referenzen

Git basiert auf dem Konzept von Referenzen – Zeigern auf spezifische Zustände Ihres Codes. Diese Referenzen umfassen Branches, Commits und Tags. Der git diff Befehl kann zwei beliebige dieser Referenzen vergleichen, um zu zeigen, was sich zwischen ihnen geändert hat.

Lassen Sie uns einen neuen Branch erstellen, um ein Feature zu entwickeln und einige Änderungen vorzunehmen:

# Erstelle und wechsle zu einem neuen Branch
git checkout -b feature/advanced-analytics

# Modifiziere die Datei analysis.py mit einer neuen Funktion
echo "import pandas as pd
import numpy as np

def load_data(filename):
   return pd.read_csv(filename)

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   """Performs advanced statistical analysis on the dataset"""
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

# Übernehme die Änderungen
git add analysis.py
git commit -m "Add advanced analysis function"

Jetzt können wir unseren Feature-Branch mit dem Haupt-Branch vergleichen:

git diff main feature/advanced-analytics

Dieser Befehl zeigt alle Unterschiede zwischen den beiden Branches — jede Datei, die modifiziert, hinzugefügt oder gelöscht wurde. Du wirst die Änderungen sehen, die wir an analysis.py vorgenommen haben, einschließlich unserer neuen Importe und Funktionen (drücke mehrmals die Eingabetaste, da der vollständige Diff im Terminal abgeschnitten wird).

Um mit einem bestimmten Commit zu vergleichen, kannst du den Commit-Hash verwenden:

git log --oneline  # Find the commit hash you want to compare with

git diff 7b3105e  # Replace 7b3105e with the actual commit hash you want to compare

Diese Vergleichsfunktion wird unschätzbar, wenn:

  • Du dich auf Code-Reviews vorbereitest, indem du alle Änderungen in einem Feature-Branch siehst
  • Überprüfen möchtest, welche Änderungen der Branch eines Kollegen einführen würde, bevor du zusammenführst
  • Nachvollziehen möchtest, wie sich dein Codebestand zwischen Releases oder Versionen entwickelt hat

Bestimmte Dateien vergleichen möchtest

Wenn du mit großen Repositories arbeitest, möchtest du oft die Änderungen an bestimmten Dateien oder Verzeichnissen fokussieren, anstatt alle Unterschiede zu sehen. Git diff macht dies einfach, indem du Pfade angeben kannst.

Lass uns Änderungen an mehreren Dateien vornehmen:

# Aktualisiere config.txt
echo "DEBUG=True
DATABASE_PATH=./data/
LOG_LEVEL=INFO" > config.txt

# Aktualisiere utils.py
echo "def normalize_data(data):
   return (data - data.min()) / (data.max() - data.min())

def clean_data(data):
   return data.dropna()" > utils.py

Um nur die Änderungen an der Konfigurationsdatei zu sehen:

git diff config.txt

Oder um eine bestimmte Datei zwischen Branches zu vergleichen:

# Vergleiche die Datei analysis.py zwischen den Branches main und feature/advanced-analytics
git diff main feature/advanced-analytics -- analysis.py

Der -- in dem obigen Befehl hilft Git, zwischen Referenzen und Dateipfaden zu unterscheiden. Dies ist besonders nützlich, wenn:

  • Sie in Repositories mit vielen Dateien arbeiten, sich jedoch auf bestimmte Komponenten konzentrieren (was oft der Fall sein wird)
  • Sie prüfen, wie sich die Konfigurationen in verschiedenen Branches geändert haben
  • Sie nur die wichtigsten Dateien in einer großen Anzahl von Änderungen überprüfen möchten

Kontextuelle Diff-Optionen

Git diff bietet mehrere Optionen zur Anpassung der Anzeige von Unterschieden, um es einfacher zu machen, sich auf bedeutende Änderungen zu konzentrieren.

Zum Beispiel können bei Änderungen an der Codeformatierung Unterschiede in der Leerzeichenverwendung wichtige semantische Änderungen verdecken. Lassen Sie uns dies anhand einer Formatänderung demonstrieren:

# Führen Sie eine Leerzeichenänderung in analysis.py durch
sed -i '' 's/    return/  return/g' analysis.py  # Reduce indentation

Beim Vergleich mit dem Standard-Git-Diff werden Leerzeichenänderungen angezeigt (beachten Sie, wie die return-Anweisungen falsch ausgerichtet sind):

git diff analysis.py

# OUT:
--- a/analysis.py
+++ b/analysis.py
@@ -2,17 +2,17 @@ import pandas as pd
import numpy as np

def load_data(filename):
-    return pd.read_csv(filename)
+  return pd.read_csv(filename)

def analyze_data(data):
-    return data.describe()
+  return data.describe()

def visualize_data(data):
-    return data.plot(kind='bar')
+  return data.plot(kind='bar')

def perform_advanced_analysis(data):
    Performs advanced statistical analysis on the dataset
    results = {}
    results['correlation'] = data.corr()
    results['skew'] = data.skew()
-    return results
+  return results

Aber wir können Leerzeichenänderungen ignorieren (hier werden keine Änderungen angezeigt, da wir nur Leerzeichen entfernt haben):

git diff -w analysis.py  # or --ignore-all-space

Eine weitere nützliche Option ist die Steuerung der Kontextzeilen — die unveränderten Zeilen, die um die Änderungen herum angezeigt werden:

git diff -U1 analysis.py  # Show only 1 line of context (default is 3)
git diff -U5 analysis.py  # Show 5 lines of context

Diese Kontextoptionen sind besonders wertvoll, wenn:

  • Sie Code überprüfen, der automatischen Formatierungen unterzogen wurde
  • Sie sich auf funktionale Änderungen anstatt auf stilistische Änderungen konzentrieren
  • Sie mehr Kontext benötigen, um eine bestimmte Änderung zu verstehen
  • Sie mit großen Dateien arbeiten, bei denen der Standardkontext zu viele Ausgaben erzeugen würde

Indem Sie diese fortgeschrittenen Techniken beherrschen, haben Sie eine viel feinere Kontrolle darüber, wie Sie Änderungen in Ihrem Codebestand überprüfen und verstehen, was Ihren Entwicklungsworkflow effizienter und Ihre Codeüberprüfungen effektiver macht.

Lassen Sie uns die neuesten Änderungen übernehmen, bevor wir zu fortgeschrittenen Git-Diff-Anwendungen übergehen:

git add .
git commit -m "Modify analysis.py, config.txt, and utils.py"

Fortgeschrittene Git-Diff-Anwendungen

Aufbauend auf unserem Verständnis der fortgeschrittenen Techniken von git diff wollen wir einige fortgeschrittene Anwendungen erkunden, die Ihre Git-Fähigkeiten auf die nächste Stufe heben werden. Diese fortgeschrittenen Techniken sind besonders nützlich, wenn Sie an komplexen Codebasen arbeiten oder mit größeren Teams zusammenarbeiten.

Verwendung externer Diff-Tools

Obwohl der integrierte Diff von Git leistungsstark ist, bietet manchmal ein visuelles Diff-Tool eine bessere Übersicht, insbesondere bei komplexen Änderungen. Git ermöglicht es Ihnen, externe Tools zu konfigurieren, um Ihr Diff-Erlebnis zu verbessern.

Lassen Sie uns ein beliebtes visuelles Diff-Tool einrichten. Wir verwenden VSCode als Beispiel, aber eine ähnliche Konfiguration funktioniert auch für Tools wie Beyond Compare, Meld oder KDiff3:

# Konfigurieren Sie Git, um VSCode als Diff-Tool zu verwenden (projektspezifisch)
git config diff.tool vscode
git config difftool.vscode.cmd "code --wait --diff \$LOCAL \$REMOTE"

# Für die Verwendung anderer beliebter Tools könnten Sie verwenden:
# Für Beyond Compare (projektspezifisch):
git config diff.tool bc3
git config difftool.bc3.path "/path/to/beyond/compare"

# Installationsbefehle:
# Für Beyond Compare:
# Auf macOS: brew install --cask beyond-compare
# Auf Ubuntu: sudo apt-get install beyond-compare
# Auf Windows: Herunterladen von https://www.scootersoftware.com/download.php

# Hinweis: Um diese Einstellungen global anzuwenden anstelle des aktuellen Projekts,
# fügen Sie jedem Befehl die --global-Flag hinzu, zum Beispiel:
# git config --global diff.tool vscode

Statt git diff zu verwenden, können Sie jetzt verwenden:

git difftool main feature/advanced-analytics

Dies öffnet Ihr konfiguriertes visuelles Diff-Tool, um die Änderungen anzuzeigen. So sieht Beyond Compare aus:

Visuelle Diff-Tools bieten mehrere Vorteile:

  1. Vergleich nebeneinander, was es einfacher macht, den Kontext zu sehen
  2. Syntaktische Hervorhebung, die mit Ihren Editor-Vorlieben übereinstimmt
  3. Erweiterte Navigation zwischen Änderungen
  4. Die Möglichkeit, Dateien direkt während der Überprüfung von Unterschieden zu bearbeiten

Bei der Überprüfung großer Änderungen oder Dateien mit komplexen Strukturen (wie geschachteltem JSON oder XML) können visuelle Diff-Tools das Verständnis und die Effizienz erheblich verbessern.

Spezialisierte Diff-Befehle

Git bietet spezialisierte Diff-Befehle, die Ihnen eine genauere Kontrolle für spezifische Anwendungsfälle geben. Lassen Sie uns einige dieser leistungsstarken Befehle erkunden:

git diff-tree untersucht Unterschiede zwischen Baumobjekten (Verzeichnissen):

# Holen Sie sich den Hash der letzten beiden Commits
LAST_COMMIT=$(git rev-parse HEAD)
PREV_COMMIT=$(git rev-parse HEAD~1)

# Zeigen Sie die Änderungen im letzten Commit an
git diff-tree --patch $PREV_COMMIT $LAST_COMMIT

git diff-index vergleicht den Arbeitsbaum mit dem Index (Staging-Bereich) oder einem Baum:

# Vergleichen Sie das Arbeitsverzeichnis mit dem Index
git diff-index --patch HEAD

git diff-index ist besonders nützlich für Skripterstellung und Automatisierung. Es ermöglicht Ihnen, programmgesteuert zu überprüfen, welche Änderungen in Ihrem nächsten Commit enthalten sein würden, was es wertvoll für Pre-Commit-Hooks und Validierungsskripte macht.

Zum Beispiel könnten Sie es in einer CI/CD-Pipeline verwenden, um zu überprüfen, ob bestimmte Dateien nicht verändert wurden, oder um sicherzustellen, dass Konfigurationsänderungen bestimmten Mustern folgen, bevor Commits erlaubt werden.

git diff-files zeigt Änderungen zwischen Dateien im Arbeitsverzeichnis und dem Index an:

# Unterschiede für spezifische Dateien überprüfen
git diff-files --patch config.txt

Diese spezialisierten Befehle sind besonders nützlich für:

  • Erstellen benutzerdefinierter Git-Workflows und Skripte
  • Fehlerbehebung bei Problemen mit den internen Abläufen von Git
  • Durchführen gezielter Analysen des Repository-Zustands
  • Erstellen von Automatisierungstools, die mit Git interagieren

Analysieren der Code-Historie

Einer der mächtigsten Anwendungen von git diff ist die Analyse, wie sich der Code im Laufe der Zeit entwickelt hat, was entscheidend für die Fehlersuche oder das Verständnis der Entwicklung von Funktionen sein kann.

Lassen Sie uns einen bestimmten Commit mithilfe der speziellen ^! Notation untersuchen:

# Holen Sie den Hash unseres fortgeschrittenen Analytics-Commits
ANALYTICS_COMMIT=$(git log --oneline | grep "advanced analysis" | cut -d ' ' -f 1)

# Zeigen Sie nur die Änderungen, die in diesem spezifischen Commit vorgenommen wurden
git diff $ANALYTICS_COMMIT^!

Die ^! Syntax ist eine Abkürzung für den Vergleich eines Commits mit seinem Elternteil, der genau zeigt, was sich in diesem Commit geändert hat.

Um zu verfolgen, wie sich eine bestimmte Datei im Laufe der Zeit entwickelt hat:

# Analysieren Sie, wie sich analysis.py in den letzten 3 Commits geändert hat
git log -p -3 analysis.py

Beim Suchen nach einem Fehler können Sie git diff mit git bisect verwenden:

# Fügen Sie einen Fehler hinzu, um eine Regression zu simulieren
echo "import pandas as pd
import numpy as np

def load_data(filename):
   # Fehler: versehentliches Zurückgeben von None anstelle der Daten
   pd.read_csv(filename)
   return None

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

git add analysis.py
git commit -m "Update analysis.py with a hidden bug"

# Verwenden Sie nun git bisect, um herauszufinden, wann der Fehler eingeführt wurde
git bisect start
git bisect bad  # Mark current commit as containing the bug
git bisect good main  # Mark the main branch as working correctly

# Git wird Commits für Sie auschecken, um sie zu testen
# Sobald gefunden, können Sie die genaue Änderung untersuchen, die den Fehler eingeführt hat
git diff HEAD^!

Git bisect ist ein leistungsstolles Debugging-Tool, das eine binäre Suche durch Ihre Commit-Historie durchführt, um herauszufinden, welcher Commit einen Fehler eingeführt hat. In Kombination mit git diff schafft es einen effizienten Workflow:

1. Starten Sie den Bisektionsprozess mit git bisect start

2. Markieren Sie den aktuellen Commit als schlecht (enthält den Fehler) mit git bisect bad

3. Markieren Sie einen bekannten guten Commit (in dem der Fehler nicht vorhanden ist) mit git bisect good <Commit-Hash>

4. Git überprüft automatisch einen Commit in der Mitte Ihrer Historie, den Sie testen können.

5. Nachdem Sie den aktuellen Commit getestet haben, teilen Sie Git das Ergebnis mit:

  • Wenn der Fehler in diesem Commit vorhanden ist: git bisect bad
  • Wenn der Fehler in diesem Commit nicht vorhanden ist: git bisect good

6. Git wird weiterhin unterschiedliche Commits basierend auf Ihrem Feedback (nach jedem git bisect bad/good Befehl) überprüfen und die Suche jedes Mal eingrenzen. Wiederholen Sie den Test- und Markierungsprozess, bis Git den ersten fehlerhaften Commit identifiziert.

7. Sobald Git den problematischen Commit findet, wird eine Nachricht angezeigt, die angibt, welcher Commit den Fehler eingeführt hat.

8. Untersuchen Sie genau, was im identifizierten Commit geändert wurde mit: git diff HEAD^!

9. Dieser Befehl zeigt Ihnen genau, welcher Code im Commit, der den Fehler eingeführt hat, geändert wurde, sodass Sie Ihre Debugging-Bemühungen auf diese spezifischen Änderungen konzentrieren können.

10. Verlassen Sie jederzeit die Bisektion mit: git bisect reset Dadurch gelangen Sie zurück in den Branch, in dem Sie sich vor Beginn des Bisektionsprozesses befanden.

11. Sie können auch den Bisektionsprozess automatisieren mit: git bisect run <Testskript> Wobei ein Befehl verwendet wird, der für gute Commits 0 und für schlechte Commits eine andere Zahl zurückgibt.

Dieser Workflow reduziert die Debugging-Zeit dramatisch, insbesondere in großen Codebasen mit vielen Commits zwischen funktionierenden und fehlerhaften Zuständen.

Diese Techniken zur Analyse des Verlaufs sind von unschätzbarem Wert für:

  • Herausfinden, wann und warum ein Fehler eingeführt wurde
  • Das Verständnis der Evolution eines Features oder einer Komponente
  • Überprüfung von Änderungen für Sicherheitsprüfungen
  • Dokumentation des Entscheidungsprozesses hinter Codeänderungen

Durch die Beherrschung dieser fortgeschrittenen Git Diff-Anwendungen werden Sie in der Lage sein, die Historie Ihres Projekts präzise zu navigieren, Probleme effizienter zu debuggen und tiefere Einblicke in die Evolution Ihres Codebestands zu gewinnen.

Git Diff-Befehl Referenz

Git diff bietet eine Vielzahl von Optionen zur Anpassung der Ausgabe und des Verhaltens für spezifische Situationen. Hier ist eine umfassende Referenz der am häufigsten verwendeten Parameter, um Ihre Differentialanalyse zu verbessern:

Grundlegende Vergleichsoptionen

  • git diff – Vergleichen des Arbeitsverzeichnisses mit dem Staging-Bereich
  • git diff --staged (oder --cached) – Vergleichen des Staging-Bereichs mit dem letzten Commit
  • git diff HEAD – Vergleichen des Arbeitsverzeichnisses mit dem letzten Commit
  • git diff <commit> – Vergleichen des Arbeitsverzeichnisses mit einem bestimmten Commit
  • git diff <commit1> <commit2> – Vergleicht zwei bestimmte Commits
  • git diff <branch1> <branch2> – Vergleicht zwei Branches

Pfadbegrenzung

  • git diff -- <path> – Begrenzt den Vergleich auf eine bestimmte Datei oder Verzeichnis
  • git diff --stat – Zeigt eine Zusammenfassung der Änderungen (geänderte Dateien, Einfügungen, Löschungen), eine sehr nützliche Option für große Unterschiede
  • git diff --name-only – Zeigt nur die Namen der geänderten Dateien
  • git diff --name-status – Zeigt Namen und Status (hinzugefügt, modifiziert, gelöscht) der geänderten Dateien an

Display control

  • git diff -w (oder –ignore-all-space) – Ignoriere Leerzeichenänderungen
  • git diff --ignore-space-change – Ignoriere Änderungen in der Menge von Leerzeichen
  • git diff --color-words – Zeige wortbasierte Unterschiede mit Farben an
  • git diff --word-diff – Zeigen Sie Wortebenenunterschiede in einem anderen Format an
  • git diff -U<n> – Zeigen Sie n Zeilen des Kontexts an (Standardwert ist 3)
  • git diff --no-prefix – Zeigen Sie keine a/ und b/ Präfixe im Diff-Ausgabean

Content-Filterung

  • git diff --binary – Zeigen Sie Änderungen an Binärdateien an
  • git diff -S<string> – Suchen Sie nach Änderungen, die die angegebene Zeichenfolge hinzufügen oder entfernen
  • git diff -G<regex> – Suchen Sie nach Änderungen, die dem angegebenen Regex-Muster entsprechen
  • git diff --pickaxe-all – Bei Verwendung von -S oder -G alle Änderungen in der Datei anzeigen, nicht nur passende

Formatierungsoptionen

  • git diff --patch-with-stat – Patch und Statistik-Zusammenfassung anzeigen
  • git diff --compact-summary – Statistik-Zusammenfassung in kompakter Form anzeigen
  • git diff --numstat – Statistiken in einem maschinenfreundlichen Format anzeigen
  • git diff --summary – Erstellungs-/Lösch-Zusammenfassung anzeigen

Diese Optionen können kombiniert werden, um leistungsstarke, gezielte Vergleiche zu erstellen. Zum Beispiel, um Änderungen auf Wortebene in einer bestimmten Datei zu sehen, während Leerzeichen ignoriert werden:

git diff --color-words -w -- analysis.py

Oder um alle Stellen zu finden, an denen eine bestimmte Funktion hinzugefügt oder entfernt wurde:

git diff -S"def perform_advanced_analysis" main feature/advanced-analytics

Das Verständnis dieser Optionen hilft Ihnen, sich durch Rauschen zu schneiden und sich genau auf die relevanten Änderungen zu konzentrieren, was Ihre Codeüberprüfungs- und Analyseworkflows effizienter macht. Egal, ob Sie nach Fehlern suchen, sich auf einen Pull-Request vorbereiten oder einfach nur verstehen möchten, was sich geändert hat, die richtige git diff-Option kann Ihre Aufgabe erheblich erleichtern.

Abschluss

In diesem Artikel haben wir git diff als vielseitigen Befehl zur Anzeige von Code-Änderungen erkundet. Wir haben das Vergleichen von Arbeitsdateien mit gestageten Änderungen, das Untersuchen von Unterschieden zwischen Branches und Commits sowie die Verwendung spezialisierter Befehle für tiefere Einblicke behandelt. Die Integration von git diff in Ihren Workflow hilft dabei, sauberere Commits zu erstellen, Probleme frühzeitig zu erkennen und bessere Code-Reviews zu ermöglichen.

Ob Sie alleine arbeiten oder im Team, die Beherrschung von git diff hebt Sie davon ab, einfach nur Code zu schreiben, hin zu einem Verständnis, wie sich Ihre Codebasis im Laufe der Zeit entwickelt.

Um Ihr Git-Wissen weiter auszubauen, werfen Sie einen Blick auf diese wertvollen Ressourcen:

Diese Ressourcen helfen Ihnen, auf dem aufzubauen, was Sie über git diff gelernt haben, und Ihre Beherrschung der Versionskontrolle auf die nächste Stufe zu heben.

Source:
https://www.datacamp.com/tutorial/git-diff-guide