So überprüfen Sie, ob eine Git-Commit-Nachricht bestimmten Text enthält

Einführung

In diesem Lab lernen Sie, wie Sie effizient in Ihrem Git-Commit-Verlauf nach bestimmten Texten in Commit-Nachrichten suchen können. Wir werden den Befehl git log --grep untersuchen, um Commits anhand von Schlüsselwörtern zu filtern. Dadurch können Sie schnell relevante Änderungen in einem großen Projekt finden.

Sie werden auch lernen, wie Sie git show verwenden, um die Details eines bestimmten Commits zu untersuchen, der durch Ihre Suche gefunden wurde, und wie Sie mit git log --grep casesensitive (Groß- und Kleinschreibung berücksichtigende) Suchen durchführen, um Ihre Ergebnisse zu verfeinern. Am Ende dieses Labs können Sie diese Git-Befehle beherrschen, um sich durch den Verlauf Ihres Projekts zu navigieren und ihn zu verstehen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/BasicOperationsGroup(["Basic Operations"]) git(("Git")) -.-> git/BranchManagementGroup(["Branch Management"]) git/BasicOperationsGroup -.-> git/add("Stage Files") git/BasicOperationsGroup -.-> git/commit("Create Commit") git/BasicOperationsGroup -.-> git/diff("Compare Changes") git/BranchManagementGroup -.-> git/log("Show Commits") subgraph Lab Skills git/add -.-> lab-560067{{"So überprüfen Sie, ob eine Git-Commit-Nachricht bestimmten Text enthält"}} git/commit -.-> lab-560067{{"So überprüfen Sie, ob eine Git-Commit-Nachricht bestimmten Text enthält"}} git/diff -.-> lab-560067{{"So überprüfen Sie, ob eine Git-Commit-Nachricht bestimmten Text enthält"}} git/log -.-> lab-560067{{"So überprüfen Sie, ob eine Git-Commit-Nachricht bestimmten Text enthält"}} end

Suchen mit `git log --grep`

In diesem Schritt lernen wir, wie wir unseren Commit-Verlauf mit git log --grep durchsuchen können. Dies ist unglaublich nützlich, wenn Sie viele Commits haben und einen bestimmten Commit anhand seiner Nachricht finden müssen.

Zunächst erstellen wir noch ein paar weitere Commits, damit wir etwas zu durchsuchen haben. Wir fügen unserer message.txt-Datei einige weitere Nachrichten hinzu.

echo "Adding a second message." >> message.txt
git add message.txt
git commit -m "Add second message"

Sie sollten eine Ausgabe ähnlich dieser sehen:

[master <commit-id>] Add second message
 1 file changed, 1 insertion(+)

Jetzt fügen wir noch eine weitere Nachricht hinzu und committen sie:

echo "Adding a third message about the future." >> message.txt
git add message.txt
git commit -m "Add third message about future"

Sie sollten eine Ausgabe ähnlich dieser sehen:

[master <commit-id>] Add third message about future
 1 file changed, 1 insertion(+)

Jetzt haben wir drei Commits in unserem Verlauf. Verwenden wir git log, um sie alle anzuzeigen:

git log --oneline

Sie sollten etwas wie Folgendes sehen (die Commit-IDs werden unterschiedlich sein):

<commit-id> Add third message about future
<commit-id> Add second message
<commit-id> Send a message to the future

Nehmen wir an, wir möchten den Commit finden, der "future" (Zukunft) erwähnt. Wir können hierfür git log --grep verwenden:

git log --grep "future" --oneline

Dieser Befehl teilt Git mit, uns nur die Commits anzuzeigen, deren Nachrichten das Wort "future" enthalten. Sie sollten eine Ausgabe ähnlich dieser sehen:

<commit-id> Add third message about future
<commit-id> Send a message to the future

Beachten Sie, dass nur die Commits angezeigt werden, deren Nachrichten "future" enthalten. Dies ist eine leistungsstarke Methode, um Ihren Commit-Verlauf zu filtern und schnell das zu finden, wonach Sie suchen.

Die Option --grep ermöglicht es Ihnen, Commit-Nachrichten nach einem bestimmten Muster zu durchsuchen. Dies ist sehr hilfreich, wenn Sie ein großes Projekt mit vielen Commits haben und einen Commit finden müssen, der sich auf ein bestimmtes Feature oder eine Fehlerbehebung bezieht.

Anzeigen eines bestimmten Commits mit `git show`

In diesem Schritt lernen wir, wie wir die Details eines bestimmten Commits mit dem Befehl git show anzeigen können. Mit diesem Befehl können Sie genau sehen, welche Änderungen in einem bestimmten Commit vorgenommen wurden.

Zunächst holen wir uns die Commit-ID des ersten Commits, den wir gemacht haben. Wir können erneut git log --oneline verwenden, um die Liste der Commits anzuzeigen:

git log --oneline

Schauen Sie sich die Ausgabe an und finden Sie die Commit-Nachricht "Send a message to the future". Kopieren Sie die kurze Commit-ID (die Zeichenkette aus Buchstaben und Zahlen vor der Nachricht). Sie sollte in etwa so aussehen wie a1b2c3d.

