Tiefer Einblick in Git Diff

Einführung

Willkommen, Git-Entdecker! Heute werden wir uns einer der mächtigsten und am häufigsten verwendeten Funktionen von Git widmen: dem Befehl git diff. Wenn Sie sich jemals gefragt haben, welche genauen Änderungen Sie an Ihren Dateien vorgenommen haben, oder wenn Sie verschiedene Versionen Ihres Codes vergleichen mussten, dann ist git diff das Tool, das Sie gesucht haben.

Der Befehl git diff ist wie ein Mikroskop für Ihre Codeänderungen. Es ermöglicht Ihnen, die genauen Unterschiede zwischen verschiedenen Zuständen Ihres Repositorys zu sehen, sei es Änderungen in Ihrem Arbeitsverzeichnis, in Ihrer Staging-Area, zwischen Commits oder sogar zwischen Branches.

In diesem Lab werden wir untersuchen, wie man:

1. Das Arbeitsverzeichnis mit der Staging-Area vergleicht
2. Die Staging-Area mit dem letzten Commit vergleicht
3. Verschiedene Branches vergleicht
4. Spezifische Dateien vergleicht
5. Externe Diff-Tools für einen visuelleren Vergleich verwendet

Am Ende dieses Labs werden Sie ein git diff-Experte sein und Ihre Änderungen präzise und zuversichtlich untersuchen können. Diese Fähigkeit ist entscheidend für die Überprüfung Ihrer Arbeit, die Vorbereitung von Commits und die effektive Zusammenarbeit mit anderen.

Lassen Sie uns starten und die Macht von git diff erkunden!

Skills Graph

Einrichten Ihres Arbeitsbereichs

Bevor wir mit dem Vergleichen beginnen, richten wir einen Arbeitsbereich mit einigen Dateien und Commits ein, die wir vergleichen können. Wir werden ein neues Verzeichnis erstellen, ein Git-Repository initialisieren und einige Dateien mit mehreren Commits hinzufügen.

Öffnen Sie Ihr Terminal und geben Sie diese Befehle ein:

cd ~/project
mkdir git-diff-lab
cd git-diff-lab
git init

Jetzt erstellen wir einige Dateien und machen eine Reihe von Commits, indem wir die folgenden Befehle kopieren und einfügen:

echo "## Git Diff Lab" > README.md
git add README.md
git commit -m "Initial commit"

echo "function greet(name) {" > greet.js
echo "  return 'Hello, ' + name + '!';" >> greet.js
echo "}" >> greet.js
git add greet.js
git commit -m "Add greet function"

echo "const numbers = [1, 2, 3, 4, 5];" > numbers.js
echo "console.log(numbers);" >> numbers.js
git add numbers.js
git commit -m "Add numbers array"

Lassen Sie uns analysieren, was wir gerade getan haben:

1. Wir haben eine README-Datei erstellt und unseren ersten Commit gemacht.
2. Wir haben eine JavaScript-Datei mit einer Begrüßungsfunktion erstellt und sie committet.
3. Wir haben eine weitere JavaScript-Datei mit einem Zahlenarray erstellt und sie committet.

Jetzt haben wir ein Repository mit etwas Historie, das wir erkunden können!

Vergleich des Arbeitsverzeichnisses und der Staging-Area

Die grundlegendste Verwendung von git diff besteht darin, die Änderungen in Ihrem Arbeitsverzeichnis zu sehen, die noch nicht in die Staging-Area übernommen wurden. Lassen Sie uns dies untersuchen.

Zuerst machen wir einige Änderungen an unserer greet.js-Datei:

echo "function farewell(name) {" >> greet.js
echo "  return 'Goodbye, ' + name + '!';" >> greet.js
echo "}" >> greet.js

Jetzt verwenden wir git diff, um diese Änderungen anzuzeigen:

git diff

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

diff --git a/greet.js b/greet.js
index 95f5574..a3641f6 100644
--- a/greet.js
+++ b/greet.js
@@ -1,3 +1,7 @@
 function greet(name) {
   return 'Hello, ' + name + '!';
 }
+function farewell(name) {
+  return 'Goodbye, ' + name + '!';
+}

Lassen Sie uns diese Ausgabe analysieren:

• Die erste Zeile zeigt, welche Dateien verglichen werden.
• Die Zeilen mit +++ und --- zeigen, welche Dateiversionen verglichen werden (a/ ist die ursprüngliche, b/ ist die neue Version).
• Die @@-Zeile gibt Informationen darüber, wo in der Datei die Änderungen vorgenommen wurden.
• Zeilen, die mit + beginnen, sind Hinzufügungen, während - Entfernungen anzeigen würde.

Dieser Diff zeigt uns, dass wir drei neue Zeilen zu greet.js hinzugefügt haben.

