Was sind die Unterschiede zwischen git pullund git fetch?

Im einfachsten Sinne git pullwird a git fetchgefolgt von a git merge.

Sie können git fetchjederzeit eine Option ausführen, um Ihre Remote-Tracking-Zweige unter zu aktualisieren refs/remotes/<remote>/.

Dieser Vorgang ändert niemals eine Ihrer eigenen lokalen Niederlassungen unter refs/headsund ist sicher, ohne Ihre Arbeitskopie zu ändern. Ich habe sogar von Leuten gehört, die git fetchregelmäßig in einem Cron-Job im Hintergrund laufen (obwohl ich dies nicht empfehlen würde).

A git pullist das, was Sie tun würden, um eine lokale Niederlassung mit ihrer Remote-Version auf den neuesten Stand zu bringen und gleichzeitig Ihre anderen Remote-Tracking-Zweige zu aktualisieren.

Git-Dokumentation - Git Pull :

Im Standardmodus git pullwird die Abkürzung für git fetchgefolgt von git merge FETCH_HEAD.

• Wenn Sie verwenden pull, versucht Git, Ihre Arbeit automatisch für Sie zu erledigen.Es ist kontextsensitiv , sodass Git alle gezogenen Commits in dem Zweig zusammenführt, in dem Sie gerade arbeiten. pull Die Commits werden automatisch zusammengeführt, ohne dass Sie sie zuerst überprüfen müssen . Wenn Sie Ihre Filialen nicht genau verwalten, kann es häufig zu Konflikten kommen.

• Wenn Sie dies fetchtun, sammelt Git alle Commits aus dem Zielzweig, die in Ihrem aktuellen Zweig nicht vorhanden sind, und speichert sie in Ihrem lokalen Repository . Sie werden jedoch nicht mit Ihrem aktuellen Zweig zusammengeführt . Dies ist besonders nützlich, wenn Sie Ihr Repository auf dem neuesten Stand halten müssen, aber an etwas arbeiten, das beim Aktualisieren Ihrer Dateien möglicherweise kaputt geht. Um die Commits in Ihren Hauptzweig zu integrieren, verwenden Sie merge.

Es ist wichtig, die Designphilosophie von git der Philosophie eines traditionelleren Versionsverwaltungswerkzeugs wie SVN gegenüberzustellen.

Subversion wurde mit einem Client / Server-Modell entworfen und erstellt. Es gibt ein einziges Repository, das der Server ist, und mehrere Clients können Code vom Server abrufen, daran arbeiten und ihn dann wieder auf den Server übertragen. Es wird davon ausgegangen, dass der Client den Server immer dann kontaktieren kann, wenn er eine Operation ausführen muss.

Git wurde entwickelt, um ein verteilteres Modell zu unterstützen, ohne dass ein zentrales Repository erforderlich ist (obwohl Sie sicherlich eines verwenden können, wenn Sie möchten). Außerdem wurde git so konzipiert, dass der Client und der "Server" nicht gleichzeitig online sein müssen. Git wurde so konzipiert, dass Personen mit einem unzuverlässigen Link sogar Code per E-Mail austauschen können. Es ist möglich, vollständig getrennt zu arbeiten und eine CD zu brennen, um Code über Git auszutauschen.

Um dieses Modell zu unterstützen, verwaltet git ein lokales Repository mit Ihrem Code sowie ein zusätzliches lokales Repository, das den Status des Remote-Repositorys widerspiegelt. Indem eine Kopie des Remote-Repositorys lokal aufbewahrt wird, kann git die erforderlichen Änderungen herausfinden, auch wenn das Remote-Repository nicht erreichbar ist. Wenn Sie die Änderungen später an eine andere Person senden müssen, kann git sie als eine Reihe von Änderungen ab einem dem Remote-Repository bekannten Zeitpunkt übertragen.

• git fetch ist der Befehl "Meine lokale Kopie des Remote-Repositorys auf den neuesten Stand bringen".

• git pull sagt "Bringen Sie die Änderungen im Remote-Repository dahin, wo ich meinen eigenen Code aufbewahre."

Normalerweise git pullgeschieht dies durch agit fetch , um die lokale Kopie des Remote-Repositorys auf den neuesten zu bringen, und dann die Änderungen in Ihrem eigenen Code-Repository und möglicherweise in Ihrer Arbeitskopie zusammenführen.

Beachten Sie, dass sich auf Ihrer Workstation häufig mindestens drei Kopien eines Projekts befinden. Eine Kopie ist Ihr eigenes Repository mit Ihrem eigenen Commit-Verlauf. Die zweite Kopie ist Ihre Arbeitskopie, in der Sie bearbeiten und erstellen. Die dritte Kopie ist Ihre lokale "zwischengespeicherte" Kopie eines Remote-Repositorys.

Hier ist Oliver Steeles Bild davon, wie alles zusammen passt :

Wenn genügend Interesse besteht, könnte ich das Bild möglicherweise aktualisieren, um es hinzuzufügen git clone und git merge...