Verwenden Sie nun den Befehl git show gefolgt von der Commit-ID, die Sie kopiert haben. Ersetzen Sie <commit-id> durch die tatsächliche ID, die Sie kopiert haben:

git show <commit-id>

Sie sollten detaillierte Informationen zu diesem bestimmten Commit sehen, darunter:

Die Commit-ID, der Autor, das Datum und die Nachricht.
Die Änderungen, die in diesem Commit vorgenommen wurden. Bei unserem ersten Commit wird angezeigt, dass die Datei message.txt erstellt wurde und die Zeile "Hello, Future Me" hinzugefügt wurde.

Die Ausgabe sollte in etwa so aussehen (die Commit-ID und das Datum werden unterschiedlich sein):

commit <commit-id>
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

diff --git a/message.txt b/message.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/message.txt
@@ -0,0 +1 @@
+Hello, Future Me

Der Befehl git show ist unglaublich nützlich, um die Geschichte Ihres Projekts zu verstehen. Sie können ihn verwenden, um genau zu sehen, welche Änderungen in jedem Commit vorgenommen wurden, was für das Debugging oder das Verständnis, wie ein Feature implementiert wurde, unerlässlich ist.

Sie können auch git show ohne eine Commit-ID verwenden, um die Details des neuesten Commits anzuzeigen. Probieren Sie es aus:

git show

Dies wird Ihnen die Details des Commits "Add third message about future" anzeigen.

Denken Sie daran, dass Sie q drücken können, um die git show-Ansicht zu verlassen und zur Befehlszeile zurückzukehren.

Testen der Groß- und Kleinschreibungssensitivität bei der Suche

In diesem Schritt werden wir untersuchen, wie git log --grep die Groß- und Kleinschreibung behandelt. Standardmäßig ist die Suche Groß- und Kleinschreibungssensitiv, was bedeutet, dass "future" (klein) von "Future" (groß) unterschieden wird.

Versuchen wir, nach "Future" (mit großem F) mit git log --grep zu suchen:

git log --grep "Future" --oneline

Basierend auf unseren vorherigen Commits enthält nur die erste Commit-Nachricht "Send a message to the Future" "Future" mit großem F. Die Ausgabe sollte in etwa so aussehen:

<commit-id> Send a message to the future

Beachten Sie, dass der Commit "Add third message about future" nicht enthalten ist, da er ein kleines "f" verwendet.

Jetzt versuchen wir erneut, nach "future" (mit kleinem f) zu suchen:

git log --grep "future" --oneline

Diesmal sollten beide Commits, die "future" enthalten (unabhängig von der Groß- oder Kleinschreibung in der ursprünglichen Nachricht), angezeigt werden:

<commit-id> Add third message about future
<commit-id> Send a message to the future

Warten Sie, das stimmt nicht! Im vorherigen Schritt wurden beide Commits angezeigt, als wir nach "future" suchten. Dies liegt daran, dass das Standardverhalten von git log --grep auf einigen Systemen oder Konfigurationen Groß- und Kleinschreibung-unabhängig ist.

Um eine Groß- und Kleinschreibungssensitive Suche sicherzustellen, können Sie die Option --i (oder --ignore-case) verwenden. Versuchen wir, nach "Future" Groß- und Kleinschreibungssensitiv zu suchen:

git log --grep "Future" --oneline --i

Dieser Befehl teilt Git mit, die Groß- und Kleinschreibung bei der Suche zu ignorieren. Jetzt sollten beide Commits, die "future" oder "Future" enthalten, angezeigt werden:

<commit-id> Add third message about future
<commit-id> Send a message to the future

Dies zeigt, dass sich das Standardverhalten möglicherweise unterscheidet, aber die explizite Verwendung der Option --i die Suche Groß- und Kleinschreibung-unabhängig macht. Wenn Sie eine streng Groß- und Kleinschreibungssensitive Suche benötigen, verlassen Sie sich normalerweise auf das Standardverhalten ohne --i. Angesichts der möglichen Unterschiede ist es jedoch eine gute Praxis, sich der Option --i für Groß- und Kleinschreibung-unabhängige Suchen bewusst zu sein.

Das Verständnis der Groß- und Kleinschreibungssensitivität bei der Suche ist wichtig, um Commits genau zu finden, insbesondere in Projekten, in denen die Konventionen für Commit-Nachrichten variieren können.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man effektiv durch die Git-Commit-Historie sucht. Wir haben begonnen, indem wir git log --grep verwendet haben, um Commits anhand bestimmter Texte in ihren Nachrichten zu filtern. Dieser leistungsstarke Befehl ermöglicht es uns, schnell relevante Commits zu finden, insbesondere in Projekten mit umfangreichen Commit-Historien. Wir haben dies geübt, indem wir mehrere Commits erstellt und dann --grep verwendet haben, um diejenigen zu finden, die das Wort "future" enthalten.

Wir haben auch untersucht, wie man die Details eines bestimmten Commits mit git show anzeigt und wie man Groß- und Kleinschreibungssensitive Suchen mit git log --grep durchführt. Diese Techniken bieten essentielle Werkzeuge, um sich in der Entwicklung eines Git-Repositorys zurechtzufinden und sie zu verstehen.