Jaka jest różnica między „git pull” a „git fetch”?


11909

Jakie są różnice między git pulli git fetch?


364
Znalazłem dobrze napisany artykuł o git fetch i git pull, który jest wart przeczytania: longair.net/blog/2009/04/16/git-fetch-and-merge
Marcos Oliveira

50
Nasze alternatywne podejście stało się git fetch; git reset --hard origin/masterczęścią naszego przepływu pracy. Wysadza lokalne zmiany, utrzymuje Cię na bieżąco z ALE, ale upewnia się, że nie tylko wprowadzasz nowe zmiany na bieżąco i robisz bałagan. Używamy go od dłuższego czasu i jest w zasadzie o wiele bezpieczniejszy w praktyce. Pamiętaj tylko, aby najpierw dodać / zatwierdzić / ukryć wszelkie prace w toku!
Michael Durrant

25
Upewnij się, że wiesz, jak prawidłowo używać git stash. Jeśli pytasz o „ściągnij” i „pobierz”, być może „skrytka” również będzie wymagała wyjaśnienia ...
Henry Heleine,

35
Wielu ludzi pochodzących z Mercurial nadal używa „git pull”, myśląc, że jest to odpowiednik „hg pull”. Który to nie jest. Odpowiednikiem Git „hg pull” jest „git fetch”.
Serge Shultz

7
polecenie git fetch pobiera zaktualizowany kod z gałęzią, a także otrzyma nowo dodane gałęzie w twoim lokalnym, polecenie git pull pobiera tylko zaktualizowany kod tylko aktualnego oddziału
Kartik Patel

Odpowiedzi:


9913

W najprostszych słowach, git pullrobi git fetchpo której następuje git merge.

W git fetchdowolnym momencie możesz zrobić aktualizację swoich oddziałów do zdalnego śledzenia refs/remotes/<remote>/.

Ta operacja nigdy nie zmienia żadnych lokalnych oddziałów refs/headsi jest bezpieczna bez zmiany kopii roboczej. Słyszałem nawet o ludziach, którzy git fetchokresowo pracują w tle w cronie (chociaż nie poleciłbym tego robić).

To, git pullco zrobiłbyś, aby zaktualizować lokalny oddział do jego wersji zdalnej, jednocześnie aktualizując inne oddziały zdalnego śledzenia.

Dokumentacja Git - Git Pull :

W trybie domyślnym git pulljest skrótem, git fetchpo którym następuje git merge FETCH_HEAD.


326
„„ Git pull ”to to, co byś zrobił, aby zaktualizować swoje repozytorium” <- czy aktualizacja repozytorium nie została już wykonana przez pobranie? nie masz na myśli, że dzięki temu Twoje lokalne oddziały są na bieżąco z oddziałami zdalnymi? Do scalenia: Łączy odległe gałęzie z lokalnymi kopiami tych gałęzi lub co dokładnie tutaj łączy?
Albert,

193
@Albert: Tak, jest dziwnie sformułowany. git pullzawsze połączy się z bieżącym oddziałem . Więc wybrać gałąź chcesz ciągnąć od , i ciągnie go do bieżącego oddziału. Oddział z może być lokalny lub zdalny; może to być nawet gałąź zdalna, która nie jest zarejestrowana git remote(co oznacza, że ​​podajesz adres URL w git pullwierszu poleceń).
intuicyjnie

128
@espertus: Nie. Pchanie nigdy nie powoduje automatycznego scalenia. Oczekuje się, że użytkownik pociągnie, lokalnie rozwiąże wszelkie konflikty scalania, a następnie wróci do zdalnego.
Greg Hewgill

32
Jeśli jestem /home/alice/i robię git fetch /home/bob, jakie parametry powinienem przekazać do następnego git merge?
ripper234

105
Uwaga dla osób uczących się Git: pullnie można go naśladować za pomocą znaku fetchplus a merge. Właśnie pobrałem zmianę, w której zmienia się tylko zdalny wskaźnik gałęzi i mergenie chce nic robić. pull, z drugiej strony, szybko przesyła moją gałąź śledzenia.
Roman Starkov,

2170
  • Kiedy korzystasz pull, Git próbuje automatycznie wykonać za Ciebie pracę. Jest wrażliwy na kontekst , więc Git połączy wszelkie wyciągnięte zatwierdzenia z gałęzi, w której obecnie pracujesz. pull Automatycznie scali te zatwierdzenia, nie pozwalając na ich przejrzenie w pierwszej kolejności . Jeśli nie będziesz ściśle zarządzał swoimi oddziałami, możesz napotykać częste konflikty.

  • Gdy Ty fetch, Git zbiera wszelkie zatwierdzenia z gałęzi docelowej, które nie istnieją w bieżącym oddziale i zapisuje je w lokalnym repozytorium . Jednak nie łączy ich z bieżącym oddziałem . Jest to szczególnie przydatne, jeśli chcesz aktualizować swoje repozytorium, ale pracujesz nad czymś, co może się zepsuć, jeśli zaktualizujesz swoje pliki. Aby zintegrować zatwierdzenia z gałęzią master, używasz merge.


33
Uzgodniony, świetny komentarz. Dlatego nienawidzę git pull. Kiedy miałoby kiedykolwiek sens pozwolić, aby narzędzie do poprawiania kodu dokonywało za Ciebie edycji? I czy nie to właśnie łączy scalanie dwóch plików? Co jeśli te dwie zmiany są fizycznie oddzielone w pliku, ale logicznie sprzeczne?
Lee Dixon

126
@elexhobby w skrócie, git fetchaktualizuje tylko .git/katalog (AKA: lokalne repozytorium) i nic poza .git/(AKA: działające drzewo). Nie zmienia twoich lokalnych oddziałów i też nie dotyka master. Dotyka remotes/origin/masterjednak (patrz git branch -avv). Jeśli masz więcej pilotów, spróbuj git remote update. To jest git fetchdla wszystkich pilotów w jednym poleceniu.
Tino

24
@Tino twoje jest naprawdę najważniejszym punktem. Ludzie mogą nie wiedzieć, że „zdalne” gałęzie są w rzeczywistości przechowywane jako zbiór skrótów .git/refs/remotes/origin/.
Chris

13
Podczas pobierania Git gromadzi wszelkie zatwierdzenia z gałęzi docelowej, które nie istnieją w bieżącym oddziale i zapisuje je w lokalnym repozytorium - jak mogę zobaczyć, co zostało przyniesione ze zdalnego i jak scalić je z moimi lokalnymi oddziałami?
ア レ ッ ク ス

13
@Tino Nadal nie rozumiem, o co chodzi? Po co używać pobierania, jeśli tylko się aktualizuje .git? Jaka jest zamierzona korzyść i co mam potem zrobić?
BadHorsie

1209

