border=0

"134.249.254.222 - 134.249.254.222"

Wat is het verschil tussen 'git pull' en 'git fetch'?

Notitie van de moderator. Aangezien er al 67 antwoorden zijn verzonden op deze vraag (sommige zijn verwijderd), kunt u overwegen of u iets nieuws toevoegt voordat u een nieuwe verzendt.

Wat zijn de verschillen tussen git pull en git fetch ?

10878
15 нояб. stel pupeno 15 nov. 2008-11-15 12:51 '08 om 12:51 2008-11-15 12:51
@ 47 antwoorden
  • 1
  • 2

Simpel gezegd, git pull voert git fetch gevolgd door git merge .

Je kunt git fetch op elk gewenst moment doen om de remote tracking-takken bij te werken in refs/remotes/<remote>/ .

Deze operatie wijzigt nooit een van je lokale vestigingen onder refs/heads , en het is veilig om dit te doen zonder je werkkopie te veranderen. Ik heb zelfs gehoord van mensen die regelmatig git fetch op een cron-baan uitvoeren (hoewel ik niet zou adviseren om dit te doen).

git pull is wat u moet doen om de lokale tak van uw externe versie bij te werken en om andere remote tracking-takken bij te werken.

Git-documentatie: git pull :

In de standaardmodus is git pull een afkorting voor git fetch gevolgd door git merge FETCH_HEAD .

9055
15 нояб. Antwoord gegeven door Greg Hewgill 15 november 2008-11-15 12:52 '08 om 12:52 2008-11-15 12:52
  • Wanneer u pull , probeert Git uw taak automatisch voor u te doen. Dit is contextgevoelig , dus Git zal elke push-opdracht samenvoegen in de branch waar je momenteel aan werkt. pull voegt automatisch commits samen zonder dat je ze eerst ziet . Als je niet erg goed bent in het beheren van je filialen, kun je regelmatig conflicten tegenkomen.

  • Wanneer je fetch , verzamel Git alle commits van de doelvertakking die niet in je huidige branch bestaan, maar sla ze op in je lokale repository . Het combineert ze echter niet met uw huidige branch . Dit is met name handig als u uw repository constant moet bijwerken, maar moet werken aan wat kan breken als u uw bestanden bijwerkt. Om commits in de hoofdtak te integreren, gebruik je merge .

1994
18 авг. antwoord gegeven door Mouna Cheikhna 18 aug. 2011-08-18 11:53 '11 om 11:53 2011-08-18 11:53

Het is be>

Subversion is ontworpen en gebouwd met behulp van een client / server-model. Er is één repository, dat een server is, en verschillende clients kunnen code van de server extraheren, ermee werken en het vervolgens terugzetten naar de server. Er wordt van uitgegaan dat de client altijd contact met de server kan opnemen wanneer hij een bewerking moet uitvoeren.

Git is ontworpen om een ​​meer gedistribueerd model te ondersteunen zonder de noodzaak van een centrale repository (hoewel je het zeker kunt gebruiken als je dat wilt). Ook was git zo ontworpen dat de client en de "server" niet tegelijkertijd online zouden moeten zijn. Git is zo ontworpen dat mensen op een onbetrouwbare link zelfs code per e-mail kunnen uitwisselen. Je kunt het werk volledig uitschakelen en een CD branden om via git code uit te wisselen.

Ter ondersteuning van dit model onderhoudt git een lokale repository met uw code, evenals een extra lokale repository die de staat van de externe repository weerspiegelt. Door een kopie van de externe repository lokaal op te slaan, kan git de benodigde wijzigingen bepalen, zelfs als de externe repository niet beschikbaar is. Later, wanneer u wijzigingen aan iemand anders moet verzenden, kan git ze als een set van wijzigingen overbrengen vanaf het tijdstip dat bekend is naar de externe repository.

  • git fetch is een opdracht die zegt: "Breng mijn lokale kopie van de externe repository tot nu toe."

  • git pull zegt: "Breng wijzigingen aan in de externe repository waar ik mijn eigen code bewaar."

Normaal gesproken doet git pull dit door git fetch te voeren om een ​​lokale kopie van de remote repository bij te werken, en dan de wijzigingen samen te voegen met je eigen coderepository en eventueel je werkkopie.

Verwijder dit om te onthouden dat er vaak ten minste drie exemplaren van het project op uw werkstation zijn. Eén exemplaar is uw eigen repository met een eigen commit-geschiedenis. Het tweede exemplaar is uw werkkopie waar u kunt bewerken en bouwen. Het derde exemplaar is uw lokale "cache" -kopie van de externe repository.

