So überprüfen Sie den Status von Git-Submodulen in einem Repository

GitBeginner
Jetzt üben

Einführung

Git-Submodule sind eine leistungsstarke Funktion, mit der Sie externe Repositories in Ihre eigenen Projekte einbinden können. Diese Fähigkeit ist besonders nützlich, wenn Ihr Projekt von externen Bibliotheken oder Komponenten abhängt, die separat verwaltet werden. Durch die Verwendung von Submodulen können Sie diese Abhängigkeiten aktuell halten und gut verwalten.

In diesem Tutorial erfahren Sie, wie Sie den Status von Git-Submodulen in Ihrem Repository überprüfen, welche Änderungen an ihnen vorgenommen wurden und wie Sie sicherstellen, dass sie ordnungsgemäß mit ihren Quell-Repositories synchronisiert werden.

Erstellen eines Repositorys mit Submodulen

Beginnen wir mit der Erstellung eines Beispiel-Repositorys mit einem Submodul, um eine praktische Umgebung für unser Lernen zu haben.

Einrichten des Haupt-Repositorys

Zuerst erstellen wir ein neues Haupt-Repository, dem wir unser Submodul hinzufügen werden. Öffnen Sie Ihr Terminal und führen Sie die folgenden Befehle aus:

cd ~/project
mkdir main-repo
cd main-repo
git init

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Initialized empty Git repository in /home/labex/project/main-repo/.git/

Lassen Sie uns nun eine einfache Datei in unserem Haupt-Repository erstellen:

echo "## Main Repository" > README.md
git add README.md
git commit -m "Initial commit"

Die Ausgabe sollte anzeigen, dass Sie Ihren ersten Commit erstellt haben:

[master (root-commit) xxxxxxx] Initial commit
 1 file changed, 1 insertion(+)
 create mode 100644 README.md

Hinzufügen eines Submoduls

Fügen wir nun ein Submodul zu unserem Haupt-Repository hinzu. Für dieses Tutorial verwenden wir ein kleines, öffentliches Repository als unser Submodul:

git submodule add https://github.com/libgit2/libgit2-backends.git libs/libgit2-backends

Dieser Befehl klont das Repository und fügt es als Submodul im Verzeichnis libs/libgit2-backends hinzu. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Cloning into '/home/labex/project/main-repo/libs/libgit2-backends'...
remote: Enumerating objects: xxx, done.
remote: Counting objects: 100% (xxx/xxx), done.
remote: Compressing objects: 100% (xxx/xxx), done.
remote: Total xxx (delta xx), reused xxx (delta xx), pack-reused xxx
Receiving objects: 100% (xxx/xxx), xxx KiB | xxx KiB/s, done.
Resolving deltas: 100% (xxx/xxx), done.

Verstehen der Änderungen

Wenn Sie ein Submodul hinzufügen, erstellt Git eine .gitmodules-Datei in Ihrem Repository, die die URL und den Pfad des Submoduls verfolgt. Schauen wir uns diese Datei an:

cat .gitmodules

Sie sollten einen Inhalt ähnlich dem folgenden sehen:

[submodule "libs/libgit2-backends"]
	path = libs/libgit2-backends
	url = https://github.com/libgit2/libgit2-backends.git

Überprüfen wir auch den Status unseres Repositorys:

git status

Sie sollten eine Ausgabe sehen, die anzeigt, dass sowohl die neue .gitmodules-Datei als auch das Submodul-Verzeichnis hinzugefügt wurden:

On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   .gitmodules
        new file:   libs/libgit2-backends

Lassen Sie uns diese Änderungen committen, um unser Setup abzuschließen:

git commit -m "Add libgit2-backends submodule"

Sie sollten jetzt ein Repository mit einem erfolgreich eingerichteten Submodul haben.

Überprüfen des Status von Submodulen

Nachdem wir nun ein Repository mit einem Submodul haben, wollen wir lernen, wie man den Status des Submoduls überprüft und was die Ausgabe bedeutet.