Ważne jest, aby porównać filozofię projektowania git z filozofią bardziej tradycyjnego narzędzia kontroli źródła, takiego jak SVN.

Subversion zostało zaprojektowane i zbudowane w modelu klient / serwer. Istnieje jedno repozytorium, którym jest serwer, a kilku klientów może pobrać kod z serwera, pracować na nim, a następnie przekazać go z powrotem do serwera. Zakłada się, że klient zawsze może skontaktować się z serwerem, gdy musi wykonać operację.

Git został zaprojektowany do obsługi bardziej rozproszonego modelu bez potrzeby posiadania centralnego repozytorium (choć z pewnością możesz go użyć, jeśli chcesz). Ponadto git został zaprojektowany tak, aby klient i „serwer” nie musiały być jednocześnie w trybie online. Git został zaprojektowany tak, aby ludzie z niewiarygodnego linku mogli nawet wymieniać kod przez e-mail. Możliwe jest całkowicie odłączone działanie i nagranie płyty CD w celu wymiany kodu przez git.

Aby wesprzeć ten model, git utrzymuje lokalne repozytorium z twoim kodem, a także dodatkowe lokalne repozytorium, które odzwierciedla stan repozytorium zdalnego. Zachowując lokalnie kopię zdalnego repozytorium, git może ustalić potrzebne zmiany, nawet gdy zdalne repozytorium jest nieosiągalne. Później, gdy musisz wysłać zmiany do kogoś innego, git może przenieść je jako zestaw zmian od momentu znanego zdalnemu repozytorium.

  • git fetch to polecenie, które mówi „zaktualizuj moją lokalną kopię zdalnego repozytorium”.

  • git pull mówi „przenieś zmiany w zdalnym repozytorium do miejsca, w którym przechowuję własny kod”.

Zwykle git pullrobi to git fetch, aktualizując lokalną kopię zdalnego repozytorium, a następnie scalając zmiany z własnym repozytorium kodu i ewentualnie kopią roboczą.

Należy pamiętać, że na stacji roboczej często znajdują się co najmniej trzy kopie projektu. Jedna kopia to twoje własne repozytorium z własną historią zatwierdzeń. Druga kopia to kopia robocza, w której edytujesz i budujesz. Trzecia kopia to lokalna „buforowana” kopia zdalnego repozytorium.


75
Technicznie, lokalne i zdalne repozytoria są tak naprawdę jednym i tym samym. W Git repozytorium jest DAG zatwierdzeń wskazujących na ich rodziców. Oddziały są technicznie niczym więcej niż znaczącymi nazwami zobowiązań. Jedyną różnicą między gałęziami lokalnymi i zdalnymi jest to, że zdalne mają prefiks remoteName/ Git od podstaw, to bardzo dobra lektura. Kiedy zrozumiesz, jak działa Git - i to jest naprawdę proste , naprawdę - wszystko ma sens.
Emil Lundberg,

13
Wielkie dzięki za wyjaśnienie. Do tej pory tak naprawdę nie rozumiałem, że Git został zaprojektowany, więc nie trzeba mieć centralnego repozytorium. Wszyscy opisując Git zawsze mówią „DVCS”, ale jako stosunkowo nowy programista nic dla mnie nie znaczy. Nigdy nie widziałem CVCS, a także nigdy nie pracowałem z centralnym zdalnym repozytorium podczas współpracy z innymi (np. Github), więc do tej pory muszę zrozumieć, co czyni Git wyjątkowym.
Brian Peterson

7
Opierając się na tym, dlaczego NIE jest dobrym pomysłem git-fetch z zadaniem cron? Zawsze zachowując kopię pilota, z którym pracujesz na komputerze lokalnym, wydaje się dobrym pomysłem. W rzeczywistości mam ochotę napisać skrypt, który sprawdzi, czy w ciągu ostatnich 24 godzin zaktualizowałem pilota i połączyłem go z hakiem udev do połączenia internetowego.
Brian Peterson

23
Jednym z powodów, dla których nie jest dobrym pomysłem mieć crona: często pracując nad nowym biletem lub przy aktualizacjach oddziału, lubię patrzeć, jak zmiany są pobierane. Jeśli zmiany nie pojawią się podczas pobierania, będę bardziej pewny, pytając mojego programistę „hej, naciskałeś?”. Wyczuwam też, ile „odejść” w repozytorium od ostatniego pobrania. Pomaga mi to również w zrozumieniu ilości i szybkości zmian wprowadzanych obecnie w tym repozytorium.
Michael Durrant

5
@Nabheet Chodzi o to, że Git jest zorientowany na treść. Przechowuje dane tylko raz i wskazuje je wielokrotnie. Dlatego w Git nawet wiele zatwierdzeń na oryginale nie wpływa znacząco na rozmiar repo, ponieważ większość obiektów jest taka sama.
cst1992

887

Oto obraz Olivera Steele, jak to wszystko do siebie pasuje :

wprowadź opis zdjęcia tutaj

Jeśli jest wystarczające zainteresowanie, mogę zaktualizować obraz, aby dodać git clonei git merge...


154
Zaktualizowany obraz z git clonei git mergebyłby bardzo pomocny!
UWAGA

19
Tak, proszę dodać git merge- powinien wyraźnie pokazywać, że mergewywołanie osobno NIE jest tym samym, co wywołanie, pullponieważ pullłączy się tylko ze zdalnym i ignoruje lokalne zatwierdzenia w lokalnym oddziale, który śledzi, z którego jest pobierany oddział zdalny.
JustAMartin

12
Obraz jest wart tysiąca słów! Czy zaktualizowany obraz z klonowaniem i scalaniem przepływu danych jest już gdzieś gotowy? Jakikolwiek inny przepływ danych poza tym, co jest już na schemacie?
shikhanshu

10
@Contango proszę dodać klon i połączyć. Byłby pomocny dla początkujących takich jak ja.
wynajmuje

11
Istnieją dwa diagramy pokazujące klonowanie i scalanie w innych odpowiedziach (poniżej) autorstwa th3sly i thedarkpassenger.
intotecho

487

Jednym z przykładów użycia git fetchjest to, że poniższe informacje powiedzą ci o wszelkich zmianach w zdalnej gałęzi od czasu ostatniego ściągnięcia ... abyś mógł sprawdzić przed wykonaniem rzeczywistego ściągnięcia, co może zmienić pliki w bieżącym oddziale i kopii roboczej.

git fetch
git diff ...origin

Zobacz: https://git-scm.com/docs/git-diff na temat składni podwójnych i potrójnych kropek w poleceniu diff


9
dlaczego nie git diff ..origin?
Erik Kaplun,

3
git diff origin i git diff ..origin wydają się działać, ale nie takie dziwne ... rzeczy
Marc

