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

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.

• 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.

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.

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

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

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

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.

Czasami pomaga wizualna reprezentacja.

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/

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.

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

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).

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ć ...

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”.

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

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).

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.

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)

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 .

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.

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.

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ą.

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.

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.

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.

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.

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

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.

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

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

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ć.

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ą.

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

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.

Prosta reprezentacja graficzna dla początkujących,

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.

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ą.