Wie man die Commit-Historie eines Remote-Git-Branches anzeigt

GitGitBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einleitung

Git ist ein leistungsstarkes Versionskontrollsystem, das es Entwicklern ermöglicht, Änderungen zu verfolgen, an Projekten zusammenzuarbeiten und eine vollständige Historie ihrer Codebasis zu pflegen. Eine wesentliche Fähigkeit in Git ist das Anzeigen der Commit-Historie von Remote-Branches, was Ihnen hilft zu verstehen, wie sich ein Projekt entwickelt hat und wer spezifische Änderungen beigetragen hat.

In diesem Lab lernen wir, wie man die Commit-Historie von Remote-Git-Branches mithilfe eines echten GitHub-Repositorys anzeigt und interpretiert. Dieses Wissen wird Ihnen helfen, die Projektentwicklung besser zu verstehen, Probleme zu debuggen und effektiver mit Ihrem Team zusammenzuarbeiten.

Git-Repositories und grundlegende Log-Befehle verstehen

Bevor wir die Commit-Historie von Remote-Branches untersuchen, wollen wir die grundlegende Struktur eines Git-Repositorys verstehen und wie man die Commit-Historie lokal anzeigt.

In diesem Lab arbeiten wir mit einem echten Git-Repository – dem git-playground-Repository von GitHub. Navigieren wir dorthin und erkunden es:

cd ~/project/git-playground

Was ist ein Git-Repository?

Ein Git-Repository ist eine Sammlung von Dateien und der Historie der Änderungen, die an diesen Dateien vorgenommen wurden. Git verfolgt Änderungen durch Commits, bei denen es sich um Schnappschüsse Ihrer Dateien zu bestimmten Zeitpunkten handelt.

Untersuchen wir die Struktur unseres git-playground-Repositorys:

ls -la

Sie sollten die folgenden Dateien sehen:

  • README.md - Die Repository-Dokumentation
  • file1.txt - Eine Beispieltextdatei
  • file2.txt - Eine weitere Beispieltextdatei

Anzeigen der grundlegenden Commit-Historie

Der grundlegendste Befehl zum Anzeigen der Commit-Historie in Git ist git log. Dieser Befehl zeigt die Commit-Historie in umgekehrter chronologischer Reihenfolge an (die neuesten Commits zuerst).

Probieren wir es aus:

git log

Sie sollten eine Ausgabe ähnlich dieser sehen:

commit d22f46ba8c2d4e07d773c5126e9c803933eb5898 (HEAD -> master, origin/master, origin/main, origin/feature-branch, origin/HEAD)
Author: Hang <[email protected]>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file2.txt

commit cf80005e40a3c661eb212fcea5fad06f8283f08f
Author: Hang <[email protected]>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file1.txt

commit b00b9374a7c549d1af111aa777fdcc868d8a2a01
Author: Hang <[email protected]>
Date:   Wed Apr 26 14:16:00 2023 +0800

    Initial commit

Jeder Commit-Eintrag zeigt:

  • Einen eindeutigen Commit-Hash (Identifikator)
  • Den Autor des Commits
  • Das Datum und die Uhrzeit des Commits
  • Die Commit-Nachricht

Für eine prägnantere Ansicht können Sie die Option --oneline verwenden:

git log --oneline

Dadurch wird jeder Commit in einer einzigen Zeile angezeigt, wobei nur der kurze Commit-Hash und die Commit-Nachricht gezeigt werden:

d22f46b Added file2.txt
cf80005 Added file1.txt
b00b937 Initial commit

Diese grundlegenden Log-Befehle helfen Ihnen, die Historie Ihres aktuellen Branches zu verstehen. Im nächsten Schritt werden wir untersuchen, wie man Informationen über Remote-Branches anzeigt.

Remote-Repositories und Branches verstehen

In diesem Schritt lernen wir Remote-Repositories kennen und wie man mit ihnen in Git arbeitet.

Was sind Remote-Repositories?

Ein Remote-Repository ist eine Version Ihres Projekts, die im Internet oder in einem anderen Netzwerk gehostet wird. Wenn Sie mit anderen zusammenarbeiten, pushen Sie Ihre Änderungen in Remote-Repositories und ziehen deren Änderungen daraus.

In unserem Fall haben wir ein Remote-Repository, das auf GitHub unter https://github.com/labex-labs/git-playground.git gehostet wird. Dieses Remote ist in unserem lokalen Repository bereits mit dem Namen origin konfiguriert.

Um die konfigurierten Remote-Repositories anzuzeigen, verwenden Sie:

git remote -v

Sie sollten eine Ausgabe wie diese sehen:

origin  https://github.com/labex-labs/git-playground.git (fetch)
origin  https://github.com/labex-labs/git-playground.git (push)

Remote-Branches verstehen