19
@Compustretch Nie było spacji. git diff ...originjest równoważny git diff $(git-merge-base HEAD origin) origin(patrz git diff [--options] <commit>...<commit> [--] [<path>…]sekcja kernel.org/pub/software/scm/git/docs/git-diff.html#_description ), który różni się od git diff origin; git diff ...originjest koncepcyjnie zmianami dokonanymi originod czasu odgałęzienia bieżącej gałęzi origin, a git diff origintakże odwrotnością zmian dokonanych w bieżącym odgałęzieniu od rozgałęzienia origin.
Max Nanasy

2
żadne z poleceń .. nie działało dla mnie (w systemie Windows), ale git diff origin/masterdziała, jak wspomniano poniżej
Brian Burns

to samo tutaj przy użyciu git 2.0.0 na OSX. Żadne z tych poleceń nie działało. Czy były przestarzałe?
K.-Michael Aye

372

Trochę mnie kosztowało zrozumienie, jaka była różnica, ale to proste wyjaśnienie. masterw twoim lokalnym hoście jest oddział.

Klonując repozytorium, pobierasz całe repozytorium do lokalnego hosta. Oznacza to, że w tym momencie masz wskaźnik początkowy / główny HEADi główny wskazujący na to samo HEAD.

kiedy zaczynasz pracę i robisz zatwierdzenia, przesuwasz główny wskaźnik do HEAD+ twoich zatwierdzeń. Ale wskaźnik origin / master wciąż wskazuje na to, co było po sklonowaniu.

Różnica będzie więc następująca:

  • Jeśli to zrobisz git fetch, po prostu pobierze wszystkie zmiany w zdalnym repozytorium ( GitHub ) i przeniesie wskaźnik origin / master do HEAD. W międzyczasie twój lokalny kierownik oddziału będzie nadal wskazywał, gdzie ma.
  • Jeśli to zrobisz git pull, to w zasadzie pobierze (jak wyjaśniono wcześniej) i połączy wszelkie nowe zmiany w gałęzi master i przeniesie wskaźnik do HEAD.

14
origin / master to lokalny oddział, który jest KOPIĄ master z pochodzenia. Podczas pobierania aktualizujesz local: / origin / master. Gdy naprawdę zdajesz sobie sprawę, że wszystko w git jest gałęzią, ma to sens i jest bardzo potężnym sposobem utrzymywania różnych zestawów zmian, tworzenia szybkich lokalnych gałęzi, łączenia i zmiany bazy i generalnie czerpania korzyści z taniego rozgałęziania Model.
cam8001

3
Wciąż mylące. Myślałem, że git fetchdosłownie pobieram zmiany z repozytorium zdalnego do repozytorium lokalnego, ale NIE zatwierdzam ich - tj. Nadal trzeba je dodać / zatwierdzić do repozytorium lokalnego.
krb686,

3
pobieranie tylko ściąga ze zdalnego / origin (github) do twojego lokalnego pochodzenia. Ale nie łączy go z twoimi rzeczywistymi plikami roboczymi. jeśli wykonasz ciągnięcie, zostanie ono pobrane i scalone z twoimi bieżącymi plikami roboczymi
Gerardo

223

Czasami pomaga wizualna reprezentacja.

wprowadź opis zdjęcia tutaj


17
Myślę, że zdjęcie to pokazuje, że wpływa również na lokalne repozytorium. Oznacza to, że Git pull jest kombinacją wpływu na lokalne repozytorium i kopię roboczą. W tej chwili wydaje się, że wpływa to tylko na kopię roboczą.
nonpolarity

10
@太極者無極而生Zgoda - ten obraz jest dość mylące, ponieważ to sprawia, że wygląda jak git pulljest pomijanie fetch, co oczywiście jest niedokładna.
forresthopkinsa

8
Jaka jest różnica między „Lokalnym repozytorium” a „Kopią roboczą”? Czy oba nie są lokalne na komputerze?
theITvideos

1
Jaki jest zatem pożytek z git fetch? jak zobaczyć, jaka jest różnica w lokalnym repozytorium i kopii roboczej?
Vikash,

1
@theITvideos Nie, to nie jest. Lokalne repozytorium to miejsce, w którym idzie twój kod (z działającego repozytorium) podczas zatwierdzania. (Po naciśnięciu przechodzi do zdalnego repo).
Vikash

219

Krótko

git fetchjest podobny, pullale nie łączy się. tzn. pobiera zdalne aktualizacje ( refsi objects), ale lokalny pozostaje taki sam (tzn. origin/masterjest aktualizowany, ale masterpozostaje taki sam).

git pull ściąga z pilota i natychmiast się łączy.

Więcej

git clone klonuje repozytorium.

git rebasezapisuje rzeczy z twojego obecnego oddziału, który nie znajduje się w odgałęzieniu powyżej, w obszarze tymczasowym. Twój oddział jest teraz taki sam, jak przed rozpoczęciem zmian. Tak, git pull -rebasebędzie ciągnąć w dół zdalnych zmian, przewijanie do lokalnego oddziału, odtworzyć zmiany na górnej części bieżącej jedna gałąź jeden aż będziesz up-to-date.

Ponadto git branch -apokaże Ci dokładnie, co się dzieje ze wszystkimi oddziałami - lokalnymi i zdalnymi.

Ten post był przydatny:

Różnica między git pull, git fetch i git clone (i git rebase) - Mike Pearce

i pokrowce git pull, git fetch, git clonei git rebase.

====

AKTUALIZACJA

Pomyślałem, że zaktualizuję to, aby pokazać, jak faktycznie wykorzystasz to w praktyce.

  1. Zaktualizuj lokalne repozytorium zdalnie (ale nie scalaj):

    git fetch 
    
  2. Po pobraniu aktualizacji zobaczmy różnice:

    git diff master origin/master 
    
  3. Jeśli jesteś zadowolony z tych aktualizacji, połącz:

    git pull
    

Uwagi:

W kroku 2: Aby uzyskać więcej informacji na temat różnic między lokalnymi i zdalnymi, zobacz: Jak porównać lokalną gałąź git z jej gałęzią zdalną?

W kroku 3: Prawdopodobnie bardziej dokładne (np. W szybko zmieniającym się repozytorium) jest zrobienie git rebase origintutaj. Zobacz komentarz @Justin Ohms w innej odpowiedzi.

Zobacz także: http://longair.net/blog/2009/04/16/git-fetch-and-merge/


1
Wydaje mi się, że jeśli ktoś chce, aby lokalny kod odzwierciedlał „wskazówkę”, powinien go użyć git clone. Podaję wskazówkę w cudzysłowie, ponieważ zakładam, że oznaczałoby to, kim jest mistrz i co ktoś „pobrałby jako zip” z github.com
Chris K

3
co jeśli nie jesteś zadowolony ze zmian po pobraniu? co zrobic nastepnie?
Kugutsumen

Twój akapit na temat bazy był właśnie tym, czego szukałem. Cały pomysł zerowania wszystkiego, aktualizowania ze zdalnego, a następnie odtwarzania zmian na podstawie poprzednich zatwierdzeń, które miały miejsce podczas pracy. Idealne wyjaśnienie przy założeniu, że jest poprawne. ;)
coblr

