Git Fetch | W3Docs Online Git Tutorial

Der Befehl git fetch lädt Commits, Dateien und Referenzen aus einem Remote-Repository in Ihr lokales Repository herunter, ohne dabei Ihre eigene Arbeit zu verändern. Es ist die sichere Methode, um zu sehen, was Ihre Teammitglieder gemacht haben: Nichts in Ihrem Arbeitsverzeichnis oder Ihren lokalen Branches wird berührt, bis Sie sich entscheiden, einen Merge durchzuführen.

Diese Seite erklärt, was git fetch macht, wie es Remote-Tracking-Branches aktualisiert, die nützlichsten Optionen, wie man einen bestimmten Branch oder ein ganzes Remote abruft, und wie sich git fetch von git pull unterscheidet.

Definition

Der Befehl git fetch wird verwendet, um Commits, Objekte und Referenzen aus einem Remote-Repository in das lokale Repository herunterzuladen. Er wird eingesetzt, um zu sehen, woran andere Teammitglieder gearbeitet haben. Im Gegensatz zu git pull führt er die heruntergeladene Arbeit niemals automatisch mit Ihrem aktuellen Branch zusammen.

Funktionsweise mit Remote-Branches

Git speichert lokale und Remote-Commits und trennt diese durch Branch-Referenzen. Die Referenzen für lokale Branches werden im Verzeichnis /.git/refs/heads/ gespeichert. Um die Liste der lokalen Branch-Referenzen anzuzeigen, führen Sie den Befehl git branch aus.

git branch

git branch
* master
  crossword
  solver

Das Untersuchen des Inhalts des Verzeichnisses /.git/refs/heads/ ergibt folgende Ausgabe:

ls ./.git/refs/heads/

ls ./.git/refs/heads/
master
crossword
solver

Remote-Branch-Referenzen werden im Verzeichnis ./.git/refs/remotes/ gespeichert. Um die Remote-Branches anzuzeigen, verwenden Sie das Flag -r mit git branch. Hier ist die Ausgabe nach dem Abrufen eines Remote-Repositorys:

git branch -r

git branch -r
  origin/master
  origin/crossword
  origin/solver
  remote-repo/master
  remote-repo/other-feature

Die Ausgabe zeigt Remote-Branches mit dem Präfix origin/. Diese sind Remote-Tracking-Branches — schreibgeschützte lokale Kopien, die aufzeichnen, wo sich jeder Branch beim letzten Fetch auf dem Remote befand. Sie können diese mit den Befehlen git checkout und git log untersuchen. Nach der Überprüfung der Änderungen können Sie einen Remote-Tracking-Branch mit git merge in Ihren lokalen Branch zusammenführen. Verwenden Sie git pull, um Fetch und Merge in einem einzigen Schritt zu kombinieren.

Häufig verwendete Optionen

Option	Funktion
`--all`	Ruft alle konfigurierten Remotes ab, nicht nur eines.
`-k`, `--keep`	Behält die heruntergeladene Pack-Datei, anstatt sie zu entpacken.
`-p`, `--prune`	Entfernt Remote-Tracking-Referenzen, die auf dem Remote nicht mehr existieren.
`--depth=<depth>`	Begrenzt die Anzahl der von der Spitze jedes Branches abgerufenen Commits (ein flacher Fetch).
`--dry-run`	Zeigt an, was abgerufen würde, ohne tatsächlich etwas herunterzuladen.

Um Tracking-Referenzen für Branches zu entfernen, die auf dem Remote nicht mehr existieren, verwenden Sie --prune:

git fetch --prune

Um von allen konfigurierten Remotes gleichzeitig abzurufen, verwenden Sie --all:

git fetch --all

Einen Remote-Branch mit git fetch abrufen

Im Folgenden zeigen wir die Schritte zum Abrufen eines Remote-Branches und zur Aktualisierung des lokalen Arbeitsstands auf den Remote-Inhalt. Im folgenden Beispiel gibt es ein zentrales Repository origin, von dem das lokale Repository mit dem Befehl git clone geklont wurde. Es gibt ein weiteres Remote-Repository namens test_repo, das feature_branch enthält und konfiguriert sowie abgerufen werden muss.

