Git-Geschichts- und Log-Verwaltung

Einführung

Willkommen, Git-Zeitreisender! Heute gehen wir auf eine spannende Reise durch die Geschichte Ihrer Git-Projekte. Eine der leistungsstärksten Funktionen von Git ist seine Fähigkeit, die Geschichte Ihres Projekts zu verfolgen und anzuzeigen. Diese Geschichte ist nicht nur eine Aufzeichnung dessen, was passiert ist, sondern ein leistungsstarkes Werkzeug zum Verstehen, Debuggen und Verbessern Ihres Projekts.

In diesem Lab werden wir den Befehl git log erkunden, der Ihr Fenster in Git's historische Aufzeichnungen ist. Wir beginnen mit der grundlegenden Verwendung und tauchen dann in fortgeschrittenere Techniken ein, wie die Formatierung der Log-Ausgabe, die Filterung von Logs nach Datum, die Suche nach bestimmten Änderungen und sogar die Generierung von Statistiken aus der Projektgeschichte.

Am Ende dieses Labs können Sie wie ein Profi durch die Geschichte Ihres Projekts navigieren und wertvolle Erkenntnisse und Informationen gewinnen, die Sie zu einem effektiveren Entwickler machen. Egal, ob Sie einen Fehler suchen, Änderungen überprüfen oder einfach verstehen möchten, wie sich Ihr Projekt entwickelt hat, die hier erlernten Fähigkeiten werden unschätzbar sein.

Lassen Sie uns in unsere Git-Zeitreise-Maschine steigen und die Vergangenheit erkunden!

Skills Graph

Einrichten Ihres Arbeitsbereichs

Bevor wir uns mit den historischen Funktionen von Git befassen, richten wir einen Arbeitsbereich mit etwas Commit-Geschichte ein, den wir erkunden können. Wir werden ein neues Verzeichnis erstellen, ein Git-Repository initialisieren und einige Commits hinzufügen.

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

cd ~/project
mkdir git-history-lab
cd git-history-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 History Lab" > README.md
git add README.md
git commit -m "Initial commit"

echo "function hello() {" > script.js
echo "  console.log('Hello, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add hello function"

echo "function goodbye() {" >> script.js
echo "  console.log('Goodbye, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add goodbye function"

echo "This is a test file" > test.txt
git add test.txt
git commit -m "Add test file"

echo "hello();" >> script.js
echo "goodbye();" >> script.js
git add script.js
git commit -m "Call hello and goodbye functions"

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 "hello"-Funktion erstellt und sie committet.
3. Wir haben eine "goodbye"-Funktion zur gleichen Datei hinzugefügt und diese Änderung committet.
4. Wir haben eine Testdatei hinzugefügt und sie committet.
5. Schließlich haben wir unser Skript so geändert, dass es beide Funktionen aufruft, und die Änderungen committet.

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

Grundlegende Verwendung von git log

Jetzt, da wir etwas Commit-Geschichte haben, lassen Sie uns die grundlegende Verwendung von git log erkunden.

Um die Commit-Geschichte Ihres Projekts anzuzeigen, führen Sie einfach aus:

git log

Sie sollten eine Ausgabe ähnlich dieser sehen:

commit 1234567890abcdef1234567890abcdef12345678 (HEAD -> main)
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 10:00:00 2023 +0000

    Call hello and goodbye functions

commit 2345678901abcdef2345678901abcdef23456789
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 09:45:00 2023 +0000

    Add test file

...

Jeder Eintrag im Log zeigt:

• Den vollständigen Commit-Hash (eine eindeutige Kennung für den Commit)
• Den Autor des Commits
• Datum und Uhrzeit des Commits
• Die Commit-Nachricht

Standardmäßig zeigt git log alle Commits an, beginnend mit dem neuesten. Es zeigt sie in umgekehrter chronologischer Reihenfolge (neueste zuerst) an.

Wenn die Ausgabe lang ist, zeigt Git sie in einem Pager (normalerweise less) an. Sie können mit den Pfeiltasten navigieren und q drücken, um zu beenden.

Um eine kompaktere Version des Logs anzuzeigen, können Sie verwenden:

git log --oneline

Dies zeigt jeden Commit in einer einzigen Zeile an, nur mit dem kurzen Commit-Hash und der Commit-Nachricht.