1118
31 марта '13 в 21:43 2013-03-31 21:43 het antwoord wordt gegeven door MikeD op 31 maart '13 om 21:43 uur 2013-03-31 21:43 uur
758
09 июня '15 в 16:30 2015-06-09 16:30 het antwoord wordt gegeven aan Contango 09 juni '15 om 16.30 uur 2015-06-09 16:30 uur

Eén gebruik van git fetch is dat het volgende bericht je vertelt over eventuele wijzigingen in de remote branch sinds de laatste pull ... dus je kunt het controleren voordat je de pull uitvoert die de bestanden in je huidige branch kan veranderen en een kopie kan uitvoeren .

 git fetch git diff ...origin 
452
07 мая '10 в 22:23 2010-05-07 22:23 het antwoord wordt gegeven aan mepster 07 mei, '10 om 10:23 AM 2010-05-07 22:23

Ik moest een beetje begrijpen wat het verschil was, maar dit is een eenvoudige verklaring. master in uw localhost is een filiaal.

Wanneer u een repository kloont, krijgt u de volledige repository voor de lokale host. Dit betekent dat je op dit moment de oorsprong / meester-aanwijzer op HEAD en de master naar dezelfde HEAD .

wanneer u begint te werken en u dit doet, draagt ​​u de hoofdwijzer over naar HEAD + uw fixaties. Maar de oorsprong / meester-aanwijzer geeft nog steeds aan wat het was toen je kloneerde.

Het verschil zal dus zijn:

  • Als je git fetch uitvoert, zal het gewoon alle veranderingen in de remote repository extraheren ( GitHub ) en de start / master pointer naar HEAD verplaatsen. In de tussentijd blijft uw lokale vertakkingswizard aangeven waar deze zich bevindt.
  • Als je git pull , zal het in principe uitpakken (zoals eerder uitgelegd) en nieuwe wijzigingen samenvoegen in de hoofdtak en de aanwijzer naar HEAD verplaatsen.
354
11 мая '12 в 21:37 2012-05-11 21:37 het antwoord is gegeven Gerardo 11 mei '12 om 21:37 2012-05-11 21:37

Soms helpt een visuele presentatie.

2019

25 янв. het antwoord wordt gegeven door thedarkpassenger 25 jan. 2016-01-25 20:28 '16 om 20:28 uur 2016-01-25 20:28

kort

git fetch is als pull maar voegt niet samen. dat wil zeggen, het selecteert externe updates ( refs en objects ), maar uw lokale blijft hetzelfde (d.w.z. origin/master bijgewerkt, maar master blijft hetzelfde).

git pull blaast de console af en voegt onmiddellijk samen.

grotere

git clone klonen repos.

git rebase bewaart gegevens van je huidige branch die niet in de upstream branch is naar een tijdelijk gebied. Je thread is nu hetzelfde als voordat je met je wijzigingen begon. Dus, git pull -rebase zal git pull -rebase remote changes git pull -rebase , je lokale branch terugspoelen, je wijzigingen één voor één over de huidige branch spelen, totdat je up-to-date bent.

Ook git branch -a zal je laten zien wat er gebeurt met al je filialen - lokaal en op afstand.

Dit bericht was nuttig:

Verschil tussen git pull, git fetch en git clone (en git rebase) - Mike Pierce

en bestrijkt git pull , git fetch , git clone en git rebase .

====

UPDATE

Ik dacht dat ik het zou updaten om te laten zien hoe je het in de praktijk gebruikt.

  1. Lokale opslag bijwerken vanaf een externe computer (maar niet samenvoegen):

     git fetch 
  2. Na het downloaden van updates, laten we de verschillen bekijken:

     git diff master origin/master 
  3. Als je tevreden bent met deze updates, combineer dan:

     git pull 

notes:

In stap 2: Voor meer informatie over de verschillen tussen lokaal en extern, zie: Hoe de lokale git branch vergelijken met zijn remote branch?

In stap 3: Waarschijnlijk nauwkeuriger (bijvoorbeeld in een snel veranderende repository) is het maken van een source source source hier. Zie het commentaar van Justin Ohm in een ander antwoord.

Zie ook: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

192
13 апр. Antwoord Snowcrash 13 apr 2013-04-13 20:31 '13 om 20:31 uur 2013-04-13 20:31 uur
 git-pull - ophalen van en samenvoegen met een andere repository of een lokale branch SYNOPSIS git trek ... BESCHRIJVING Voert de git-fetch uit  teruggehaald hoofd (s) in de huidige tak.  Met --rebase roept u git-rebase aan  in plaats van git-merge. Merk op dat je kunt gebruiken.  (huidige map) als de <repository> om te trekken  van de lokale repository - dit is handig bij het samenvoegen van lokale vestigingen  in de huidige tak. Merk ook op dat de opties bedoeld voor git-pull zelf en de onderliggende git-merge  voor git-fetch.