Der erste Schritt besteht darin, das Remote-Repository mit git remote zu konfigurieren:

git remote

git remote add test_repo git@hostname:test/test_repo.git

Mithilfe der URL des Kollegen-Repositorys haben wir eine Referenz darauf erstellt. Um den Inhalt herunterzuladen, rufen wir git fetch für den test feature_branch ab:

git fetch

git fetch test_repo feature_branch
From hostname:test/test_repo
* [new branch]      feature_branch -> test_repo/feature_branch

Dadurch wird der Inhalt von test_repo/feature_branch als Remote-Tracking-Branch in Ihr lokales Repository heruntergeladen — er wird nicht mit Ihrem aktuellen Branch zusammengeführt. Verwenden Sie nun den Befehl git checkout, um den heruntergeladenen Remote-Branch zu untersuchen:

git checkout test_repo/feature_branch

git checkout test_repo/feature_branch
Note: checking out 'test_repo/feature_branch'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can drop all the commits you make in this
state without influencing branches by executing another checkout.

If you want to generate a new branch for maintaining commits you create, you may
do so (now or later) if you use -b with the checkout command again. Example:

git checkout -b &lt;new-branch-name&gt;

Die Ausgabe zeigt, dass wir uns im detached HEAD-Zustand befinden, was bedeutet, dass die HEAD-Referenz direkt auf einen Commit anstatt auf einen Branch zeigt.

Mit dem Befehl git checkout kann ein neuer lokaler Branch aus der Referenz test/feature_branch erstellt werden:

git checkout -b local_feature_branch test_repo/feature_branch

git checkout -b local_feature_branch test_repo/feature_branch

Der neue lokale Branch wird erstellt und HEAD zeigt auf den neuesten Remote-Inhalt.

origin mit git fetch synchronisieren

Das folgende Beispiel zeigt, wie das lokale Repository mit dem master-Branch des zentralen Repositorys synchronisiert wird:

git fetch origin

git fetch origin

Die Ausgabe zeigt die heruntergeladenen Branches:

git fetch origin output

b341bc3..32a45b1  master     -> origin/master
b341bc3..7a52a22  develop    -> origin/develop
* [new branch]      some-feature -> origin/some-feature

Rufen Sie git log mit origin/master als Filter auf, um die Commits anzuzeigen, die dem upstream master hinzugefügt wurden:

git log --oneline master..origin/master

git log --oneline master..origin/master

Überprüfen Sie die Änderungen und führen Sie diese in den lokalen master-Branch ein:

git checkout master && git log origin/master

git checkout master
git log origin/master

Führen Sie git merge origin/master aus, um mit den upstream-Entwicklungen zu synchronisieren:

git merge

git merge origin/master

Ein typisches Zusammenarbeitsszenario

Hier ist ein Szenario, das Ihnen hilft, dieses Konzept besser zu verstehen.

Angenommen, es gibt ein kleines Entwicklungsteam, bestehend aus zwei Entwicklern, Alice und Bob. Sie arbeiten an einem Projekt, das in einem Remote-Git-Repository namens origin gehostet wird. Alice klont das Repository auf ihren lokalen Rechner und beginnt, am main-Branch zu arbeiten, während Bob an einem separaten Branch namens feature-branch arbeitet.

1- Alice erstellt eine neue Datei namens README.md und nimmt einige Änderungen daran vor. Anschließend committet und pusht sie ihre Änderungen in den main-Branch des origin-Repositorys:

$ git add README.md
$ git commit -m "Add README file"
$ git push origin main

2- Inzwischen hat Bob einige Änderungen am feature-branch vorgenommen und diese in das origin-Repository gepusht:

$ git add some_file.txt
$ git commit -m "Add new feature"
$ git push origin feature-branch

3- Alice bemerkt, dass sie Bobs Änderungen in ihre eigene Arbeit integrieren muss, und ruft daher die Änderungen aus dem origin-Repository ab:

$ git fetch origin