Ein Anwendungsfall von git fetchist, dass im Folgenden alle Änderungen in der Remote-Verzweigung seit Ihrem letzten Pull angezeigt werden. Sie können also vor dem eigentlichen Pull überprüfen, ob sich die Dateien in Ihrer aktuellen Verzweigung und Arbeitskopie ändern können.

git fetch
git diff ...origin

Informationen zur Doppel- und Dreifachpunktsyntax im Befehl diff finden Sie unter: https://git-scm.com/docs/git-diff

Es hat mich ein bisschen gekostet zu verstehen, was der Unterschied war, aber das ist eine einfache Erklärung. masterIn Ihrem lokalen Host befindet sich eine Niederlassung.

Wenn Sie ein Repository klonen, rufen Sie das gesamte Repository auf Ihren lokalen Host ab. Dies bedeutet, dass Sie zu diesem Zeitpunkt einen Ursprungs- / Master-Zeiger auf HEADund einen Master-Zeiger auf denselben haben HEAD.

Wenn Sie anfangen zu arbeiten und Commits ausführen, bewegen Sie den Master-Zeiger auf HEAD+ Ihre Commits. Der Ursprungs- / Master-Zeiger zeigt jedoch immer noch auf das, was er beim Klonen war.

Der Unterschied wird also sein:

• Wenn Sie dies tun git fetch, werden nur alle Änderungen im Remote-Repository ( GitHub ) abgerufen und der Ursprungs- / Master-Zeiger auf verschobenHEAD . In der Zwischenzeit zeigt Ihr lokaler Filialleiter immer wieder darauf, wo er sich befindet.
• Wenn Sie eine git pull , werden im Grunde genommen (wie zuvor erläutert) neue Änderungen an Ihrem Hauptzweig zusammengeführt und der Zeiger auf verschoben HEAD.

Manchmal hilft eine visuelle Darstellung.

Kurz

git fetchist ähnlich, wird pullaber nicht zusammengeführt. dh es ruft Remote-Updates ab ( refsund objects), aber Ihr lokales bleibt gleich (dh origin/masterwird aktualisiert, masterbleibt aber gleich).

git pull wird von einer Fernbedienung heruntergezogen und sofort zusammengeführt.

Mehr

git clone klont ein Repo.

git rebaseSpeichert Daten aus Ihrer aktuellen Filiale, die sich nicht in der Upstream-Filiale befindet, in einem temporären Bereich. Ihre Filiale ist jetzt dieselbe wie vor Beginn Ihrer Änderungen. Damit,git pull -rebase wird ziehen Sie die Remote - Änderungen nach unten, zurückspulen Ihre lokale Niederlassung, wiederholen Sie Ihre Änderungen über die Spitze der aktuellen Zweig eins nach dem anderen , bis Sie up-to-date.

Außerdem git branch -awird Ihnen genau gezeigt, was mit all Ihren Filialen los ist - lokal und remote.

Dieser Blog-Beitrag war nützlich:

Der Unterschied zwischen Git Pull, Git Fetch und Git Clone (und Git Rebase) - Mike Pearce

und Abdeckungen git pull, git fetch, git cloneundgit rebase .

====

AKTUALISIEREN

Ich dachte, ich würde dies aktualisieren, um zu zeigen, wie Sie dies in der Praxis tatsächlich verwenden würden.

1. Aktualisieren Sie Ihr lokales Repo von der Fernbedienung (aber nicht zusammenführen):

   git fetch 
   

2. Lassen Sie uns nach dem Herunterladen der Updates die Unterschiede sehen:

   git diff master origin/master 
   

3. Wenn Sie mit diesen Updates zufrieden sind, führen Sie Folgendes zusammen:

   git pull
   

Anmerkungen:

Zu Schritt 2: Weitere Informationen zu Unterschieden zwischen lokalen und Fernbedienungen finden Sie unter: Wie vergleiche ich einen lokalen Git-Zweig mit seinem Remote-Zweig?

Zu Schritt 3: Es ist wahrscheinlich genauer (z. B. bei einem sich schnell ändernden Repo), git rebase originhier ein zu machen. Siehe @ Justin Ohms Kommentar in einer anderen Antwort.

Siehe auch: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

git-pull - Abrufen aus einem anderen Repository oder einem lokalen Zweig und Zusammenführen mit diesem
ZUSAMMENFASSUNG

Git Pull ...
BESCHREIBUNG

Führt git-fetch mit den angegebenen Parametern aus und ruft git-merge auf, um das zusammenzuführen 
Kopf (e) in den aktuellen Zweig abgerufen. Ruft mit --rebase git-rebase auf
statt git-merge.

Beachten Sie, dass Sie verwenden können. (aktuelles Verzeichnis) als <Repository> zum Abrufen
aus dem lokalen Repository - Dies ist nützlich, wenn lokale Zweige zusammengeführt werden 
in den aktuellen Zweig.