178
git-pull - Pobierz i połącz z innym repozytorium lub oddziałem lokalnym
STRESZCZENIE

git pull…
OPIS

Uruchamia git-fetch z podanymi parametrami i wywołuje git-merge w celu scalenia 
odzyskałem głowy w bieżącej gałęzi. Z opcją --rebase wywołuje git-rebase
zamiast git-merge.

Pamiętaj, że możesz użyć. (bieżący katalog) jako <repository> do pobrania
z lokalnego repozytorium - jest to przydatne podczas łączenia lokalnych oddziałów 
do obecnego oddziału.

Zauważ też, że opcje przeznaczone dla samego git-pull i leżącego u jego podstaw git-merge 
należy podać przed opcjami przeznaczonymi dla git-fetch.

Wyciągnąłbyś, jeśli chcesz scalić historie, ściągnąłbyś, gdybyś po prostu „chciałby kodu”, ponieważ ktoś oznaczył tu jakieś artykuły.


5
Bardzo interesujące, ale tak naprawdę nie widzę przypadku użycia, w którym chcesz „tylko kod”. I co się stanie z twoim kodem podczas pobierania? Czy to zostało usunięte? Co się dzieje z odległymi zmianami? Jak to się dzieje w twoim repozytorium bez usuwania kodu, jeśli się nie scalisz?
e-satis

11
@ e-satis: Zdalna gałąź jest również przechowywana lokalnie na twoim komputerze. Kiedy to zrobisz git fetch, pobierze zmiany z repozytorium i zaktualizuje lokalny oddział zdalny. Nie wpływa na lokalny oddział, który śledzi lokalny oddział zdalny, więc nie wpływa na kopię roboczą. Teraz, gdy to zrobisz merge, połączy pobrane zmiany z lokalnym oddziałem.
jeffreyveon

Prosty przypadek użycia polecenia fetch: wykonuj czasochłonne operacje obejmujące ostatnie zatwierdzenia innych osób, takie jak scalanie lub przegląd kodu, uzyskując dostęp tylko do aktualnego lokalnego repozytorium bez wymagań dotyczących łączności sieciowej, ponieważ wcześniej używałeś funkcji pobierania do pobrania wszystko, czego potrzebujesz szybko (np. podczas wizyty u innego programisty i połączenia z siecią innego repozytorium). Polecenie ściągania pobierałoby te same zatwierdzenia, ale scalanie, które wykonuje, może być niepożądane.
Lorenzo Gatti,

163

Możesz pobrać ze zdalnego repozytorium, zobaczyć różnice, a następnie pobrać lub scalić.

To jest przykład zdalnego repozytorium o nazwie origini gałęzi o nazwie masterśledzącej gałąź zdalną origin/master:

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

35
Prawdopodobnie chcesz pominąć ściąganie i po prostu zrobić „początek git rebase” jako ostatni krok, ponieważ już pobrałeś zmiany. Powodem jest to, że ktoś mógł wprowadzić zmiany w czasie od momentu pobrania i nie byłyby one w pobieraniu, w którym dokonałeś przeglądu różnic.
Justin Ohms

158

Odpowiedź jest krótka i prosta, że git pulljest po prostu git fetchnastępuje git merge.

Bardzo ważne jest, aby pamiętać, że git pullbędzie automatycznie łączą się, czy chcesz, czy nie . Może to oczywiście prowadzić do konfliktów scalania. Powiedzmy, że twój pilot jest, origina twoja gałąź to master. Jeśli git diff origin/masterto zrobisz, powinieneś mieć pojęcie o potencjalnych konfliktach scalania i odpowiednio przygotować swój lokalny oddział.

Oprócz ciągnięcia i pchania niektóre przepływy pracy obejmują git rebase, na przykład ten, który parafrazuję z powiązanego artykułu:

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

Jeśli znajdziesz się w takiej sytuacji, możesz ulec pokusie git pull --rebase. Jeśli naprawdę nie wiesz, co robisz, odradzałbym to. To ostrzeżenie pochodzi ze manstrony dla git-pullwersji 2.3.5:

Jest to potencjalnie niebezpieczny tryb działania. Przepisuje historię, co nie wróży dobrze, gdy już ją opublikowałeś. Nie używaj tej opcji, chyba że dokładnie przeczytałeś git-rebase (1).


2
@JustinOhms Jeśli git pull --rebaseto nie jest właściwe w danej sytuacji, czy jest to właściwe, jeśli odbywa się to w dwóch etapach? Jeśli jest to właściwe, co stanowi dodatkową korzyść z robienia tego w dwóch etapach?
Kaz

@Kaz - ponieważ zmiana bazy nie jest automatyczna. Najpierw pobranie zmian pozwala na wywołanie oceny. Nie rozwiązuje problemu z publikowaniem historii, którą już opublikowałeś. Pozwoli ci to sprawdzić, czy można bezpiecznie wprowadzać zmiany, których jeszcze nie wprowadziłeś.
Justin Ohms

2
@JustinOhms Jak zdecydowałbyś, czy zmiana bazy jest bezpieczna? Po prostu spróbowałbym git rebase i cofnąłbym się, gdyby zrobił bałagan, w takim przypadku równie dobrze mógłbym zrobić git pull --rebase. Ale może masz inny sposób?
Kaz

3
@KaZ gitk pozwala zobaczyć strukturę gałęzi wizualnie. Pokaże Ci swoją pozycję lokalnego szefa, piloty i struktury oddziałów w stosunku do tego, co pobrałeś. W ten sposób możesz upewnić się, że nie wycofujesz pobranych zmian opartych na przodku, który jest wcześniejszy niż to, co już wypchnąłeś na swoich pilotów.
Justin Ohms

Użyj, rebasegdy pracujesz nad lokalnym oddziałem, który nie został jeszcze wypchnięty. Jeśli pracujesz nad oddziałem, który istnieje w trybie zdalnym, rebasemoże to powodować pewne nieprzyjemne problemy, więc powinieneś preferować regularne merge.
Justus Romijn

151

OK , oto kilka informacji na temat git pulli git fetch, dzięki czemu można zrozumieć rzeczywiste różnice ... w kilku prostych słowach, pobieranie pobiera najnowsze dane, ale nie zmiany kodu i nie będzie bałaganu z bieżącym lokalnym kodem oddziału, ale pull get kod się zmienia i łączy go z lokalnym oddziałem, czytaj dalej, aby uzyskać więcej informacji na temat każdego z nich:

ściągnij

Pobierze wszystkie referencje i obiekty oraz wszelkie nowe oddziały do ​​lokalnego repozytorium ...