Denken Sie daran, dass git log Ihr Fenster in die Projektgeschichte ist. Es ist ein ausgezeichneter Ausgangspunkt, um zu verstehen, welche Änderungen gemacht wurden, wann und von wem.

Formatierung der Log-Ausgabe

Git bietet leistungsstarke Optionen zur Formatierung der Log-Ausgabe, um genau die Informationen anzuzeigen, die Sie benötigen. Lassen Sie uns einige dieser Optionen erkunden.

Um die Dateien anzuzeigen, die in jedem Commit geändert wurden, verwenden Sie die Option --stat:

git log --stat

Dies zeigt Ihnen, welche Dateien in jedem Commit geändert wurden und wie viele Zeilen hinzugefügt oder entfernt wurden.

Für eine detailliertere Ansicht der Änderungen verwenden Sie die Option -p:

git log -p

Dies zeigt den eigentlichen Patch (die hinzugefügten und entfernten Zeilen) für jeden Commit an. Es ist sehr nützlich, um Änderungen im Detail zu überprüfen.

Sie können auch benutzerdefinierte Formate mit der Option --pretty erstellen. Beispielsweise:

git log --pretty=format:"%h - %an, %ar : %s"

Dies zeigt:

• %h: Abgekürzter Commit-Hash
• %an: Autorennamen
• %ar: Autorendatum, relativ
• %s: Betreff (Commit-Nachricht)

Sie können diese Formatzeichenfolge anpassen, um alle benötigten Informationen einzuschließen. Hier sind einige nützliche Platzhalter:

• %H: Vollständiger Commit-Hash
• %ad: Autorendatum
• %cn: Committer-Name
• %ce: Committer-E-Mail
• %cd: Committer-Datum

Experimentieren Sie mit verschiedenen Formaten, um herauszufinden, was am besten für Sie funktioniert!

Filtern des Logs nach Datum

Oft möchten Sie sich Commits innerhalb eines bestimmten Zeitraums ansehen. Git bietet mehrere Optionen, um das Log nach Datum zu filtern.

Um die Commits der letzten Woche anzuzeigen:

git log --since=1.week

Sie können auch konkrete Daten verwenden:

git log --after="2023-06-01" --before="2023-06-30"

Dies zeigt die Commits zwischen dem 1. und dem 30. Juni 2023 an.

Git versteht eine Vielzahl von Datumsformaten, einschließlich relativer Formate wie "gestern", "vor 1 Monat, 2 Wochen und 3 Tagen" usw.

Sie können auch die Option --until anstelle von --before verwenden, und --after ist synonym zu --since.

Denken Sie daran, dass diese Filter Commits anzeigen, deren Commit-Datum in den angegebenen Zeitraum fällt. Das Commit-Datum ist der Zeitpunkt, zu dem der Commit erstellt wurde, was möglicherweise unterschiedlich ist von dem Zeitpunkt, zu dem die eigentlichen Änderungen vorgenommen wurden.

Wenn Sie untersuchen, wann eine bestimmte Änderung eingeführt wurde, möchten Sie möglicherweise die Option --grep verwenden, um nach bestimmten Commit-Nachrichten zu suchen. Dies wird im nächsten Schritt behandelt.

Suchen im Log nach bestimmten Änderungen

Git bietet leistungsstarke Suchfunktionen, um Ihnen zu helfen, bestimmte Commits zu finden. Lassen Sie uns einige dieser Funktionen erkunden.

Um nach Commits zu suchen, in deren Commit-Nachricht ein bestimmtes Wort vorkommt:

git log --grep="function"

Dies zeigt alle Commits an, in denen das Wort "function" in der Commit-Nachricht vorkommt.

Sie können auch nach Änderungen an einer bestimmten Datei suchen:

git log -- script.js

Dies zeigt alle Commits an, die die Datei script.js beeinflusst haben.

Um nach Änderungen zu suchen, die eine bestimmte Codezeile hinzugefügt oder entfernt haben:

git log -S "console.log"

Dies wird als "Pickaxe-Suche" (Eispickelsuche) bezeichnet. Sie zeigt Commits an, in denen die Anzahl der Vorkommen von "console.log" geändert wurde.

Sie können diese Optionen mit anderen Optionen kombinieren. Beispielsweise, um detaillierte Änderungen an script.js in der letzten Woche anzuzeigen:

git log -p --since=1.week -- script.js