4- Nach dem Fetch kann Alice sehen, dass es neue Änderungen im feature-branch gibt:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

5- Alice kann nun Bobs Änderungen in ihren main-Branch zusammenführen:

$ git merge origin/feature-branch

6- Alice löst alle Merge-Konflikte und pusht dann ihre Änderungen in das origin-Repository:

$ git push origin main

7- Bob kann nun die von Alice vorgenommenen Änderungen abrufen:

$ git fetch origin

8- Bob kann nun sehen, dass es neue Änderungen im main-Branch gibt:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

9- Bob kann die von Alice vorgenommenen Änderungen in seinen feature-branch zusammenführen:

$ git merge origin/main

10- Bob löst alle Merge-Konflikte und pusht dann seine Änderungen in das origin-Repository:

$ git push origin feature-branch

Und so setzt sich der Zyklus fort, wobei sowohl Alice als auch Bob git fetch verwenden, um die Änderungen des jeweils anderen zu verfolgen und eigene Änderungen in das origin-Repository zu pushen. Durch die Verwendung von git fetch können sie ihr lokales Repository mit den Änderungen ihrer Teammitglieder auf dem neuesten Stand halten, was dazu beiträgt, Konflikte zu vermeiden und einen reibungslosen Kollaborationsprozess sicherzustellen.

Git fetch vs. git pull

Sowohl git fetch als auch git pull werden zum Herunterladen von Inhalten aus dem Remote-Repository verwendet. Der Befehl git fetch führt Änderungen nicht automatisch in Ihre lokalen Branches ein; er aktualisiert lediglich Ihre Remote-Tracking-Branches. Der abgerufene Inhalt beeinflusst Ihr lokales Arbeitsverzeichnis nicht, sodass Sie Commits sicher überprüfen können, bevor Sie diese zusammenführen. Der Befehl git pull lädt neue Inhalte herunter und führt diese automatisch in Ihren aktuellen Branch ein. Dies kann zu Merge-Konflikten führen, daher wird empfohlen, git pull nur auszuführen, wenn Ihre Arbeitskopie sauber ist.

Kurz gesagt ist git pull in etwa äquivalent zu git fetch gefolgt von git merge:

git pull origin main
# is similar to:
git fetch origin
git merge origin/main

Wann git fetch verwendet werden sollte

Greifen Sie auf git fetch zurück, wenn Sie:

Änderungen sehen möchten, bevor Sie diese integrieren. Führen Sie zuerst einen Fetch durch, untersuchen Sie dann mit git log origin/main.. oder git diff main origin/main, und führen Sie den Merge erst durch, wenn Sie bereit sind.
Remote-Tracking-Branches aktualisieren möchten, ohne Ihre Arbeit zu berühren. Nützlich in der Mitte einer Aufgabe, wenn Ihr Arbeitsverzeichnis nicht committete Änderungen enthält, die ein git pull stören könnte.
Veraltete Branches bereinigen möchten. git fetch --prune entfernt Remote-Tracking-Referenzen für Branches, die auf dem Remote gelöscht wurden.
Den Branch eines Teammitglieds überprüfen möchten. Rufen Sie ihn ab, checken Sie ihn aus, um den Code zu lesen, und entscheiden Sie dann, ob Sie einen Merge durchführen möchten.

Übungen

Übung

Welche Aussagen über den Befehl git fetch sind korrekt?

git fetch lädt Commits, Dateien und Referenzen aus einem Remote-Repository in das lokale Repository herunter.Nach der Verwendung von git fetch werden Ihre lokalen Branches automatisch aktualisiert, um dem Remote-Repository zu entsprechen.git fetch unterstützt Optionen wie --all, --dry-run, --keep, --prune und --depth.Die Verwendung von git fetch versetzt Sie in einen 'detached HEAD'-Zustand, in dem Sie experimentieren können, ohne lokale Branches zu beeinflussen.git fetch gefolgt von git merge ist eine sichere Methode, um Änderungen aus einem Remote-Repository zu überprüfen und zu integrieren.git fetch erzwingt das Zusammenführen von Remote-Änderungen in Ihren aktuellen Branch.