Pobierz gałęzie i / lub tagi (łącznie „referencje”) z jednego lub więcej innych repozytoriów, wraz z obiektami niezbędnymi do uzupełnienia ich historii. Oddziały zdalnego śledzenia są aktualizowane (patrz opis poniżej, aby dowiedzieć się, jak kontrolować to zachowanie).

Domyślnie pobierany jest również każdy znacznik wskazujący pobierane historie; efektem jest pobranie tagów wskazujących na gałęzie, którymi jesteś zainteresowany. To domyślne zachowanie można zmienić, używając opcji --tags lub --no-tags lub konfigurując remote..tagOpt. Używając refspec jawnie pobierającego tagi, możesz pobrać tagi, które nie wskazują również na gałęzie, którymi jesteś zainteresowany.

git fetch może pobierać albo z jednego nazwanego repozytorium lub adresu URL, albo z kilku repozytoriów jednocześnie, jeśli jest podany i istnieją piloty. wpis w pliku konfiguracyjnym. (Zobacz git-config 1 ).

Jeśli nie zostanie określony żaden pilot, domyślnie używany będzie pilot źródłowy, chyba że istnieje gałąź odgałęziona skonfigurowana dla bieżącej gałęzi.

Pobierane nazwy referencji wraz z nazwami obiektów, na które wskazują, są zapisywane w .git / FETCH_HEAD. Informacje te mogą być wykorzystywane przez skrypty lub inne polecenia git, takie jak git-pull.


git pull

Zastosuje zmiany ze zdalnego do bieżącego oddziału w lokalnym ...

Zawiera zmiany ze zdalnego repozytorium w bieżącym oddziale. W domyślnym trybie git pull jest skrótem dla git fetch, po którym następuje fuzja GET FETCH_HEAD.

Dokładniej, git pull uruchamia git fetch z podanymi parametrami i wywołuje git merge, aby scalić odzyskane głowy gałęzi z bieżącą gałęzią. W przypadku --rebase uruchamia git rebase zamiast git merge.

powinna być nazwą zdalnego repozytorium przekazaną do git-fetch 1 . może nazwać dowolne zdalne odwołanie (na przykład nazwę znacznika) lub nawet zbiór odnośników z odpowiednimi gałęziami zdalnego śledzenia (np. refs / heads / : refs / remotes / origin / ), ale zazwyczaj jest to nazwa oddziału w zdalnym repozytorium.

Domyślne wartości i są odczytywane z konfiguracji „zdalnej” i „scalającej” dla bieżącej gałęzi, zgodnie z ustawieniem git-branch --track.


Tworzę również poniższy rysunek, aby pokazać, jak git fetchi jak git pullwspółpracować ...

git pull i git fetch


9
Jeśli podoba ci się obraz, spójrz na ściągawkę git, która jest taka sama dla wszystkich poleceń git ... ndpsoftware.com/git-cheatsheet.html
Tom

3
Czy klonowanie nie wpływa również na lokalne repozytorium (kopiowanie całej historii ze zdalnego)?
Tom Loredo

135

wprowadź opis zdjęcia tutaj

Ta interaktywna reprezentacja graficzna jest bardzo pomocna w zrozumieniu git: http://ndpsoftware.com/git-cheatsheet.html

git fetchpo prostu „pobiera” zmiany ze zdalnego do lokalnego repozytorium. git pullpobiera zmiany i łączy je w bieżący oddział. „W trybie domyślnym git pulljest skrótem, git fetchpo którym następuje git merge FETCH_HEAD”.


18
Ludzie, kliknij link, aby wejść w interakcję z różnymi kolumnami. Ten ściąg jest najlepszym zasobem, jaki widziałem, aby w pełni zrozumieć różnice między poszczególnymi poleceniami.
M. Luisa Carrión

Ta odpowiedź musi iść na górę
Tessaracter

126

Premia:

Mówiąc o pull & fetch w powyższych odpowiedziach, chciałbym podzielić się ciekawą sztuczką,

git pull --rebase

To powyższe polecenie jest najbardziej użytecznym poleceniem w moim życiu git, które zaoszczędziło wiele czasu.

Przed wypchnięciem nowych zatwierdzeń na serwer, spróbuj tego polecenia, a ono automatycznie zsynchronizuje najnowsze zmiany na serwerze (z funkcją pobierania + scalania) i umieści twoje zatwierdzenie na górze w dzienniku git. Nie musisz martwić się o ręczne wyciąganie / scalanie.

Znajdź szczegóły na: http://gitolite.com/git-pull--rebase


4
Fajna wskazówka, choć warto wspomnieć nowym użytkownikom git, że rebase modyfikuje skróty zatwierdzania (to zaskakujące, że pochodzi z subversion).
AlexMA

1
Czy możesz wyjaśnić, jaka jest różnica między git pulli git pull --rebase?
shaijut

2
Zobacz surowe ostrzeżenie o tej metodzie w odpowiedzi powyżej: stackoverflow.com/a/6011169/241244

118

Lubię mieć wizualną reprezentację sytuacji, aby zrozumieć te rzeczy. Może inni programiści też chcieliby to zobaczyć, więc oto mój dodatek. Nie jestem do końca pewien, czy wszystko jest w porządku, więc proszę o komentarz, jeśli znajdziesz jakieś błędy.

                                         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.

Niektóre główne zalety posiadania ściągniętego lustra pilota to:

  • Wydajność (przewijaj wszystkie zatwierdzenia i wiadomości, nie próbując przeciskać ich przez sieć)
  • Informacja zwrotna na temat stanu twojego lokalnego repozytorium (na przykład korzystam z narzędzia SourceTree Atlassian, które da mi żarówkę wskazującą, czy robię postępy z przodu czy z tyłu w porównaniu do źródła. Informacje te można zaktualizować za pomocą GIT FETCH).

Czy a git pulltakże nie wykonuje scalenia, czyli przejścia do kopii roboczej?
Kamiel Wanrooij

Dobrze, tak, spowoduje to wprowadzenie wszystkich zmian w kopii roboczej, a następnie możesz samodzielnie zatwierdzić to w lokalnym repozytorium. Zaktualizuję grafikę.
Justus Romijn

@JustusRomijn Czy ściąganie nie aktualizuje również lokalnego repozytorium? Czy nie powinna istnieć gwiazdka między gwiazdką początkową a gwiazdką kopii roboczej?
user764754

2
@ user764754 Po wyciągnięciu kopia robocza pobiera zmiany (mogą wystąpić także konflikty, które mogą być konieczne do rozwiązania). Nadal musisz zatwierdzić to w swoim lokalnym repozytorium.
Justus Romijn

@JustusRomijn: Dziękuję za ilustrację. Byłoby wspaniale, gdybyś mógł uczynić schemat bardziej wszechstronnym, ilustrując efekty operacji takich jak reset, wybieranie wiśni na stany repozytorium.
jith912