Je zou trekken, als je wilt dat de verhalen worden samengevoegd, zou je krijgen als je gewoon "de code wilde", omdat sommigen hier een aantal artikelen hebben geplaatst.

167
15 нояб. Antwoord gegeven door Vinko Vrsalovic 15 november 2008-11-15 12:52 '08 om 12:52 2008-11-15 12:52

U kunt ophalen uit een externe repository, de verschillen bekijken en vervolgens trekken of samenvoegen.

Dit is een voorbeeld van een externe repository met de naam origin en een branch met de naam master , die de remote origin/master branch volgt:

 git checkout master git fetch git diff origin/master git rebase origin master 
153
21 марта '11 в 14:07 2011-03-21 14:07 het antwoord wordt gegeven door Antonio Bardazzi 21 maart 11 om 14:07 de 2011-03-21 14:07

Het korte en eenvoudige antwoord is dat git pull gewoon git fetch gevolgd door git merge .

Het is heel be>git pull automatisch wordt samengevoegd, of je het nu leuk vindt of niet . Dit kan natuurlijk leiden tot samenvoegingsconflicten. Laten we zeggen dat uw console van origin en dat uw branche master . Als je van git diff origin/master voordat je eraan trekt, moet je je bewust zijn van mogelijke samenvoegingsconflicten en je lokale filiaal hierop voorbereiden.

Naast het trekken en klikken, bevatten sommige workflows ook git rebase , bijvoorbeeld deze, die ik parafraseer van een gerelateerd artikel:

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

Als je jezelf in deze situatie bevindt, word je misschien verleid door git pull --rebase . Als je echt niet weet wat je doet, zou ik adviseren om het te doen. Dit is een waarschuwing van de man pagina voor git-pull , versie 2.3.5 :

Dit is een potentieel gevaarlijke manier van werken. Hij herschrijft een verhaal dat niet veel goeds voorspelt wanneer je dit verhaal al hebt gepubliceerd. Gebruik deze parameter niet als u git-rebase (1) niet zorgvuldig hebt gelezen.

147
15 мая '11 в 23:53 2011-05-15 23:53 het antwoord wordt gegeven door jfmercer 15 mei '11 om 11:53 uur 2011-05-15 23:53

Nou , hier is wat informatie over git pull en git fetch , zodat je de werkelijke verschillen kunt begrijpen ... in een paar eenvoudige woorden haalt fetch de laatste gegevens, maar verandert de code niet en neemt geen contact op met je huidige lokale branchecode, maar trekt de code eruit met de veranderingen en voeg het samen met je lokale filiaal, lees verder voor meer gedetailleerde informatie over elk:

Git Fetch

Het downloadt alle links en objecten en eventuele nieuwe branches naar uw lokale repository ...

Kies branches en / of tags (samen, "refs") van een of meer andere repositories, samen met de objecten die nodig zijn om hun verhalen te voltooien. Bijgewerkte remote tracking-takken (zie onderstaande beschrijving voor manieren om dit gedrag te beheren).

Standaard wordt elke tag die verwijst naar geëxtraheerde verhalen ook opgehaald; het effect is om tags te extraheren die naar de branches wijzen waarin je bent geïnteresseerd. Dit standaardgedrag kan worden gewijzigd met de opties - tags of --no-tags of door de afstandsbediening in te stellen .. TagOpt. Met behulp van refspec, waarmee expliciet tags worden geëxtraheerd, kunt u tags extraheren die niet naar de branches wijzen waarin u bent geïnteresseerd.

git fetch kan worden opgehaald uit een enkele benoemde repository of URL, of uit meerdere repositories tegelijk, indien gegeven, en er zijn consoles. schrijf naar het configuratiebestand. (Zie Git-config 1 ).

Als geen extern apparaat is opgegeven, wordt de standaardstartbron gebruikt, tenzij een upstream-branch is geconfigureerd voor de huidige tak.

De namen van de links die worden geselecteerd, samen met de namen van de objecten waarnaar ze verwijzen, worden geschreven in.git / FETCH_HEAD. Deze informatie kan worden gebruikt door scripts of andere git-commando's, zoals git-pull.


git pull

Het past veranderingen toe van remote naar current branch op lokale ...

Omvat wijzigingen van een externe repository naar de huidige branch. In de standaardmodus is git pull een afkorting voor git fetch, gevolgd door git merge FETCH_HEAD.

Meer specifiek, git pull draait git fetch met de opgegeven parameters en roept git merge op om de ontvangen branch headers samen te voegen met de huidige branch. Met behulp van --rebase wordt git rebase uitgevoerd in plaats van git merge.