Remote-Branches repräsentieren den Zustand von Branches in Ihren Remote-Repositories. Sie folgen der Namenskonvention <remote-name>/<branch-name>, wie z. B. origin/master oder origin/feature-branch.

Um alle Branches, einschließlich Remote-Branches, anzuzeigen, verwenden Sie:

git branch -a

Die Ausgabe sollte sowohl lokale als auch Remote-Branches anzeigen:

* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/feature-branch
  remotes/origin/main
  remotes/origin/master

Remote-Daten abrufen (Fetching)

Bevor Sie die Commit-Historie von Remote-Branches anzeigen können, müssen Sie die neuesten Daten vom Remote-Repository abrufen. Dies aktualisiert Ihre lokale Kopie der Remote-Branches, ohne Änderungen zusammenzuführen.

Rufen wir die neuesten Daten ab:

git fetch origin

Dieser Befehl lädt alle neuesten Commits, Branches und Dateien vom Remote-Repository herunter und ermöglicht Ihnen so, den neuesten Zustand der Remote-Branches anzuzeigen.

Nun können Sie die Commit-Historie eines Remote-Branches mit git log anzeigen, indem Sie den Namen des Remote-Branches angeben:

git log origin/feature-branch

Da alle Branches in diesem Repository auf denselben Commit verweisen, sehen Sie dieselbe Commit-Historie:

commit d22f46ba8c2d4e07d773c5126e9c803933eb5898 (HEAD -> master, origin/master, origin/main, origin/feature-branch, origin/HEAD)
Author: Hang <[email protected]>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file2.txt

commit cf80005e40a3c661eb212fcea5fad06f8283f08f
Author: Hang <[email protected]>
Date:   Wed Apr 26 14:16:25 2023 +0800

    Added file1.txt

commit b00b9374a7c549d1af111aa777fdcc868d8a2a01
Author: Hang <[email protected]>
Date:   Wed Apr 26 14:16:00 2023 +0800

    Initial commit

Durch das Verständnis von Remote-Repositories und wie man Daten von ihnen abruft, können Sie auf die Commit-Historie jedes Remote-Branches zugreifen und diese anzeigen.

Erweiterte Git Log-Befehle für Remote-Branches

Nachdem wir die Grundlagen der Anzeige der Remote-Branch-Historie verstanden haben, wollen wir nun fortgeschrittenere Git log-Optionen erkunden, um die Commit-Historie besser zu visualisieren und zu analysieren.

Anpassen der Log-Ausgabe

Der Befehl git log verfügt über viele Optionen zur Anpassung seiner Ausgabe. Hier sind einige nützliche:

Eine prägnante Log-Anzeige

Für eine kompaktere Ansicht der Commit-Historie verwenden Sie die Option --oneline:

git log --oneline origin/master

Beispielausgabe:

d22f46b Added file2.txt
cf80005 Added file1.txt
b00b937 Initial commit

Begrenzen der Anzahl von Commits

Wenn Sie nur eine bestimmte Anzahl von Commits sehen möchten, verwenden Sie die Option -n gefolgt von der Nummer:

git log -n 2 origin/master

Dies zeigt nur die 2 neuesten Commits im Remote-Master-Branch an.

Commits mit Änderungen anzeigen

Um die tatsächlichen Änderungen anzuzeigen, die in jedem Commit vorgenommen wurden, fügen Sie die Option -p (kurz für "patch") hinzu:

git log -p origin/master

Dies zeigt den vollständigen Diff für jeden Commit an, einschließlich welcher Zeilen hinzugefügt oder entfernt wurden. Dies ist besonders nützlich, wenn Sie Fehler untersuchen oder spezifische Änderungen verstehen möchten.

Versuchen wir dies mit einer bestimmten Datei:

git log -p origin/master -- file1.txt

Dieser Befehl zeigt die Commit-Historie mit Änderungen nur für die Datei file1.txt im Remote-Master-Branch an.

Visualisieren des Commit-Graphen

Für eine visuelle Darstellung der Commit-Historie verwenden Sie die Option --graph:

git log --graph --oneline --all

Dies zeigt einen ASCII-Graphen an, der die Beziehungen zwischen Commits und Branches darstellt:

* d22f46b (HEAD -> master, origin/master, origin/main, origin/feature-branch, origin/HEAD) Added file2.txt
* cf80005 Added file1.txt
* b00b937 Initial commit

Der Graph hilft Ihnen zu visualisieren, wie Branches abzweigen und zusammengeführt werden, was das Verständnis der Entwicklungshistorie des Projekts erleichtert.

Anzeigen von Commit-Statistiken

Um Statistiken über Änderungen in jedem Commit anzuzeigen:

git log --stat origin/master

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