106

Walczyłem również z tym. W rzeczywistości znalazłem się tutaj, szukając w Google dokładnie tego samego pytania. Po przeczytaniu wszystkich tych odpowiedzi w końcu namalowałem obraz w mojej głowie i postanowiłem to sprowadzić, patrząc na stan 2 repozytoriów i 1 piaskownicy oraz działań wykonanych w czasie, oglądając ich wersję. Oto co wymyśliłem. Popraw mnie, jeśli coś pomieszałem.

Trzy repozytoria z pobraniem:

---------------------     -----------------------     -----------------------
- 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+               -
---------------------     -----------------------     -----------------------

Trzy repozytoria z pociągnięciem

---------------------     -----------------------     -----------------------
- 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+               -
---------------------     -----------------------     -----------------------

Pomogło mi to zrozumieć, dlaczego pobieranie jest bardzo ważne.


Nie tak trudne do odczytania: pola reprezentują stan repozytorium, który w każdym rzędzie zmienia się w czasie od lewej do prawej po zgłoszonej operacji w wierszu 2 pola. Etykiety R0n są tagami w git, a tag z + jest jeszcze nieprzyzwoitym materiałem. Sanbox jest używany w folderze roboczym innym niż folder repo, w którym przechowywane są zatwierdzone rzeczy.
user1708042,

96

Różnicę między GIT Fetch a GIT Pull można wytłumaczyć następującym scenariuszem: (pamiętając, że zdjęcia mówią głośniej niż słowa !, przedstawiłem obrazki)

Weźmy przykład, że pracujesz nad projektem z członkami swojego zespołu. Będą więc jedną główną gałęzią projektu, a wszyscy współtwórcy muszą rozwidlić go do własnego lokalnego repozytorium, a następnie pracować nad tym lokalnym oddziałem, aby zmodyfikować / dodać moduły, a następnie wypchnąć z powrotem do głównej gałęzi.

Tak, Stan początkowy obu gałęzi kiedy rozwidlone główny projekt na lokalnym repozytorium będzie jak to- ( A, Bi Csą już gotowe moduły projektu)

wprowadź opis zdjęcia tutaj

Teraz rozpoczęły się prace nad nowym modułem (przypuszczam D) i po zakończeniu Dmodułu, który chcesz przesunąć do głównej gałęzi, Ale tymczasem co się dzieje, że jeden z twoich kolegów opracował nowy moduł E, Fi modyfikowane C.
Tak więc teraz dzieje się tak, że w twoim lokalnym repozytorium brakuje oryginalnego postępu projektu, a zatem przekazanie twoich zmian do głównej gałęzi może prowadzić do konfliktu i może spowodować Dawarię modułu .

wprowadź opis zdjęcia tutaj

Aby uniknąć takich problemów i pracować równolegle z pierwotnym postępem projektu, są dwa sposoby:

1. Git Fetch - Spowoduje to pobranie wszystkich zmian, które zostały wprowadzone w projekcie źródłowym / głównym oddziału, które nie są obecne w oddziale lokalnym. I będzie czekać na polecenie Git Merge, aby zastosować zmiany, które zostały pobrane do Twojego repozytorium lub oddziału.

wprowadź opis zdjęcia tutaj

Teraz możesz dokładnie monitorować pliki przed scaleniem ich z repozytorium. Możesz także zmodyfikować, Djeśli jest to wymagane ze względu na Zmodyfikowane C.

wprowadź opis zdjęcia tutaj

2. Git Pull - spowoduje to zaktualizowanie twojego lokalnego oddziału o gałęzi origin / main, tzn. To, co robi, to połączenie Git Fetch i Git scalają jeden po drugim. Może to jednak powodować konflikty, dlatego zaleca się używanie Git Pull z czystą kopią.

wprowadź opis zdjęcia tutaj


1
gdybyś mógł zmienić „Oddział główny” na „Zdalne repozytorium”, byłaby to świetna odpowiedź.
Qibiron Who

87

Mówimy po prostu:

git pull == git fetch + git merge

Jeśli uruchomisz git pull, nie musisz scalać danych z lokalnymi. Jeśli uruchomisz git fetch, oznacza to, że musisz uruchomić, git mergeaby pobrać najnowszy kod na komputer lokalny. W przeciwnym razie lokalny kod maszynowy nie zostałby zmieniony bez scalenia.

Więc w Git Gui, kiedy pobierasz, musisz scalić dane. Sam pobierz nie spowoduje zmiany kodu w twoim lokalnym. Możesz to sprawdzić po aktualizacji kodu, pobierając raz, pobierz i zobacz; kod się nie zmieni. Następnie scalasz ... Zobaczysz zmieniony kod.


3
Wolę powiedzieć git pull == git fetch + git merge:)
melvynkim,

2
Alegit pull --rebase = git fetch + git rebase
Tino,

83

git fetchściąga kod ze zdalnego serwera do gałęzi śledzenia w lokalnym repozytorium. Jeśli pilot jest nazwany origin(domyślnie), wówczas te oddziały będą w zasięgu origin/, na przykład origin/master, origin/mybranch-123itd To nie są wasze obecne oddziały są lokalne kopie tych gałęzi z serwera.

git pullwykonuje, git fetchale następnie łączy również kod z gałęzi śledzenia w bieżącą lokalną wersję tej gałęzi. Jeśli nie jesteś jeszcze gotowy na te zmiany, git fetchnajpierw.


78

git fetchpobierze zdalne gałęzie, abyś mógł git difflub git mergeone z bieżącą gałęzią. git pulluruchomi pobieranie na zdalnym brachie śledzonym przez bieżącą gałąź, a następnie scali wynik. Możesz użyć, git fetchaby sprawdzić, czy są jakieś aktualizacje zdalnego oddziału bez konieczności scalania ich z lokalnym oddziałem.


73

Git Fetch

Pobierasz zmiany do lokalnego oddziału od miejsca pochodzenia poprzez pobieranie. Fetch prosi zdalne repo o wszystkie zatwierdzenia dokonane przez innych, ale nie masz ich w repozytorium lokalnym. Pobierz pobiera te zatwierdzenia i dodaje je do lokalnego repozytorium.

Git Merge

Możesz zastosować zmiany pobrane poprzez pobieranie za pomocą polecenia scalania. Scalenie pobierze zatwierdzenia pobrane z pobierania i spróbuje dodać je do lokalnego oddziału. Scalenie zachowa historię zatwierdzania lokalnych zmian, dzięki czemu, kiedy udostępnisz swój oddział push, Git będzie wiedział, jak inni mogą scalić twoje zmiany.

Git Pull

Fetch i merge biegają razem tak często, że powstało polecenie, które łączy oba, pull. Pull wykonuje pobieranie, a następnie scalanie w celu dodania pobranych commits do lokalnego oddziału.


52