moet de naam zijn van de externe repository die is doorgegeven aan git-fetch 1 . kan een willekeurige externe ref (bijvoorbeeld de tagnaam) of zelfs een verzameling links met corresponderende remote tracking-takken (bijvoorbeeld refs / heads /: refs / remotes / origin /), maar meestal is dit de naam van de branch in de externe repository.

De standaardwaarden voor en worden gelezen uit de configuraties "remote" en "merge" voor de huidige branch, zoals ingesteld door git-branch - track.


Ik maak ook een visuele afbeelding hieronder om je te laten zien hoe git fetch en git pull samenwerken ...

2019

2019

122
06 февр. het antwoord wordt th3sly 06 februari gegeven . 2015-02-06 14:48 '15 om 14:48 2015-02-06 14:48

bonus:

Over stretching en extractie in de bovenstaande antwoorden gesproken, ik wil graag een interessante truc delen,

git pull --rebase

Dit bovenstaande commando is het meest bruikbare commando in mijn leven, wat veel tijd heeft bespaard.

Probeer deze opdracht voordat u nieuwe commits naar de server pusht en synchroniseert automatisch de nieuwste serverwijzigingen (met fetch + merge) en zet uw bericht aan het begin in het git-logboek. U hoeft zich geen zorgen te maken over het trekken aan de hand / samenvoegen.

Vind informatie op: http://gitolite.com/git-pull--rebase

119
23 дек. Het antwoord wordt gegeven door Sazzad Hissain Khan op 23 december. 2015-12-23 18:31 '15 om 18:31 2015-12-23 18:31

Ik hou ervan om een ​​soort visuele weergave van de situatie te hebben om deze dingen te begrijpen. Misschien willen andere ontwikkelaars dit ook graag zien, dus hier is mijn toevoeging. Ik ben er niet helemaal zeker van dat alles correct is, dus geef alsjeblieft commentaar als je fouten ontdekt.

  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 . . . FETCH *------------------>* Your local cache of the remote is updated with the origin (or multiple external sources, that is git 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. 

Enkele van de be>

  • Prestaties (scrollen van alle commits en berichten zonder te proberen het via het netwerk te comprimeren)
  • Feedback over de status van je lokale repo (ik gebruik bijvoorbeeld Atlassian SourceTree, die me een gloeilamp geeft die aangeeft of ik vooruit of achteruit zal gaan in vergelijking met de bron. Update met GIT FETCH).
110
20 февр. Het antwoord wordt gegeven door Justus Romijn op 20 februari. 2014-02-20 00:18 '14 om 0:18 2014-02-20 00:18

Ik heb hier ook moeite mee gehad. Sterker nog, ik kwam hier met Google zoeken voor precies dezelfde vraag. Nadat ik al deze antwoorden had gelezen, tekende ik eindelijk een foto in mijn hoofd en besloot ik om te gaan met de toestand van 2 repositories en 1 sandbox en de acties die met de tijd werden uitgevoerd, hun versie te bekijken. Dus dat is wat ik bedacht. Corrigeer me als ik het verprutst.

Drie repositories met een voorbeeld:

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

Drie repositories met een last

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

Dit heeft me geholpen begrijpen waarom sampling erg be>

102
17 июля '12 в 19:43 2012-07-17 19:43 het antwoord wordt gegeven pn1 maat 17 juli '12 om 19:43 uur 2012-07-17 19:43

Het verschil tussen GIT Fetch en GIT Pull kan worden verklaard door het volgende scenario: (Denk eraan dat de beelden meer zeggen dan woorden! Ik heb een grafische weergave gegeven)

Laten we aannemen dat je aan een project werkt met leden van je team. Daarom zullen ze een van de hoofddivisies van het project zijn en moeten alle deelnemers het uitplanten in hun eigen lokale repository, en vervolgens aan deze lokale vestiging werken om modules te wijzigen / toevoegen en vervolgens terugkeren naar de hoofdvestiging.

Dus, de initiële status van de twee vestigingen, wanneer je het hoofdproject in je lokale repository verrekent, zal zo zijn- ( A , B en C zijn de modules die al in het project zijn voltooid)

Nu ben je begonnen aan een nieuwe module (veronderstel D ), en wanneer je module D hebt voltooid die je naar de hoofdfiliaal wilt sturen, maar wat gebeurt, is dat een van je teamgenoten nieuwe modules E , F en gemodificeerde C
Итак, теперь произошло то, что у вашего локального репозитория не хватает первоначального прогресса проекта, и, таким образом, нажатие ваших изменений в основную ветку может привести к конфликту и может привести к сбою вашего модуля D