Diese erweiterten Log-Befehle bieten Ihnen leistungsstarke Werkzeuge, um die Commit-Historie von Remote-Branches auf verschiedene Weise zu analysieren und zu verstehen.

Vergleichen von Branches und Untersuchen spezifischer Commits

Nachdem wir die Commit-Historie von Remote-Branches anzeigen können, lernen wir nun, wie man Branches vergleicht und spezifische Commits detaillierter untersucht.

Vergleichen von Branches

Git bietet leistungsstarke Werkzeuge zum Vergleichen verschiedener Branches. Da alle Branches in unserem git-playground-Repository auf denselben Commit verweisen, wollen wir zunächst verstehen, wie diese Befehle verwendet werden, und dann praktische Beispiele sehen.

Um die Unterschiede zwischen Ihrem aktuellen Branch und einem Remote-Branch anzuzeigen, verwenden Sie:

git diff origin/main

Da in unserem Beispiel alle Branches identisch sind, werden hier keine Unterschiede angezeigt. In realen Projekten würde dies jedoch zeigen, was sich zwischen Ihrem aktuellen Branch und dem Remote-Branch geändert hat.

Sie können auch zwei Remote-Branches vergleichen:

git diff origin/master origin/feature-branch

Auch hier werden keine Unterschiede angezeigt, da sie identisch sind.

Untersuchen spezifischer Commits

Manchmal müssen Sie einen bestimmten Commit im Detail untersuchen. Dies können Sie mit dem Befehl git show gefolgt vom Commit-Hash tun:

Zuerst holen wir uns die Commit-Hashes:

git log --oneline origin/master

Untersuchen Sie nun einen bestimmten Commit anhand seines Hashs:

git show d22f46b

Dieser Befehl zeigt die Commit-Details zusammen mit den in diesem Commit eingeführten Änderungen an. Sie sehen die Hinzufügung von file2.txt.

Untersuchen wir den Commit, der file1.txt hinzugefügt hat:

git show cf80005

Und den initialen Commit:

git show b00b937

Anzeigen von Dateiinhalten von einem Remote-Branch

Um den Inhalt einer bestimmten Datei anzuzeigen, wie er in einem Remote-Branch existiert, verwenden Sie:

git show origin/master:README.md

Dies zeigt den Inhalt von README.md an, wie er im Master-Branch des Remote-Repositories existiert.

Sie können auch den Inhalt anderer Dateien anzeigen:

git show origin/master:file1.txt
git show origin/master:file2.txt

Überprüfen, wer eine bestimmte Zeile geändert hat

Um zu sehen, wer Änderungen an einer bestimmten Datei vorgenommen hat und wann, verwenden Sie den Befehl git blame:

git blame README.md

Dies zeigt jede Zeile der Datei zusammen mit dem Commit-Hash, dem Autor und dem Datum der letzten Änderung dieser Zeile an.

Probieren Sie es mit den anderen Dateien aus:

git blame file1.txt
git blame file2.txt

Anzeigen der Dateihistorie

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

git log -p origin/master -- README.md

Dies zeigt alle Commits an, die die Datei README.md im Remote-Master-Branch geändert haben, zusammen mit den in jedem Commit vorgenommenen Änderungen.

Diese Befehle bieten wertvolle Werkzeuge, um die Historie und Entwicklung Ihrer Codebasis zu verstehen, was es einfacher macht, Änderungen zu verfolgen, Probleme zu beheben und mit anderen Entwicklern zusammenzuarbeiten.

Praktische Anwendungen der Remote-Branch-Historie

Nachdem wir die technischen Aspekte der Anzeige der Remote-Branch-Historie gelernt haben, wollen wir nun einige praktische Anwendungen dieses Wissens in realen Entwicklungsszenarien erkunden.

Code-Reviews und Verständnis von Änderungen

Beim Überprüfen von Code-Änderungen, die von Teammitgliedern vorgenommen wurden, können Sie Folgendes verwenden:

git log -p origin/master

Dies hilft Ihnen, die Änderungen umfassend zu verstehen, bevor Sie sie in den Haupt-Branch integrieren. In unserem git-playground-Beispiel können Sie genau sehen, wann und wie jede Datei hinzugefügt wurde.

Debugging von Problemen

Wenn ein Fehler in Ihrer Anwendung auftritt, können Sie nachverfolgen, wann er eingeführt wurde. Wenn es beispielsweise ein Problem mit einer bestimmten Datei gab:

git log -p origin/master -- file1.txt

Durch die Untersuchung der Commit-Historie der spezifischen Datei können Sie identifizieren, wann und warum der problematische Code hinzugefügt wurde.

Verfolgen der Feature-Entwicklung

Um den Entwicklungsfortschritt eines Projekts zu verstehen:

git log --oneline origin/master

Dies gibt Ihnen eine chronologische Ansicht der Commits, die zum Projekt beigetragen haben. In unserem Beispiel:

d22f46b Added file2.txt
cf80005 Added file1.txt
b00b937 Initial commit

Sie können sehen, wie sich das Projekt von einem initialen Commit entwickelt hat und dann sequenziell zwei Dateien hinzugefügt wurden.

Identifizieren von Mitwirkenden

Um zu sehen, wer zu einer bestimmten Datei oder einem bestimmten Bereich der Codebasis beigetragen hat:

git shortlog -sn origin/master

Dies zeigt eine Zusammenfassung der Mitwirkenden und der Anzahl ihrer Commits:

     3  Hang

Für eine bestimmte Datei:

git shortlog -sn origin/master -- README.md

Üben eines realen Szenarios

Stellen Sie sich vor, Sie müssen verstehen, wie sich das Projekt entwickelt hat. Probieren Sie diese Befehle aus:

  1. Überprüfen Sie zuerst die allgemeine Projektzeitleiste:
git log --oneline --graph --all
  1. Zeigen Sie detaillierte Änderungen für jeden Commit an:
git log --stat origin/master
  1. Sehen Sie den genauen Inhalt, der in jedem Commit hinzugefügt wurde:
git log -p origin/master
  1. Überprüfen Sie, wann eine bestimmte Datei zuletzt geändert wurde:
git log -1 --format="%H %an %ad %s" origin/master -- file2.txt
  1. Vergleichen Sie den Repository-Zustand zu verschiedenen Zeitpunkten:
git show cf80005:. | head -10

Verstehen von Branch-Beziehungen

Da alle Branches in unserem Repository auf denselben Commit verweisen, wollen wir verstehen, was das bedeutet:

git show-branch origin/master origin/main origin/feature-branch

Dies zeigt, dass sich alle Branches im selben Zustand befinden, was in einfachen Repositories oder wenn Branches synchron gehalten werden, üblich ist.

Arbeiten mit Remote-Referenzen

Um alle Remote-Referenzen anzuzeigen:

git ls-remote origin

Dies zeigt alle Branches und Tags an, die im Remote-Repository verfügbar sind.

Diese praktischen Beispiele zeigen, wie die Anzeige der Remote-Branch-Historie Ihnen helfen kann, die Entwicklung Ihrer Codebasis zu verstehen, effektiver mit Teammitgliedern zusammenzuarbeiten und Probleme effizienter zu lösen.

Durch die Beherrschung der in diesem Lab behandelten Fähigkeiten sind Sie besser gerüstet, um mit Git in professionellen Entwicklungsumgebungen zu arbeiten und effektiv an Softwareprojekten zusammenzuarbeiten.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die Commit-Historie von Remote-Git-Branches mithilfe eines realen GitHub-Repositorys (git-playground) anzeigen und analysieren. Dies ist eine wesentliche Fähigkeit für eine effektive Zusammenarbeit in Softwareentwicklungsprojekten.

Abgedeckte Kernpunkte:

  • Verständnis von Git-Repositorys und grundlegender Commit-Historie mit git log
  • Arbeiten mit Remote-Repositorys und Abrufen von Remote-Branch-Daten von GitHub
  • Verwendung erweiterter git log-Optionen zur Anpassung und Visualisierung der Commit-Historie
  • Vergleichen von Branches und detailliertes Untersuchen spezifischer Commits
  • Anwendung dieser Fähigkeiten auf reale Entwicklungsszenarien unter Verwendung tatsächlicher Commit-Daten

Durch die Arbeit mit dem git-playground-Repository haben Sie Folgendes gesehen:

  • Wie man ein reales GitHub-Repository klont und erkundet
  • Die tatsächliche Commit-Historie, die die Entwicklung vom initialen Commit bis zum Hinzufügen von Dateien zeigt
  • Wie verschiedene Git-Befehle verwendet werden, um den Beitrag von "Hang" über drei Commits hinweg zu analysieren
  • Praktische Anwendungen der Commit-Analyse zum Verständnis der Projektentwicklung

Diese Fähigkeiten werden Sie in die Lage versetzen:

  • Die Projektentwicklung und den Kontext hinter Code-Änderungen besser zu verstehen
  • Probleme effektiv zu debuggen, indem Sie nachverfolgen, wann und warum spezifische Änderungen vorgenommen wurden
  • Effektiver mit Teammitgliedern zusammenzuarbeiten, indem Sie deren Beiträge verstehen
  • Fundiertere Entscheidungen beim Mergen, Verzweigen und Verwalten von Code zu treffen

Während Sie weiterhin mit Git arbeiten, werden diese Fähigkeiten immer wertvoller und helfen Ihnen, sich in komplexen Codebasen zurechtzufinden und effektiv zu kollaborativen Entwicklungsprojekten beizutragen.