Drücken Sie q, um die Diff-Ansicht zu verlassen.

Jetzt nehmen wir diese Änderungen in die Staging-Area auf:

git add greet.js

Wenn Sie git diff erneut ausführen, sehen Sie keine Ausgabe. Dies liegt daran, dass git diff standardmäßig nur nicht in die Staging-Area übernommene Änderungen anzeigt. Um die in die Staging-Area übernommenen Änderungen anzuzeigen, müssen Sie git diff --staged verwenden, was wir im nächsten Schritt behandeln werden.

Denken Sie daran, dass git diff ohne Argumente Ihr Arbeitsverzeichnis mit Ihrer Staging-Area vergleicht. Es ist eine gute Möglichkeit, Ihre Änderungen zu überprüfen, bevor Sie sie in die Staging-Area übernehmen.

Vergleich der Staging-Area und des letzten Commits

Nachdem wir unsere Änderungen in die Staging-Area übernommen haben, lernen wir nun, wie man die Staging-Area mit dem letzten Commit vergleicht. Dies ist nützlich, um zu überprüfen, welche Änderungen in Ihrem nächsten Commit enthalten sein werden.

Um die Unterschiede zwischen der Staging-Area und dem letzten Commit anzuzeigen, verwenden Sie:

git diff --staged

Sie sollten eine Ausgabe ähnlich der aus dem vorherigen Schritt sehen, die die Hinzufügung der farewell-Funktion anzeigt.

Dieser Befehl ist besonders nützlich, wenn Sie im Laufe der Zeit Änderungen in die Staging-Area übernommen haben und alles überprüfen möchten, was in Ihrem nächsten Commit enthalten sein wird.

Lassen Sie uns eine weitere Änderung vornehmen und in die Staging-Area übernehmen, um zu sehen, wie dies funktioniert:

echo "console.log(greet('World'));" >> greet.js
git add greet.js

Jetzt, wenn Sie git diff --staged ausführen, sehen Sie sowohl die farewell-Funktion als auch die neue console.log-Zeile.

Denken Sie daran, dass git diff --staged (oder git diff --cached, was synonym ist) Ihnen zeigt, welche Änderungen derzeit in Ihrer Staging-Area im Vergleich zum letzten Commit vorhanden sind. Es ist eine gute Möglichkeit, Ihre in die Staging-Area übernommenen Änderungen vor dem Committen noch einmal zu überprüfen.

Vergleich von Branches

git diff ist auch nützlich, um verschiedene Branches zu vergleichen. Dies ist besonders hilfreich, wenn Sie an einem Feature-Branch arbeiten und sehen möchten, wie er sich vom Hauptbranch (main branch) unterscheidet.

Lassen Sie uns einen neuen Branch erstellen und einige Änderungen vornehmen:

git checkout -b feature-branch
echo "const PI = 3.14159;" >> numbers.js
git add numbers.js
git commit -m "Add PI constant"

Jetzt vergleichen wir diesen Branch mit dem Hauptbranch:

git diff master feature-branch

Sie sollten eine Ausgabe sehen, die die Hinzufügung der PI-Konstante zu numbers.js anzeigt.

Dieser Befehl zeigt die Unterschiede zwischen den Spitzen der master- und feature-branch-Branches. Er sagt: "Zeige mir, welche Änderungen in feature-branch vorhanden sind, die nicht in master sind."

Sie können auch Ihren aktuellen Branch mit einem anderen Branch vergleichen, indem Sie den Namen des ersten Branches weglassen:

git diff master

Dies vergleicht Ihren aktuellen Branch (feature-branch) mit master.

Denken Sie daran, wenn Sie Branches vergleichen:

• Änderungen im ersten Branch (oder im aktuellen Branch, wenn dieser weggelassen wird), die nicht im zweiten Branch vorhanden sind, werden als Entfernungen (mit einem -) angezeigt.
• Änderungen im zweiten Branch, die nicht im ersten Branch vorhanden sind, werden als Hinzufügungen (mit einem +) angezeigt.

Diese Funktion ist unglaublich nützlich, wenn Sie vorbereiten, Branches zusammenzuführen (merge), oder wenn Sie sehen möchten, welche Änderungen ein Feature-Branch bringt.

Vergleich spezifischer Dateien

Manchmal möchten Sie nur die Änderungen für eine bestimmte Datei oder eine Gruppe von Dateien sehen. Mit git diff können Sie dies einfach tun.

Lassen Sie uns Änderungen an mehreren Dateien vornehmen:

echo "function multiply(a, b) { return a * b; }" >> greet.js
echo "const doubledNumbers = numbers.map(n => n * 2);" >> numbers.js

Jetzt, wenn wir nur die Änderungen in greet.js sehen möchten, können wir folgendes verwenden:

git diff greet.js

Dies zeigt nur die an greet.js vorgenommenen Änderungen.

Sie können auch eine bestimmte Datei zwischen Branches vergleichen:

git diff master feature-branch -- numbers.js

Dies zeigt die Unterschiede in numbers.js zwischen den master- und feature-branch-Branches.

Das -- im obigen Befehl wird verwendet, um den Dateipfad von den Branch-Namen zu trennen. Es ist nicht immer erforderlich, aber es ist eine gute Gewohnheit, es zu verwenden, um Mehrdeutigkeiten zu vermeiden, insbesondere wenn Ihre Dateinamen für Branch-Namen verwechselt werden könnten.

Denken Sie daran, dass Sie Dateipfade mit jedem der von uns gelernten Diff-Befehle verwenden können. Dies ist besonders in größeren Projekten nützlich, in denen Sie möglicherweise Änderungen an vielen Dateien vorgenommen haben, aber nur auf einige konzentrieren möchten.

Verwendung externer Diff-Tools

Obwohl Git's integrierter Diff sehr leistungsfähig ist, möchten Sie manchmal möglicherweise eine visuellere Darstellung Ihrer Änderungen haben. Viele Entwickler verwenden hierfür externe Diff-Tools.

Ein beliebtes Tool ist vimdiff. Konfigurieren wir Git so, dass es vimdiff verwendet:

git config --global diff.tool vimdiff
git config --global difftool.prompt false

Jetzt können Sie anstelle von git diff git difftool verwenden:

git difftool

Dadurch wird jede geänderte Datei in vimdiff geöffnet. Sie können zwischen den Dateien navigieren, indem Sie :n für die nächste und :prev für die vorherige Datei verwenden. Um vimdiff zu beenden, verwenden Sie :qa!.

Es gibt viele andere verfügbare Diff-Tools, wie z. B. Beyond Compare, KDiff3 oder P4Merge. Die Wahl des Tools hängt oft von persönlichen Vorlieben und Ihrem Betriebssystem ab.

Denken Sie daran, dass visuelle Diff-Tools, insbesondere bei größeren Änderungen, sehr hilfreich sein können, aber nicht immer erforderlich sind. Viele Entwickler werden mit der Standardausgabe von git diff vertraut und bevorzugen deren Geschwindigkeit und Einfachheit für den täglichen Gebrauch.

Zusammenfassung

Herzlichen Glückwunsch, Diff-Detektiv! Sie haben gerade eine tiefe Tauchfahrt in die Welt von git diff absolviert. Lassen Sie uns die wichtigsten Konzepte, die wir behandelt haben, zusammenfassen:

1. Vergleich des Arbeitsverzeichnisses (Working Directory) und der Staging-Area: Sie haben gelernt, wie Sie nicht in die Staging-Area übernommene Änderungen in Ihrem Arbeitsverzeichnis anzeigen können.
2. Vergleich der Staging-Area und des letzten Commits: Sie haben herausgefunden, wie Sie die in die Staging-Area übernommenen Änderungen vor dem Committen überprüfen können.
3. Vergleich von Branches: Sie haben gesehen, wie Sie verschiedene Branches vergleichen können, um zu sehen, wie sie voneinander abgewichen sind.
4. Vergleich spezifischer Dateien: Sie haben gelernt, wie Sie Ihren Diff auf bestimmte Dateien von Interesse fokussieren können.
5. Verwendung externer Diff-Tools: Sie haben untersucht, wie Sie visuelle Diff-Tools verwenden können, um Ihre Änderungen aus einer anderen Perspektive zu betrachten.

Der git diff-Befehl ist ein leistungsstarkes Werkzeug in Ihrem Git-Werkzeugkasten. Er ermöglicht es Ihnen, Änderungen präzise zu untersuchen, sei es, dass Sie sich auf einen Commit vorbereiten, die Arbeit eines Kollegen überprüfen oder versuchen, die Geschichte Ihres Projekts zu verstehen.

Denken Sie daran, dass es Übung braucht, um mit git diff vertraut zu werden. Seien Sie nicht entmutigt, wenn die Ausgabe zunächst kryptisch erscheint - mit der Zeit werden Sie in der Lage sein, Diffs schnell und effizient zu lesen.

Wenn Sie Ihre Git-Reise fortsetzen, erkunden Sie weiterhin die verschiedenen Optionen und Anwendungsfälle für git diff. Es ist ein vielseitiger Befehl, der mit vielen anderen Git-Funktionen kombiniert werden kann, um Ihnen tiefe Einblicke in die Änderungen Ihres Projekts zu geben.

Viel Spaß beim Diffen, und mögen Ihre Code-Änderungen immer klar und beabsichtigt sein!