Denken Sie daran, dass die Suche in Git standardmäßig Groß- und Kleinschreibung beachtet. Verwenden Sie die Option -i für eine Groß- und Kleinschreibung-unabhängige Suche:

git log --grep="function" -i

Diese Suchfunktionen sind unglaublich nützlich, wenn Sie versuchen, herauszufinden, wann eine bestimmte Änderung eingeführt oder ein Fehler behoben wurde.

Generieren von Statistiken aus dem Log

Git kann durch Statistiken wertvolle Einblicke in die Geschichte Ihres Projekts geben. Lassen Sie uns einige Möglichkeiten erkunden, wie Sie diese Statistiken generieren können.

Um eine Zusammenfassung der Anzahl der Commits pro Autor zu sehen:

git shortlog -s -n

Dies zeigt eine Liste von Autoren an, sortiert nach der Anzahl der Commits, mit der Commit-Anzahl neben jedem Namen.

Um zu sehen, wie viele Zeilen jeder Autor hinzugefügt und entfernt hat:

git log --author="Jane Doe" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "Added lines: %s, Removed lines: %s, Total lines: %s\n", add, subs, loc }'

Ersetzen Sie "Jane Doe" durch den Namen des Autors, den Sie überprüfen möchten.

Um zu sehen, welche Dateien am häufigsten geändert wurden:

git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -10

Dies zeigt die 10 am häufigsten geänderten Dateien.

Um die Gesamtzahl der Commits zu sehen:

git rev-list --count HEAD

Diese Statistiken können sehr nützlich sein, um die allgemeinen Entwicklungsmuster in Ihrem Projekt zu verstehen. Sie können helfen, zu identifizieren, welche Teile des Projekts am aktivsten entwickelt werden, wer die aktivsten Mitwirkenden sind und wie sich das Projekt im Laufe der Zeit entwickelt hat.

Denken Sie daran, dass diese Statistiken zwar informativ sein können, aber nicht die ganze Geschichte erzählen. Die Anzahl der Commits oder geänderten Zeilen korreliert nicht unbedingt mit der Auswirkung oder Qualität der Beiträge.

Zusammenfassung

Herzlichen Glückwunsch, Git-Geschichtsforscher! Sie haben gerade die Macht der Git-Geschichts- und Log-Verwaltungsfunktionen freigeschaltet. Lassen Sie uns die wichtigsten Konzepte, die wir behandelt haben, zusammenfassen:

1. Grundlegende Log-Nutzung: Sie haben gelernt, wie Sie die Commit-Geschichte Ihres Projekts mit git log anzeigen können.
2. Formatierung der Log-Ausgabe: Sie haben entdeckt, wie Sie die Log-Ausgabe anpassen können, um genau die Informationen anzuzeigen, die Sie benötigen.
3. Filtern des Logs nach Datum: Sie haben gesehen, wie Sie sich auf Commits innerhalb bestimmter Zeiträume konzentrieren können.
4. Suchen im Log nach bestimmten Änderungen: Sie haben leistungsstarke Techniken gelernt, um herauszufinden, wann bestimmte Änderungen eingeführt wurden.
5. Generieren von Statistiken aus dem Log: Sie haben Möglichkeiten erkundet, um Einblicke in die Entwicklungsmuster Ihres Projekts zu gewinnen.

Diese Fähigkeiten werden sich bei der Arbeit an größeren Projekten als unschätzbar erweisen. Egal, ob Sie einen Fehler aufspüren, die Entwicklung eines Features überprüfen oder versuchen, die allgemeinen Entwicklungstrends in Ihrem Projekt zu verstehen - der Befehl git log und seine verschiedenen Optionen werden Ihre treuen Begleiter sein.

Denken Sie daran, dass die Git-Geschichte nicht nur eine Aufzeichnung dessen ist, was passiert ist - sondern ein leistungsstarkes Werkzeug zur Verbesserung und zum Verständnis Ihres Projekts. Nutzen Sie es klug, und es wird Sie zu einem effektiveren Entwickler machen.

Setzen Sie das Experimentieren mit diesen Befehlen fort. Je vertrauter Sie sich mit der Navigation durch die Geschichte Ihres Projekts werden, desto mehr Einblicke können Sie daraus gewinnen. Viel Spaß beim Zeitreisen in Ihren Git-Repositories!