Einfache Submodul-Statusprüfung

Git bietet einen spezifischen Befehl, um den Status von Submodulen zu überprüfen. Führen Sie den folgenden Befehl aus:

cd ~/project/main-repo
git submodule status

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

+abcdef1234567890abcdef1234567890abcdef12 libs/libgit2-backends (v1.0.0-123-gabcdef12)

Lassen Sie uns verstehen, was diese Ausgabe bedeutet:

  1. Das erste Zeichen kann eines der folgenden sein:

    • +: zeigt an, dass der ausgecheckte Commit des Submoduls von dem im Haupt-Repository registrierten abweicht
    • (Leerzeichen): zeigt an, dass das Submodul mit dem registrierten synchron ist
    • -: zeigt an, dass das Submodul nicht initialisiert ist
    • U: zeigt Merge-Konflikte im Submodul an
  2. Die alphanumerische Zeichenkette ist der Commit-Hash des aktuellen, im Submodul ausgecheckten Commits.

  3. Der Pfad zeigt, wo sich das Submodul in Ihrem Repository befindet.

  4. Der Text in Klammern zeigt zusätzliche Informationen über den ausgecheckten Commit, wie z.B. Tags oder Zweignamen.

Detaillierte Submodul-Informationen

Für detailliertere Informationen über Ihre Submodule können Sie den folgenden Befehl verwenden:

git submodule

Dies zeigt ähnliche Informationen wie der Statusbefehl, jedoch in einem anderen Format.

Verwenden von Git Status, um Submodul-Änderungen zu sehen

Sie können auch den Standardbefehl git status verwenden, um Änderungen in Submodulen zu sehen:

git status

Wenn es keine Änderungen am Submodul gibt, wird es in der Ausgabe nicht erwähnt. Wenn es jedoch Änderungen am ausgecheckten Commit des Submoduls oder an Dateien innerhalb des Submoduls gibt, zeigt git status diese Informationen an.

Untersuchen des Submodul-Inhalts

Lassen Sie uns den Inhalt unseres Submoduls untersuchen:

cd ~/project/main-repo
ls -la libs/libgit2-backends/

Sie sehen die Dateien aus dem libgit2-backends-Repository. Beachten Sie, dass das Submodul im Wesentlichen ein vollständiges Git-Repository innerhalb Ihres Haupt-Repositorys ist. Sie können dies überprüfen, indem Sie auf das Vorhandensein eines .git-Verzeichnisses prüfen:

ls -la libs/libgit2-backends/.git

Möglicherweise sehen Sie nicht direkt ein .git-Verzeichnis, sondern eher eine Datei, die auf die tatsächlichen Git-Repository-Daten verweist, die im .git/modules-Verzeichnis Ihres Haupt-Repositorys gespeichert sind. So verwaltet Git Submodule.

Verstehen der Submodul-Referenz

Das Haupt-Repository speichert eine Referenz auf einen bestimmten Commit im Submodul-Repository. Diese Referenz verwendet Git, um zu wissen, welche Version des Submoduls beim Klonen Ihres Repositorys oder beim Aktualisieren des Submoduls ausgecheckt werden soll.

Lassen Sie uns den Commit sehen, auf den sich unser Haupt-Repository bezieht:

cd ~/project/main-repo
git ls-files --stage libs/libgit2-backends

Die Ausgabe zeigt einen Commit-Hash, der der spezifische Commit des Submoduls ist, den das Haupt-Repository verfolgt.

Aktualisieren von Submodulen

Eine häufige Aufgabe bei der Arbeit mit Submodulen ist es, diese mit ihren Remote-Repositories auf dem neuesten Stand zu halten. Lassen Sie uns lernen, wie man unser Submodul aktualisiert.

Initialisieren und Aktualisieren von Submodulen

Wenn Sie gerade ein Repository geklont haben, das Submodule enthält, müssen Sie diese initialisieren und aktualisieren. Für unser bestehendes Repository können wir diesen Prozess mit Folgendem demonstrieren:

cd ~/project/main-repo
git submodule init
git submodule update

Der Befehl init initialisiert Ihre Submodul-Konfiguration, und der Befehl update holt die Daten und checkt den in Ihrem Haupt-Repository angegebenen Commit aus.

Sie können diese Befehle auch kombinieren:

git submodule update --init

Aktualisieren von Submodulen auf die neueste Remote-Version

Wenn Sie ein Submodul auf den neuesten Commit in seinem Remote-Repository aktualisieren möchten, können Sie Folgendes verwenden:

cd ~/project/main-repo
git submodule update --remote libs/libgit2-backends

Dieser Befehl holt die neuesten Änderungen aus dem Remote-Repository und aktualisiert das Submodul. Sie sollten eine Ausgabe sehen, die anzeigt, dass Git Änderungen abruft.

Nachdem Sie diesen Befehl ausgeführt haben, überprüfen wir den Status des Submoduls:

git submodule status

Sie werden feststellen, dass die Ausgabe jetzt ein Pluszeichen (+) am Anfang anzeigt, was darauf hindeutet, dass der ausgecheckte Commit des Submoduls von dem im Haupt-Repository aufgezeichneten abweicht:

+abcdef1234567890abcdef1234567890abcdef12 libs/libgit2-backends (origin/HEAD)

Um die Änderungen an Ihrem Haupt-Repository zu bestätigen, führen Sie Folgendes aus:

git status

Sie sollten eine Ausgabe sehen, die anzeigt, dass das Submodul geändert wurde:

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   libs/libgit2-backends (new commits)

Committen der aktualisierten Submodul-Referenz

Um den aktualisierten Submodul-Status in Ihrem Haupt-Repository aufzuzeichnen, müssen Sie die Änderungen hinzufügen und committen:

git add libs/libgit2-backends
git commit -m "Update libgit2-backends submodule to latest version"

Die Ausgabe sollte anzeigen, dass Sie die neue Submodul-Referenz erfolgreich committet haben.

Überprüfen des aktualisierten Status

Nachdem Sie die aktualisierte Submodul-Referenz committet haben, überprüfen wir den Status erneut:

git submodule status

Die Ausgabe sollte am Anfang kein Pluszeichen mehr haben, was darauf hindeutet, dass das Submodul jetzt mit dem im Haupt-Repository aufgezeichneten synchron ist:

 abcdef1234567890abcdef1234567890abcdef12 libs/libgit2-backends (origin/HEAD)

Verstehen der Submodul-Update-Optionen

Der Befehl git submodule update verfügt über mehrere Optionen, die steuern, wie Aktualisierungen durchgeführt werden:

  • --remote: Aktualisieren auf den neuesten Commit auf dem Remote-Tracking-Branch
  • --merge: Änderungen zusammenführen, wenn der aktuelle Branch hinter dem Remote zurückliegt
  • --rebase: Änderungen rebasen, wenn der aktuelle Branch hinter dem Remote zurückliegt
  • --recursive: Auch verschachtelte Submodule aktualisieren

Für die meisten grundlegenden Anwendungsfälle ist git submodule update --remote ausreichend.

Arbeiten mit Submodul-Änderungen

Manchmal müssen Sie mit Änderungen innerhalb eines Submoduls arbeiten. In diesem Schritt lernen wir, wie man Änderungen innerhalb von Submodulen vornimmt und verwaltet.

Um mit einem Submodul zu arbeiten, müssen Sie in sein Verzeichnis navigieren:

cd ~/project/main-repo/libs/libgit2-backends

Von hier aus können Sie Standard-Git-Befehle verwenden, um Informationen über das Submodul-Repository anzuzeigen:

git status
git log -3 --oneline

Der Befehl git status zeigt den aktuellen Zustand des Submodul-Repositorys an, und git log zeigt die letzten Commits.

Änderungen in einem Submodul vornehmen