Beachten Sie auch, dass Optionen für Git-Pull selbst und das zugrunde liegende Git-Merge gedacht sind 
muss vor den für git-fetch vorgesehenen Optionen angegeben werden.

Sie würden ziehen, wenn Sie möchten, dass die Historien zusammengeführt werden. Sie würden abrufen, wenn Sie nur den Codez möchten, da eine Person hier einige Artikel markiert hat.

Sie können aus einem Remote-Repository abrufen, die Unterschiede anzeigen und dann ziehen oder zusammenführen.

Dies ist ein Beispiel für ein Remote-Repository namens originund einen Zweig namens masterTracking the Remote-Zweig origin/master:

git checkout master                                                  
git fetch                                        
git diff origin/master
git rebase origin master

Die kurze und einfache Antwort ist , dass git pullist einfach , git fetchgefolgt vongit merge .

Es ist sehr wichtig zu beachten , dass git pullwird automatisch , ob Sie es mögen oder nicht fusionieren . Dies könnte natürlich zu Zusammenführungskonflikten führen. Angenommen, Ihre Fernbedienung ist originund Ihre Niederlassung ist master. Wenn Sie git diff origin/mastervor dem Ziehen eine Vorstellung von möglichen Zusammenführungskonflikten haben und Ihre lokale Niederlassung entsprechend vorbereiten können.

Neben Ziehen und Schieben, einige Workflows beinhalten git rebase, wie diese, die ich aus dem verlinkten Artikel paraphrasieren:

git pull origin master
git checkout foo-branch
git rebase master
git push origin foo-branch

Wenn Sie sich in einer solchen Situation befinden, könnten Sie versucht sein git pull --rebase. Wenn Sie nicht wirklich wissen, was Sie tun, würde ich davon abraten. Diese Warnung stammt von der manSeite für git-pull, Version 2.3.5:

Dies ist eine potenziell gefährliche Betriebsart. Es schreibt die Geschichte neu, was nicht gut ist, wenn Sie diese Geschichte bereits veröffentlicht haben. Verwenden Sie diese Option nur, wenn Sie git-rebase (1) sorgfältig gelesen haben.

OK , hier sind einige Informationen zu git pullund git fetch, damit Sie die tatsächlichen Unterschiede verstehen können. In wenigen einfachen Worten erhält fetch die neuesten Daten, aber nicht die Codeänderungen und wird nicht mit Ihrem aktuellen lokalen Zweigstellencode in Konflikt geraten , sondern ziehen get Der Code ändert sich und führt ihn zu Ihrer lokalen Niederlassung zusammen. Lesen Sie weiter, um weitere Details zu den einzelnen Zweigen zu erhalten:

Git holen

Es werden alle Refs und Objekte sowie alle neuen Zweige in Ihr lokales Repository heruntergeladen ...

Rufen Sie Zweige und / oder Tags (zusammen "refs") aus einem oder mehreren anderen Repositorys zusammen mit den Objekten ab, die zum Vervollständigen ihrer Historien erforderlich sind. Remote-Tracking-Zweige werden aktualisiert (Möglichkeiten zur Steuerung dieses Verhaltens finden Sie in der folgenden Beschreibung).

Standardmäßig wird auch jedes Tag abgerufen, das auf die abgerufenen Historien verweist. Der Effekt besteht darin, Tags abzurufen, die auf Zweige zeigen, an denen Sie interessiert sind. Dieses Standardverhalten kann mithilfe der Optionen --tags oder --no-tags oder durch Konfigurieren von remote..tagOpt geändert werden. Durch die Verwendung einer Referenzspezifikation, die Tags explizit abruft, können Sie Tags abrufen, die nicht auf Zweige verweisen, an denen Sie ebenfalls interessiert sind.

git fetch kann entweder von einem einzelnen benannten Repository oder einer URL oder von mehreren Repositorys gleichzeitig abgerufen werden, wenn dies angegeben ist und eine Fernbedienung vorhanden ist. Eintrag in der Konfigurationsdatei. (Siehe git-config 1 ).

Wenn keine Fernbedienung angegeben ist, wird standardmäßig die Ursprungsfernbedienung verwendet, es sei denn, für die aktuelle Verzweigung ist ein Upstream-Zweig konfiguriert.

Die Namen der abgerufenen Refs werden zusammen mit den Objektnamen, auf die sie zeigen, in .git / FETCH_HEAD geschrieben. Diese Informationen können von Skripten oder anderen Git-Befehlen wie Git-Pull verwendet werden.

Git Pull

Es werden die Änderungen von Remote auf den aktuellen Zweig in lokalen ...

Integriert Änderungen aus einem Remote-Repository in den aktuellen Zweig. Im Standardmodus ist Git Pull eine Abkürzung für Git Fetch, gefolgt von Git Merge FETCH_HEAD.