Jedyna różnica między git pulli git fetchpolega na tym, że:

git pull ściąga ze zdalnej gałęzi i łączy ją.

git fetch pobiera tylko ze zdalnej gałęzi, ale nie łączy się

tj. git pull = git fetch + git merge ...


1
I nic nie pomoże, jeśli git uważa, że ​​jesteś opóźniony przez zobowiązania i może „przewinąć do przodu”, co skończyło się na tym, że wszystko skończyłem rm -rfi zacząłem od nowa. Głupi Git, proszę, pozwól mi tylko wziąć prąd, abym mógł wrócić do pracy?
Chris K

46

Mówiąc prościej, gdybyś miał wskoczyć do samolotu bez połączenia z Internetem ... przed odlotem mógłbyś to zrobić git fetch origin <master>. Pobierałby wszystkie zmiany na twoim komputerze, ale trzymał go oddzielnie od lokalnego obszaru programowania / pracy.

W samolocie możesz wprowadzić zmiany w lokalnym obszarze roboczym, a następnie scalić je z tym, co pobrałeś i rozwiązać wszystkie potencjalne konflikty scalania bez połączenia z Internetem. I chyba że ktoś wprowadzi nowe sprzeczne zmiany w zdalnym repozytorium, to kiedy dotrzesz do miejsca docelowego, zrobisz to git push origin <branch>i pójdziesz po kawę.


Z tego niesamowitego samouczka Atlassian :

Do git fetchpobrania dowodzenia commity, plików i sędziowie ze zdalnego repozytorium w lokalnym repozytorium.

Pobieranie jest tym, co robisz, gdy chcesz zobaczyć, nad czym wszyscy inni pracują. Jest podobny do aktualizacji SVN, ponieważ pozwala zobaczyć postępy w historii centralnej, ale nie zmusza cię do scalenia zmian w repozytorium. Git izoluje pobrane treści od istniejących treści lokalnych , nie ma to absolutnie żadnego wpływu na lokalne prace programistyczne . Pobrane treści należy jawnie wypisać za pomocą git checkoutpolecenia. Dzięki temu pobieranie jest bezpiecznym sposobem na sprawdzenie zatwierdzeń przed zintegrowaniem ich z lokalnym repozytorium.

Podczas pobierania zawartości z zdalnego repozytorium, git pulli git fetchpolecenia są dostępne, aby wykonać zadanie. Możesz rozważyć git fetch„bezpieczną” wersję dwóch poleceń. Pobierze zdalną zawartość, ale nie zaktualizuje stanu pracy lokalnego repozytorium, pozostawiając bieżącą pracę nienaruszoną. git pulljest bardziej agresywną alternatywą, pobierze zdalną zawartość dla aktywnego oddziału lokalnego i natychmiast uruchomi się, git mergeaby utworzyć zatwierdzenie scalania dla nowej zdalnej treści. Jeśli oczekujesz zmian, spowoduje to konflikty i rozpocznie proces rozwiązywania konfliktów scalania.


Z git pull:

  • Nie dostajesz żadnej izolacji.
  • Wpływa na twój rozwój lokalny.
  • Nie musi być jawnie wypisany. Ponieważ domyślnie robi to git merge.
  • Zasadniczo NIE jest bezpieczny. To jest agresywne.
  • W przeciwieństwie do tego, git fetchgdzie wpływa to tylko na ciebie .git/refs/remotes, git pull wpłynie zarówno na ciebie, jak .git/refs/remotes i na .git/refs/heads/

Hmmm ... więc jeśli nie aktualizuję kopii roboczej git fetch, to gdzie wprowadzam zmiany? Gdzie Git Fetch przechowuje nowe zatwierdzenia?

Świetne pytanie. Umieszcza go gdzieś w izolacji od kopii roboczej. Ale znowu gdzie? Dowiedzmy Się.

W katalogu projektu (tj. Tam, gdzie wykonujesz gitpolecenia):

  1. ls. Spowoduje to wyświetlenie plików i katalogów. Nic fajnego, wiem.

  2. Teraz zrób ls -a. To pokaże dot plików , czyli plików rozpoczynające się od .Ciebie będzie mógł zobaczyć katalog o nazwie: .git.

  3. Zrobić cd .git. To oczywiście zmieni twój katalog.
  4. Teraz zaczyna się zabawa; zrobić ls. Zobaczysz listę katalogów. Szukamy refs. Zrobić cd refs.
  5. Ciekawie jest zobaczyć, co znajduje się we wszystkich katalogach, ale skupmy się na dwóch z nich. headsa remotes. Użyj, cdaby sprawdzić również w nich.
  6. Każda git fetch czynność spowoduje aktualizację elementów w /.git/refs/remoteskatalogu. Nie zaktualizuje niczego w /.git/refs/headskatalogu.
  7. Każdy git pull najpierw zrobi git fetch, zaktualizuje elementy w /.git/refs/remoteskatalogu, a następnie połączy się z lokalnym, a następnie zmieni nagłówek w /.git/refs/headskatalogu.

Bardzo dobrą powiązaną odpowiedź można również znaleźć w temacie Gdzie znajduje się „git fetch”? .

Poszukaj też „Notacji ukośnika” w poście o konwencjach nazewnictwa gałęzi Git . Pomaga ci lepiej zrozumieć, w jaki sposób Git umieszcza rzeczy w różnych katalogach.


Aby zobaczyć rzeczywistą różnicę

Po prostu zrób:

git fetch origin master
git checkout master

Jeśli zdalny moduł główny został zaktualizowany, pojawi się następujący komunikat:

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

Jeśli tego nie zrobiłeś fetchi właśnie to zrobiłeś, git checkout masterlokalny git nie wiedziałby, że dodano 2 zatwierdzenia. I powiedziałoby to po prostu:

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

Ale to jest przestarzałe i niepoprawne. To dlatego, że git przekaże ci informacje zwrotne wyłącznie na podstawie tego, co wie. Nie jest świadomy nowych zobowiązań, których jeszcze nie rozebrał ...


Czy jest jakiś sposób, aby zobaczyć nowe zmiany wprowadzone zdalnie podczas lokalnej pracy w oddziale?

Niektóre IDE (np. Xcode) są super inteligentne i wykorzystują wynik a git fetchi mogą zawierać adnotacje do linii kodu, które zostały zmienione w zdalnej gałęzi twojego obecnego oddziału. Jeśli linia ta została zmieniona zarówno przez zmiany lokalne, jak i gałąź zdalną, wówczas linia ta zostanie opatrzona adnotacjami na czerwono. To nie jest konflikt scalania. Jest to potencjalny konflikt scalania. Jest to headsup, którego możesz użyć do rozwiązania przyszłego konfliktu scalania przed zrobieniem go git pullze zdalnej gałęzi.

wprowadź opis zdjęcia tutaj


Zabawna wskazówka:

Jeśli pobrałeś zdalną gałąź, np. Zrobiłeś:

git fetch origin feature/123

To przejdzie do twojego katalogu pilotów. Nadal nie jest dostępny dla twojego lokalnego katalogu. Upraszcza to jednak dokonywanie płatności do tej zdalnej gałęzi przez DWIM (Rób co mam na myśli):

git checkout feature/123

nie musisz już robić:

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

Więcej na ten temat przeczytasz tutaj


1
Podoba mi się ta odpowiedź
Kid_Learning_C

44

Git pozwala na stosowanie chronologicznie starszych zatwierdzeń po nowszych zatwierdzeniach. Z tego powodu przeniesienie zatwierdzeń między repozytoriami jest podzielone na dwa etapy:

  1. Kopiowanie nowych zatwierdzeń ze zdalnego oddziału do kopii tego zdalnego oddziału w lokalnym repozytorium.

    (operacja repo do repo) master@remote >> remote/origin/master@local

  2. Integrowanie nowych zatwierdzeń z lokalnym oddziałem

    (operacja repo) remote/origin/master@local >> master@local

Istnieją dwa sposoby wykonania kroku 2. Możesz:

  1. Rozwidlaj lokalną gałąź po ostatnim wspólnym przodku i dodaj nowe zatwierdzenia równolegle do zatwierdzeń, które są unikalne dla lokalnego repozytorium, sfinalizowane przez scalenie zatwierdzenia, zamknięcie rozwidlenia.
  2. Wstaw nowe zatwierdzenia po ostatnim wspólnym przodku i ponownie zastosuj zatwierdzenia unikalne dla lokalnego repozytorium.

W gitterminologii etap 1 to git fetchetap 2 to git mergelubgit rebase

git pulljest git fetchigit merge


36

Git otrzymuje gałąź najnowszej wersji ze zdalnego do lokalnego za pomocą dwóch poleceń:

  1. git fetch: Git ma pobrać najnowszą wersję ze zdalnego do lokalnego, ale nie łączy się automatycznie.      git fetch origin master git log -p master..origin/master git merge origin/master

         Powyższe polecenia oznaczają, że pobierz najnowszą wersję gałęzi głównej ze źródła ze zdalnego do gałęzi głównej źródłowej. A następnie porównuje lokalną gałąź główną i gałąź główną pochodzenia. Na koniec połącz.

  2. git pull: Git pobierze najnowszą wersję ze zdalnego i połączy się z lokalnym.

        git pull origin master

         Powyższe polecenie jest równoważne z git fetchi git merge. W praktyce git fetchmoże być bardziej bezpieczny, ponieważ przed scaleniem możemy zobaczyć zmiany i zdecydować, czy scalić.


36

Jaka jest różnica między git pulli git fetch?

Aby to zrozumieć, musisz najpierw zrozumieć, że lokalny git utrzymuje nie tylko lokalne repozytorium, ale także lokalną kopię zdalnego repozytorium.

git fetchaktualizuje lokalną kopię zdalnego repozytorium. Na przykład, jeśli Twoim zdalnym repozytorium jest GitHub - możesz pobrać wszelkie zmiany dokonane w zdalnym repozytorium do swojej lokalnej kopii w zdalnym repozytorium. Umożliwi to wykonywanie operacji takich jak porównywanie lub scalanie.

git pullz drugiej strony wprowadzi zmiany w zdalnym repozytorium do miejsca, w którym przechowujesz swój własny kod. Zazwyczaj git pullnajpierw zrobi git fetchaktualizację lokalnej kopii zdalnego repozytorium, a następnie połączy zmiany z własnym repozytorium kodu i ewentualnie kopią roboczą.


34

git pull == (git fetch + git merge)

git fetch nie zmienia lokalnych oddziałów.

Jeśli masz już lokalne repozytorium ze zdalną konfiguracją dla pożądanego projektu, możesz pobrać wszystkie gałęzie i tagi dla istniejącego zdalnego za pomocą git fetch. ... Funkcja pobierania nie wprowadza żadnych zmian w oddziałach lokalnych, dlatego konieczne będzie połączenie oddziału zdalnego ze sparowanym oddziałem lokalnym w celu uwzględnienia nowo pobranych zmian. z github


33

Staramy się być jasne i proste.

Polecenie git pull jest w rzeczywistości poleceniem shortcutfor git fetch, po którym następuje polecenie git merge lub polecenie git rebase, w zależności od konfiguracji. Możesz skonfigurować swoje repozytorium Git, aby git pull był pobierany, a następnie rebase.


33

Prosta reprezentacja graficzna dla początkujących,

wprowadź opis zdjęcia tutaj

tutaj,

git pull  

pobierze kod z repozytorium i zresetuje z lokalnym ... w git pull istnieje możliwość utworzenia nowych zatwierdzeń.

ale w ,

ściągnij

pobierze kod z repozytorium i musimy go zmienić ręcznie za pomocą git rebase

np .: zamierzam pobrać z serwera głównego i rozłożyć bazę w moim lokalnym komputerze głównym.

1) git pull (rebase zrobi się automatycznie):

git pull origin master

tutaj origin jest twoim zdalnym mistrzem repozytorium to twoja gałąź

2) git fetch (trzeba ręcznie zmienić bazę):

git fetch origin master

pobierze zmiany serwera z miejsca pochodzenia. i będzie w twoim lokalnym, dopóki sam nie wydasz podstawy. musimy ręcznie naprawić konflikty, sprawdzając kody.

git rebase origin/master

spowoduje to zmianę kodu na lokalny. wcześniej upewnij się, że jesteś w odpowiedniej branży.


Niezły wykres, ale możesz wyjaśnić, dlaczego używasz „rebase”, gdy wykres mówi „scal”.
Guntram Blohm obsługuje Monikę

1
Scalanie będzie reprezentowało inny zatwierdzenie gałęzi i wytworzy nowe zatwierdzenie, które zawiera zatwierdzenia jako odniesienie. ale rebase będzie replikował zatwierdzenia z innego oddziału, który nie utworzy nowego zatwierdzenia, a nie replikuje
Mohideen bin Mohammed

33

W rzeczywistości Git przechowuje kopię własnego kodu i zdalnego repozytorium.

To polecenie git fetchaktualizuje lokalną kopię, pobierając dane ze zdalnego repozytorium. Potrzebujemy tego, ponieważ ktoś inny mógł wprowadzić pewne zmiany w kodzie i chcesz być na bieżąco.

Polecenie git pullprzenosi zmiany w zdalnym repozytorium do miejsca przechowywania własnego kodu. Zwykle git pullrobi się to, najpierw wykonując polecenie „git fetch”, aby zaktualizować lokalną kopię zdalnego repozytorium, a następnie łączy zmiany z własnym repozytorium kodu i ewentualnie z kopią roboczą.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.