Lassen Sie uns eine einfache Änderung an einer Datei im Submodul vornehmen. Zuerst erstellen wir eine neue Datei:

echo "## My notes on libgit2-backends" > NOTES.md

Nun überprüfen wir den Status unserer Änderung:

git status

Sie sollten eine Ausgabe sehen, die anzeigt, dass Sie eine nicht verfolgte Datei haben:

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        NOTES.md

Lassen Sie uns diese Änderung zum Submodul hinzufügen und committen:

git add NOTES.md
git commit -m "Add notes file"

Sie sollten eine Ausgabe sehen, die Ihren Commit innerhalb des Submoduls bestätigt.

Überprüfen des Status aus dem Haupt-Repository

Gehen wir nun zurück zum Haupt-Repository und überprüfen den Status:

cd ~/project/main-repo
git status

Sie sollten eine Ausgabe sehen, die anzeigt, dass das Submodul geändert wurde:

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   libs/libgit2-backends (new commits)

Committen von Submodul-Änderungen im Haupt-Repository

Um den neuen Zustand des Submoduls in Ihrem Haupt-Repository aufzuzeichnen, müssen Sie die Änderungen hinzufügen und committen:

git add libs/libgit2-backends
git commit -m "Update libgit2-backends with notes file"

Die Ausgabe sollte anzeigen, dass Sie die neue Submodul-Referenz erfolgreich committet haben.

Anzeigen detaillierter Submodul-Änderungen

Um detailliertere Informationen über Änderungen in Submodulen zu sehen, können Sie Folgendes verwenden:

git diff --submodule

Dieser Befehl zeigt den Bereich der Commits an, die in jedem geänderten Submodul hinzugefügt oder entfernt wurden.

Zusammenfassung der Arbeit mit Submodul-Änderungen

Denken Sie bei der Arbeit mit Änderungen in einem Submodul an diesen Workflow:

  1. Navigieren Sie in das Submodul-Verzeichnis
  2. Nehmen Sie Änderungen innerhalb des Submoduls vor und committen Sie diese
  3. Kehren Sie zum Haupt-Repository zurück
  4. Fügen Sie die aktualisierte Submodul-Referenz hinzu und committen Sie diese

Dieser Zwei-Schritt-Commit-Prozess (zuerst im Submodul, dann im Haupt-Repository) ist unerlässlich, um Änderungen an Submodulen ordnungsgemäß zu verfolgen.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie man mit Git-Submodulen arbeitet, wobei der Schwerpunkt auf der Überprüfung ihres Status und der Durchführung von Aktualisierungen lag. Folgendes haben Sie erreicht:

  1. Erstellung eines Haupt-Repositorys und Hinzufügen eines Submoduls dazu
  2. Erfahren, wie man den Status von Submodulen mit verschiedenen Git-Befehlen überprüft
  3. Aktualisierung eines Submoduls auf die neueste Version aus seinem Remote-Repository
  4. Änderungen innerhalb eines Submoduls vorgenommen und diese Änderungen ordnungsgemäß im Haupt-Repository verfolgt

Git-Submodule bieten eine leistungsstarke Möglichkeit, externe Repositories in Ihre Projekte einzubinden, sodass Sie Abhängigkeiten effizient verwalten können. Indem Sie verstehen, wie Sie ihren Status überprüfen und Aktualisierungen verwalten, können Sie sicherstellen, dass Ihr Projekt ordnungsgemäß mit seinen Abhängigkeiten synchronisiert bleibt.

Wichtige Befehle, die man sich merken sollte:

  • git submodule status - Überprüfen des aktuellen Status von Submodulen
  • git submodule update --remote - Aktualisieren von Submodulen auf ihre neuesten Versionen
  • git add <submodule-path> - Änderungen an der Referenz eines Submoduls vormerken (stagen)
  • git diff --submodule - Detaillierte Änderungen in Submodulen anzeigen

Mit diesen Fähigkeiten können Sie Git-Repositories effektiv verwalten, die externen Code über Submodule einbinden.