Genauer gesagt führt git pull git fetch mit den angegebenen Parametern aus und ruft git merge auf, um die abgerufenen Verzweigungsköpfe mit dem aktuellen Zweig zusammenzuführen. Mit --rebase wird git rebase anstelle von git merge ausgeführt.

sollte der Name eines Remote-Repositorys sein, der an git-fetch 1 übergeben wird . kann eine beliebige entfernte Referenz (zum Beispiel den Namen eines Tags) oder sogar eine Sammlung von Referenzen mit entsprechenden Fernverfolgungszweigen (z. B. refs / Heads / : refs / remotes / origin / ) benennen, aber normalerweise ist es der Name eines Zweigs im Remote-Repository.

Standardwerte für und werden aus der Konfiguration "remote" und "merge" für den aktuellen Zweig gelesen, wie durch git-branch --track festgelegt.

Ich erstelle auch das Bild unten, um Ihnen zu zeigen, wie git fetchund wie Sie git pullzusammenarbeiten ...

Diese interaktive grafische Darstellung ist sehr hilfreich, um Git zu verstehen: http://ndpsoftware.com/git-cheatsheet.html

git fetch"lädt" einfach die Änderungen von der Fernbedienung in Ihr lokales Repository herunter. git pulllädt die Änderungen herunter und führt sie in Ihrem aktuellen Zweig zusammen. "Im Standardmodus git pullist die Abkürzung für git fetchgefolgt von git merge FETCH_HEAD."

Bonus:

Wenn ich in den obigen Antworten von Pull & Fetch spreche, möchte ich einen interessanten Trick teilen:

git pull --rebase

Dieser obige Befehl ist der nützlichste Befehl in meinem Git-Leben, der viel Zeit gespart hat.

Versuchen Sie diesen Befehl, bevor Sie Ihre neuen Commits auf den Server übertragen. Die neuesten Serveränderungen werden automatisch synchronisiert (mit einem Abruf + Zusammenführen), und Ihr Commit wird im Git-Protokoll ganz oben platziert. Sie müssen sich keine Gedanken über manuelles Ziehen / Zusammenführen machen.

Details finden Sie unter: http://gitolite.com/git-pull--rebase

Ich möchte eine visuelle Darstellung der Situation haben, um diese Dinge zu erfassen. Vielleicht möchten es auch andere Entwickler sehen, also hier ist meine Ergänzung. Ich bin mir nicht ganz sicher, ob alles korrekt ist. Bitte kommentieren Sie, wenn Sie Fehler finden.

                                         LOCAL SYSTEM
                  . =====================================================    
================= . =================  ===================  =============
REMOTE REPOSITORY . REMOTE REPOSITORY  LOCAL REPOSITORY     WORKING COPY
(ORIGIN)          . (CACHED)           
for example,      . mirror of the      
a github repo.    . remote repo
Can also be       .
multiple repo's   .
                  .
                  .
FETCH  *------------------>*
Your local cache of the remote is updated with the origin (or multiple
external sources, that is git's distributed nature)
                  .
PULL   *-------------------------------------------------------->*
changes are merged directly into your local copy. when conflicts occur, 
you are asked for decisions.
                  .
COMMIT            .                             *<---------------*
When coming from, for example, subversion, you might think that a commit
will update the origin. In git, a commit is only done to your local repo.
                  .
PUSH   *<---------------------------------------*
Synchronizes your changes back into the origin.

Einige Hauptvorteile für einen abgerufenen Spiegel der Fernbedienung sind:

• Leistung (scrollen Sie durch alle Commits und Nachrichten, ohne zu versuchen, sie durch das Netzwerk zu drücken)
• Feedback zum Status Ihres lokalen Repos (zum Beispiel verwende ich den SourceTree von Atlassian, der mir eine Glühbirne gibt, die anzeigt, ob ich im Vergleich zum Ursprung einen Commit vor oder hinter mir habe. Diese Informationen können mit einem GIT FETCH aktualisiert werden).

Ich habe auch damit zu kämpfen. Tatsächlich bin ich mit einer Google-Suche genau der gleichen Frage hierher gekommen. Das Lesen all dieser Antworten zeichnete schließlich ein Bild in meinen Kopf und ich beschloss, dies zu überprüfen, indem ich den Zustand der 2 Repositorys und 1 Sandbox sowie die im Laufe der Zeit ausgeführten Aktionen betrachtete, während ich mir die Version davon ansah. Also hier ist, was ich mir ausgedacht habe. Bitte korrigieren Sie mich, wenn ich irgendwo etwas durcheinander gebracht habe.

Die drei Repos mit einem Fetch:

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - fetch               -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     -                     -
- @ R01             -     - @ R01+              -     - @R01+               -
---------------------     -----------------------     -----------------------

Die drei Repos mit einem Zug

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - pull                -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     - merged with R02     -
- @ R01             -     - @ R01+              -     - @R02+               -
---------------------     -----------------------     -----------------------

Dies half mir zu verstehen, warum ein Abruf ziemlich wichtig ist.

Der Unterschied zwischen GIT Fetch und GIT Pull lässt sich anhand des folgenden Szenarios erklären: (Beachten Sie, dass Bilder lauter sprechen als Worte! Ich habe eine bildliche Darstellung bereitgestellt.)

Nehmen wir ein Beispiel, in dem Sie mit Ihren Teammitgliedern an einem Projekt arbeiten. Sie werden also ein Hauptzweig des Projekts sein, und alle Mitwirkenden müssen es in ihr eigenes lokales Repository einteilen und dann an diesem lokalen Zweig arbeiten, um Module zu ändern / hinzuzufügen, und dann zum Hauptzweig zurückkehren.

So Anfangszustand der beiden Zweige , wenn gegabelt Sie das Hauptprojekt auf Ihrem lokalen Repository wird wie this- sein ( A, Bund Csind Module bereits des Projekts abgeschlossen)

Jetzt haben Sie begonnen, an dem neuen Modul zu arbeiten (angenommen D), und wenn Sie das DModul abgeschlossen haben, möchten Sie es in den Hauptzweig verschieben. In der Zwischenzeit hat jedoch einer Ihrer Teamkollegen ein neues Modul Eentwickelt Fund geändert C.
Was nun passiert ist, ist, dass Ihr lokales Repository hinter dem ursprünglichen Fortschritt des Projekts fehlt und das Übertragen Ihrer Änderungen auf den Hauptzweig zu Konflikten führen und Dzu Fehlfunktionen Ihres Moduls führen kann .

Um solche Probleme zu vermeiden und parallel zum ursprünglichen Projektfortschritt zu arbeiten, gibt es zwei Möglichkeiten:

1. Git Fetch- Hiermit werden alle Änderungen heruntergeladen, die am Ursprungs- / Hauptzweigprojekt vorgenommen wurden und in Ihrem lokalen Zweig nicht vorhanden sind. Und wartet, bis der Befehl Git Merge die Änderungen übernimmt, die in Ihr Repository oder Ihren Zweig abgerufen wurden.

Jetzt können Sie die Dateien sorgfältig überwachen, bevor Sie sie mit Ihrem Repository zusammenführen. Und Sie können Dbei Bedarf auch aufgrund von Modified ändern C.

2. Git Pull - Hiermit wird Ihr lokaler Zweig mit dem Ursprungs- / Hauptzweig aktualisiert, dh es handelt sich tatsächlich um eine Kombination aus Git Fetch und Git Merge nacheinander. Dies kann jedoch zu Konflikten führen. Es wird daher empfohlen, Git Pull mit einer sauberen Kopie zu verwenden.

Wir sagen einfach:

git pull == git fetch + git merge

Wenn Sie ausführen git pull, müssen Sie die Daten nicht mit lokal zusammenführen. Wenn Sie ausführen git fetch, bedeutet dies, dass Sie ausgeführt werden müssen, git mergeum den neuesten Code auf Ihren lokalen Computer zu übertragen. Andernfalls würde der lokale Maschinencode ohne Zusammenführung nicht geändert.

Wenn Sie also in der Git Gui abrufen, müssen Sie die Daten zusammenführen. Durch das Abrufen selbst werden die Codeänderungen bei Ihrem lokalen Benutzer nicht vorgenommen. Sie können dies überprüfen, wenn Sie den Code aktualisieren, indem Sie einmal abrufen und sehen; Der Code wird sich nicht ändern. Dann führen Sie zusammen ... Sie sehen den geänderten Code.

git fetchRuft den Code vom Remote-Server zu Ihren Tracking-Zweigen in Ihrem lokalen Repository ab. Wenn Ihre Remote - Name origin(der Standard) , dann werden diese Zweige innerhalb sein origin/, zum Beispiel origin/master, origin/mybranch-123etc. Diese sind nicht Ihre Stromzweige, sie sind lokale Kopien dieses Zweiges vom Server.

git pullführt a aus git fetch, führt dann aber auch den Code aus dem Tracking-Zweig in Ihre aktuelle lokale Version dieses Zweigs ein. Wenn Sie für diese Änderungen noch nicht bereit sind, git fetchzuerst.

git fetchwird Remote - Niederlassungen abrufen , so dass Sie git diffoder git mergesie mit dem aktuellen Zweig. git pullführt Fetch auf dem Remote-Brach aus, der vom aktuellen Zweig verfolgt wird, und führt dann das Ergebnis zusammen. Sie können verwenden, git fetchum festzustellen, ob Aktualisierungen für den Remote-Zweig vorhanden sind, ohne diese mit Ihrem lokalen Zweig zusammenführen zu müssen.

Git Fetch

Sie laden Änderungen in Ihren lokalen Zweig vom Ursprung durch Abrufen herunter. Fetch fragt das Remote-Repo nach allen Commits, die andere gemacht haben, die Sie jedoch nicht in Ihrem lokalen Repo haben. Fetch lädt diese Commits herunter und fügt sie dem lokalen Repository hinzu.

Git Merge

Sie können Änderungen, die durch Abrufen heruntergeladen wurden, mit dem Befehl zum Zusammenführen anwenden. Beim Zusammenführen werden die aus dem Abruf abgerufenen Commits übernommen und versucht, sie Ihrem lokalen Zweig hinzuzufügen. Durch die Zusammenführung wird der Festschreibungsverlauf Ihrer lokalen Änderungen beibehalten, sodass Git weiß, wie andere Ihre Änderungen zusammenführen können, wenn Sie Ihren Zweig mit Push teilen.

Git Pull

Abrufen und Zusammenführen werden häufig genug ausgeführt, sodass ein Befehl erstellt wurde, der die beiden Elemente "Ziehen" kombiniert. Pull führt einen Abruf und dann eine Zusammenführung durch, um die heruntergeladenen Commits zu Ihrer lokalen Niederlassung hinzuzufügen.

Der einzige Unterschied zwischen git pullund git fetchist, dass:

git pull zieht von einem entfernten Zweig und führt ihn zusammen.

git fetch ruft nur vom Remote-Zweig ab, wird aber nicht zusammengeführt

dh git pull = git fetch + git merge ...

In einfachen Worten, wenn Sie in ein Flugzeug ohne Internetverbindung steigen wollten ... bevor Sie abfliegen, könnten Sie es einfach tun git fetch origin <master> . Es würde alle Änderungen in Ihren Computer abrufen, ihn jedoch von Ihrem lokalen Entwicklungs- / Arbeitsbereich trennen.

Im Flugzeug können Sie Änderungen an Ihrem lokalen Arbeitsbereich vornehmen und ihn dann mit dem, was Sie abgerufen haben, zusammenführen und potenzielle Zusammenführungskonflikte ohne Verbindung zum Internet lösen. Und wenn nicht jemand neue widersprüchliche Änderungen am Remote-Repository vorgenommen hat, können Sie git push origin <branch>Ihren Kaffee holen, sobald Sie am Ziel angekommen sind .

Aus diesem fantastischen Atlassian-Tutorial :

Der git fetchBefehl lädt Commits, Dateien und Refs von einem Remote-Repository in Ihr lokales Repository herunter.

Abrufen ist das, was Sie tun, wenn Sie sehen möchten, woran alle anderen gearbeitet haben. Es ähnelt dem SVN-Update darin, dass Sie sehen können, wie sich der zentrale Verlauf entwickelt hat, Sie jedoch nicht gezwungen werden, die Änderungen tatsächlich in Ihrem Repository zusammenzuführen. Git isoliert abgerufene Inhalte von vorhandenen lokalen Inhalten . Dies hat keinerlei Auswirkungen auf Ihre lokale Entwicklungsarbeit . Abgerufene Inhalte müssen mit dem git checkoutBefehl explizit ausgecheckt werden . Auf diese Weise können Sie Commits sicher abrufen, bevor Sie sie in Ihr lokales Repository integrieren.

Wenn Inhalte von einem Remote - Repository Herunterladen git pullund git fetchBefehlen zur Verfügung , die Aufgabe zu erfüllen. Sie können git fetchdie "sichere" Version der beiden Befehle in Betracht ziehen . Der Remote-Inhalt wird heruntergeladen, der Arbeitsstatus Ihres lokalen Repositorys wird jedoch nicht aktualisiert, sodass Ihre aktuelle Arbeit erhalten bleibt. git pullIst die aggressivere Alternative, wird der Remote-Inhalt für den aktiven lokalen Zweig heruntergeladen und sofort ausgeführt git merge, um ein Zusammenführungs-Commit für den neuen Remote-Inhalt zu erstellen. Wenn Änderungen anstehen, führt dies zu Konflikten und startet den Ablauf der Zusammenführungskonfliktlösung.

Mit git pull:

• Sie bekommen keine Isolation.
• Es wirkt sich auf Ihre lokale Entwicklung aus.
• Es muss nicht explizit ausgecheckt werden. Weil es implizit agit merge .
• Es ist im Grunde NICHT sicher. Es ist aggressiv.
• Anders als dort, git fetchwo es nur Ihre betrifft .git/refs/remotes, wirkt sich Git Pull sowohl auf Ihre als auch auf Ihre aus.git/refs/remotes .git/refs/heads/

Hmmm ... also wenn ich die Arbeitskopie nicht aktualisiere git fetch, wo nehme ich dann Änderungen vor? Wo speichert Git Fetch die neuen Commits?

Gute Frage. Es platziert es irgendwo isoliert von Ihrer Arbeitskopie. Aber wieder wo? Lass es uns herausfinden.

Führen Sie in Ihrem Projektverzeichnis (dh wo Sie Ihre gitBefehle ausführen) Folgendes aus:

1. ls. Dies zeigt die Dateien und Verzeichnisse. Nichts cooles, ich weiß.

2. Jetzt tu es ls -a. Daraufhin werden Punktdateien angezeigt , dh Dateien, die mit beginnen. .Anschließend wird ein Verzeichnis mit dem Namen angezeigt : .git.

3. Tu es cd .git. Dies wird offensichtlich Ihr Verzeichnis ändern.
4. Jetzt kommt der lustige Teil; tun ls. Sie sehen eine Liste der Verzeichnisse. Wir suchen refs. Tu es cd refs.
5. Es ist interessant zu sehen, was sich in allen Verzeichnissen befindet, aber konzentrieren wir uns auf zwei davon. headsund remotes. Verwenden Sie cd, um auch in ihnen zu überprüfen.
6. Alles git fetch , was Sie tun, aktualisiert die Elemente im /.git/refs/remotesVerzeichnis. Es wird nichts im /.git/refs/headsVerzeichnis aktualisiert .
7. Jeder git pull wird zuerst die git fetchElemente im /.git/refs/remotesVerzeichnis aktualisieren , dann mit Ihrem lokalen Verzeichnis zusammenführen und dann den Kopf im /.git/refs/headsVerzeichnis ändern .

Eine sehr gute Antwort finden Sie auch unter Wo platziert sich 'git fetch'? .

Suchen Sie auch im Beitrag zu den Namenskonventionen für Git-Zweige nach "Schrägstrichnotation" . Es hilft Ihnen besser zu verstehen, wie Git Dinge in verschiedenen Verzeichnissen platziert.

Um den tatsächlichen Unterschied zu sehen

Mach einfach:

git fetch origin master
git checkout master

Wenn der Remote-Master aktualisiert wurde, wird folgende Meldung angezeigt:

Your branch is behind 'origin/master' by 2 commits, and can be fast-forwarded.
  (use "git pull" to update your local branch)

Wenn Sie dies nicht fetchgetan git checkout masterhätten, würde Ihr lokaler Git nicht wissen, dass 2 Commits hinzugefügt wurden. Und es würde nur sagen:

Already on 'master'
Your branch is up to date with 'origin/master'.

Aber das ist veraltet und falsch. Das liegt daran, dass Git Ihnen Feedback nur basierend auf dem gibt, was es weiß. Es ist nicht bekannt, dass neue Commits noch nicht abgeschlossen wurden ...

Gibt es eine Möglichkeit, die neuen Änderungen zu sehen, die in Remote vorgenommen wurden, während lokal an der Zweigstelle gearbeitet wurde?

Einige IDEs (z. B. Xcode) sind sehr intelligent und verwenden das Ergebnis von a git fetchund können die Codezeilen mit Anmerkungen versehen, die im Remote-Zweig Ihres aktuellen Arbeitszweigs geändert wurden. Wenn diese Zeile sowohl durch lokale Änderungen als auch durch Remote-Verzweigung geändert wurde, wird diese Zeile mit Rot versehen. Dies ist kein Zusammenführungskonflikt. Es ist ein potenzieller Zusammenführungskonflikt. Es ist ein Headsup, mit dem Sie den zukünftigen Zusammenführungskonflikt lösen können, bevor Sie ihn git pullvom Remote-Zweig aus ausführen.

Spaß Tipp:

Wenn Sie einen Remote-Zweig abgerufen haben, z. B.:

git fetch origin feature/123

Dann würde dies in Ihr Fernbedienungsverzeichnis gehen. Es ist immer noch nicht in Ihrem lokalen Verzeichnis verfügbar. Es vereinfacht jedoch das Auschecken zu diesem Remote-Zweig durch DWIM (Tun Sie, was ich meine):

git checkout feature/123

Sie müssen nicht mehr tun:

git checkout -b feature/123 origin/feature/123

Mehr dazu hier

Mit Git können chronologisch ältere Commits nach neueren Commits angewendet werden. Aus diesem Grund ist das Übertragen von Commits zwischen Repositorys in zwei Schritte unterteilt:

1. Kopieren neuer Commits vom Remote-Zweig zum Kopieren dieses Remote-Zweigs innerhalb des lokalen Repos.

   (Repo-zu-Repo-Betrieb) master@remote >> remote/origin/master@local

2. Integration neuer Commits in die lokale Niederlassung

   (Inside-Repo-Betrieb) remote/origin/master@local >> master@local

Es gibt zwei Möglichkeiten, Schritt 2 auszuführen. Sie können:

1. Verzweigen Sie den lokalen Zweig nach dem letzten gemeinsamen Vorfahren und fügen Sie neue Commits parallel zu Commits hinzu, die nur für das lokale Repository gelten. Dies wird durch Zusammenführen des Commits und Schließen des Forks abgeschlossen.
2. Fügen Sie nach dem letzten gemeinsamen Vorfahren neue Commits ein und wenden Sie die für das lokale Repository eindeutigen Commits erneut an.

In der gitTerminologie ist Schritt 1 git fetch, Schritt 2 ist git mergeodergit rebase

git pullist git fetchundgit merge

Git ruft mit zwei Befehlen den Zweig der neuesten Version von der Fernbedienung zur lokalen Version ab:

1. git fetch: Git wird die neueste Version von remote auf local übertragen, aber nicht automatisch zusammenführen.      git fetch origin master git log -p master..origin/master git merge origin/master

        Die obigen Befehle bedeuten, dass die neueste Version des Hauptzweigs vom Ursprung vom Remote- zum Ursprungshauptzweig heruntergeladen wird. Und vergleicht dann den lokalen Hauptzweig und den Ursprungshauptzweig. Schließlich zusammenführen.

2. git pull: Git wird die neueste Version von der Fernbedienung herunterladen und in die lokale Version einbinden.

       git pull origin master

        Der obige Befehl entspricht git fetchund git merge. In der Praxis git fetchvielleicht sicherer, da wir vor dem Zusammenführen die Änderungen sehen und entscheiden können, ob sie zusammengeführt werden sollen.

Was ist der Unterschied zwischen git pullund git fetch?

Um dies zu verstehen, müssen Sie zunächst verstehen, dass Ihr lokaler Git nicht nur Ihr lokales Repository verwaltet, sondern auch eine lokale Kopie des Remote-Repositorys.

git fetchbringt Ihre lokale Kopie des Remote-Repositorys auf den neuesten Stand. Wenn Ihr Remote-Repository beispielsweise GitHub ist, möchten Sie möglicherweise alle im Remote-Repository vorgenommenen Änderungen an Ihrer lokalen Kopie des Remote-Repositorys abrufen. Auf diese Weise können Sie Vorgänge wie Vergleichen oder Zusammenführen ausführen.

git pullAuf der anderen Seite werden die Änderungen im Remote-Repository dahin verschoben, wo Sie Ihren eigenen Code aufbewahren. In der Regel git pullwird git fetchzuerst die lokale Kopie des Remote-Repositorys auf den neuesten Stand gebracht und anschließend werden die Änderungen in Ihrem eigenen Code-Repository und möglicherweise in Ihrer Arbeitskopie zusammengeführt.

git pull == (git fetch + git merge)

git fetch ändert sich nicht in lokale Zweige.

Wenn Sie bereits ein lokales Repository mit einer für das gewünschte Projekt eingerichteten Fernbedienung haben, können Sie mit git fetch alle Zweige und Tags für die vorhandene Fernbedienung abrufen. ... Beim Abrufen werden keine Änderungen an lokalen Zweigen vorgenommen. Sie müssen daher einen Remote-Zweig mit einem gepaarten lokalen Zweig zusammenführen, um neu abgerufene Änderungen zu übernehmen. von Github

Der Versuch, klar und einfach zu sein.

Der Befehl git pull ist tatsächlich ein shortcutfor git-Abruf, gefolgt von dem Befehl git merge oder git rebase, abhängig von Ihrer Konfiguration. Sie können Ihr Git-Repository so konfigurieren, dass Git Pull ein Abruf gefolgt von einer Rebase ist.

Eine einfache grafische Darstellung für Anfänger,

Hier,

git pull  

wird Code aus dem Repository abrufen und mit Ihrem lokalen Repository neu erstellen ... in Git Pull besteht die Möglichkeit, dass neue Commits erstellt werden.

aber in ,

Git holen

ruft Code aus dem Repository ab und wir müssen ihn manuell mithilfe von neu starten git rebase

Beispiel: Ich werde vom Server-Master abrufen und ihn in meinem lokalen Master neu starten.

1) Git Pull (Rebase wird automatisch durchgeführt):

git pull origin master

Hier ist der Ursprung Ihr Remote-Repo- Master ist Ihre Branche

2) Git Fetch (muss manuell neu erstellt werden):

git fetch origin master

Es werden Serveränderungen vom Ursprung abgerufen. und es wird in Ihrer Nähe sein, bis Sie es selbst neu starten. Wir müssen Konflikte manuell beheben, indem wir Codes überprüfen.

git rebase origin/master

Dadurch wird der Code in local zurückgesetzt. Stellen Sie vorher sicher, dass Sie in der richtigen Branche sind.

Tatsächlich verwaltet Git eine Kopie Ihres eigenen Codes und des Remote-Repositorys.

Der Befehl git fetchaktualisiert Ihre lokale Kopie, indem Daten aus dem Remote-Repository abgerufen werden. Der Grund, warum wir dies benötigen, ist, dass jemand anderes möglicherweise einige Änderungen am Code vorgenommen hat und Sie sich auf dem Laufenden halten möchten.

Der Befehl git pullbringt die Änderungen im Remote-Repository dahin, wo Sie Ihren eigenen Code aufbewahren. Normalerweise git pullwird dazu zuerst ein 'Git-Abruf' durchgeführt, um die lokale Kopie des Remote-Repositorys auf den neuesten Stand zu bringen. Anschließend werden die Änderungen in Ihrem eigenen Code-Repository und möglicherweise in Ihrer Arbeitskopie zusammengeführt.