În termeni simpli, git pull nu o git fetch urmat de git merge.

Poti face o git fetch în orice moment pentru a actualiza de la distanță-de urmărire ramuri sub ref/telecomenzi/<de la distanță>/.

Această operațiune nu se schimbă niciodată de propriile filiale sub ref/ "capetelor", și este sigur de a face fără a schimba copia de lucru. Am auzit de oameni care ruleazăgit fetch` periodic într-un loc de muncă cron în fundal (deși mi-ar't recomanda face acest lucru).

O git pull e ceea ce ai putea face pentru a aduce o filială locală up-to-data cu versiunea de la distanță, în timp ce, de asemenea, actualizarea de la distanță alte urmărire ramuri.

Git documentare – git pull:

de asemenea, În mod implicit, git pull este prescurtarea pentru git fetch", urmat de " git merge FETCH_HEAD.

• Atunci când utilizați "pull", Git încearcă automat să lucreze pentru tine. Este sensibil la context, deci Git va merge orice tras se angajează în ramură sunt lucrează în prezent în. "pull" unifică în mod automat angajează, fără a permițându-vă să le revizuiască prima. Dacă nu ești atent gestiona ramuri, aveți dreptul să executați în conflicte frecvente.

• Când ai "aport", Git adună orice se angajează de la ținta de ramură, care nu există în ramură și le stochează în depozit local. Cu toate acestea, nu le îmbina cu curent de ramură. Acest lucru este deosebit de util dacă aveți nevoie pentru a păstra depozit la curent, dar sunt de lucru pe ceva care s-ar putea rupe dacă actualizați fișierele. Pentru a integra angajează în ramura master, utilizați merge.

Este important de contrast filosofia de design de git cu filozofia de o mai tradiționale sursă instrument de control ca SVN.

Subversiune a fost proiectat și construit cu un client/server model. Există un singur depozit care este serverul, și mai multe clienții pot aduce codul de pe server, lucru pe ea, se angajează apoi înapoi la server. Ipoteza este că clientul poate contacta întotdeauna server atunci când acesta are nevoie pentru a efectua o operație.

Git a fost conceput pentru a sprijini o mai distribuite model cu nu este nevoie de un depozit central (deși puteți folosi cu siguranță unul, dacă doriți). De asemenea, git a fost conceput în așa fel încât clientul și "server" nu't nevoie să fie online în același timp. Git a fost conceput astfel încât oamenii de pe o încredere link-ul ar putea face schimb de cod prin e-mail, chiar. Este posibil de a lucra complet deconectat și de a arde un CD la schimb cod prin git.

În scopul de a sprijini acest model git menține un depozit local cu codul dvs. și, de asemenea, o suplimentare de depozit local, care reflectă starea de depozitul de la distanță. Prin păstrarea unui exemplar din depozitul de la distanță la nivel local, git putem da seama de modificările necesare chiar și atunci când depozitul de la distanță nu este accesibil. Mai târziu, atunci când aveți nevoie pentru a trimite modificările la altcineva, git le pot transfera, ca un set de modificări la un moment dat în timp cunoscut pentru depozitul de la distanță.

• git fetch este comanda care spune "aduce copie locală din depozitul de la distanță până la data de."

• git pull spune "aduce schimbări în depozitul de la distanță pentru a în cazul în care-mi țin propriul cod."

În mod normal, git pull are asta de a face o git fetch să aducă copia locală din depozitul de la distanță până la data de, și apoi fuzionarea schimbări în propriul cod de depozit și, eventual, copia de lucru.

Ia este de a păstra în minte că de multe ori există cel puțin trei exemplare de un proiect pe stația dumneavoastră de lucru. O copie este propriul depozit cu propriile comite istorie. Al doilea exemplar este copia de lucru în cazul în care sunteți de editare și de construcție. Cel de-al treilea exemplar este local "cache" copie a unui depozit la distanță.

Aici este Oliver Steele's imaginea cum totul se potrivește împreună:

Dacă există suficient interes, cred că am putea actualiza imaginea pentru a adăuga git clona " și " git merge...

Un caz de utilizare a git fetch este că următorul va spune orice modificări în ramură de la distanță de la ultima ta trage... astfel încât să puteți verifica înainte de a face o reală trage, care ar putea modifica fișierele în ramură și copia de lucru.

git fetch
git diff ...origin

A se vedea: https://git-scm.com/docs/git-diff cu privire dublu si triplu punct de sintaxă în diff comanda

M-a costat un pic de a înțelege ceea ce a fost diferența, dar aceasta este o explicație simplă. "stăpân" în localhost este o ramura.

Când clona un depozit aduce întregul depozit pentru tine gazdă locală. Acest lucru înseamnă că la acel moment nu au o origine/master pointer la " ȘEF "și maestrul arătând spre același "ȘEF".

atunci când începi să lucrezi și nu se angajează avans master pointer la " ȘEF " + ta comite. Dar originea/master pointer este încă arătând spre ceea ce a fost atunci când ai clonat.

Deci, diferența va fi:

• Dacă faci o git fetch va aduce toate modificările în depozitul de la distanță (GitHub) și pentru a muta originea/master pointer la "ȘEF". Între timp, filiala locală master va ține îndreptat acolo unde trebuie.
• Dacă faci o git pull, se va face practic aduce (cum este explicat anterior) și merge orice noile modificări la stăpânul tău ramură și pentru a muta cursorul la "ȘEF".

Uneori o reprezentare vizuală ajută.

Pe scurt

git fetch e similare pentru a "trage" dar nu't merge. anume acesta preia actualizări de la distanță (ref și "obiectele"), dar local rămâne aceeași (de exemplu `origine/master s-a actualizat dar "maestrul" rămâne aceeași) .

git pull trage în jos de la distanță și instantaneu fuzionează.

****Mai

git clona clonele un repo.

git rebazare salvează lucruri de pe ramură de curent care e't în amonte sucursala la o zonă temporară. Filiala este acum la fel ca înainte de a începe dvs. de schimbări. Deci, git pull-rebazare va trage în jos de la distanță de modificări, înapoi filiala locală, reluarea modificări de-a lungul partea de sus a dvs. curentă ramură unul câte unul, până când veți're up-to-data de.

De asemenea, `git branch -o va arăta exact ce se întâmplă cu toate filialele locale și la distanță.

Acest blog a fost de folos:

Diferența dintre git pull, git fetch și git clone (si git rebazare) - Mike Pearce

și acoperă git pull, git fetch, git clona " și " git rebazare.

====

UPDATE

Am crezut că am'd actualiza acest lucru pentru a arăta cum'd folosi de fapt acest lucru în practică.

1. Actualizare locală repo la distanță (dar nu't merge):

git fetch

2. După descărcarea de actualizări, să's a vedea diferențele:

git diff master origine/master

3. Daca're fericit cu aceste actualizări, apoi merge:

git pull

Note:

Pe pasul 2: Pentru mai multe detalii despre diff între locale și telecomenzi, a se vedea: https://stackoverflow.com/questions/1800783/compare-local-git-branch-with-remote-branch

Pe pasul 3: L's, probabil, mult mai exacte (de exemplu, pe o schimbare rapidă repo) de a face un `git rebazare originea aici. A se vedea @Justin Ohmi comentariu într-un alt răspuns.

Vezi de asemenea și: http://longair.net/blog/2009/04/16/git-fetch-and-merge/

git-trage - i Aducă de la și de a fuziona cu un alt depozit sau o filială locală
SINOPSIS
git pull <opțiuni>  ...
DESCRIERE
Ruleaza git-aduce cu parametrii de date și apeluri git-merge să fuzioneze 
accesat la cap(s) în ramura curentă. Cu-rebazare, apeluri git-rebazare 
în loc de git-merge.
Rețineți că puteți utiliza . (directorul curent) ca <repository - > pentru a trage 
de la depozitul local — acest lucru este util atunci când fuzionează filiale locale 
în ramura curentă.
De asemenea, rețineți că opțiunile însemnat pentru git-trage în sine și de fond al sistemului git-merge 
trebuie dat inainte de opțiuni a însemnat pentru git-aduce.

Te-ar trage daca vrei istoriile fuzionat, ai'd adu dacă te doar 'vreau codez' ca unele persoane au fost marcare de unele articole de aici.

Te poate aduce la un depozit la distanță, a se vedea diferențele și apoi trageți sau fuziona.

Acesta este un exemplu pentru un depozit la distanță numit "origine" și o ramură numită "maestru" de urmărire la distanță de ramură `origine/master:

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

Scurt și ușor răspunsul este că git pull este pur și simplu git fetch", urmat de " git merge.

Este foarte important să rețineți că git pull va fuziona automat dacă vă place sau nu. Acest lucru ar putea, desigur, rezultat din îmbinarea conflicte. Las's spun la distanță este de "origine" și filiala este "maestru". Dacă tu `git diff de origine/de master înainte de a trage, ar trebui să aveți o idee despre potențialul merge conflicte și ar putea pregăti filiala locală în consecință.

În plus față de tragere și împingere, unele fluxuri de lucru a se implica git rebazare, cum ar fi aceasta, care, citez din articol legat:

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

Dacă vă aflați într-o astfel de situație, ați putea fi tentați să git pull --rebazare. Dacă chiar știi ce faci, nu te-aș sfătui. Acest avertisment este din om pagina git-trage, versiunea 2.3.5`:

Acesta este un potențial periculoase modul de funcționare. Se rescrie istoria, care nu prevestește nimic bun atunci când ai publicat asta de istorie deja. Nu utilizați această opțiune dacă nu ai citit git-rebazare(1) cu atenție.

OK, aici sunt unele informații despre git pull " și " git fetch`, astfel încât să puteți înțelege diferențele reale... în câteva cuvinte simple, aduce primește cele mai recente date, dar nu și de modificări de cod și nu o să-ți strice locală curentă codul de ramură, dar trage obține modificări de cod și fuziona filiala locală, citiți mai departe pentru a obține mai multe detalii despre fiecare:

git fetch

Se va descărca toate ref și obiecte și orice noi ramuri de Depozit local...

Aduce sucursale și/sau tag-uri (denumite în mod colectiv "blocat") de la una sau mai multe alte depozite, împreună cu obiectele necesare pentru finalizarea lor istorii. De la distanță-de urmărire ramuri sunt actualizate (a se vedea descrierea

mai jos pentru moduri de a controla acest comportament).

implicit, orice etichetă care indică în istoriile fiind preluat este de asemenea, preluat; efectul este de a aduce categorie acel moment la ramurile care sunteți interesat în. Acest comportament poate fi schimbat prin utilizarea --categorie sau-nu-tag-uri sau opțiuni de configurare de la distanță..tagOpt. Prin utilizarea unui refspec care preia tag-uri în mod explicit, vă poate aduce tag-uri care nu indică în ramuri sunteți interesat la fel de bine.

git fetch poate aduce fie un singur nume depozit sau URL-ul, sau de la mai multe depozite la o dată, dacă este dat și există o telecomenzi. de intrare în fișierul de configurare. (A se vedea git-config1).

de la distanță atunci Când nu este specificat, implicit originea de la distanță va fi folosit, dacă nu există în amonte de ramură configurat pentru curent ramură.

numele de arbitrii care sunt preluate, împreună cu nume de obiecte ei la punct, sunt scrise .git/FETCH_HEAD. Aceste informații pot fi folosit de script-uri sau alte git comenzi, cum ar fi git-pull.

git pull

Se va aplica modificările de la la distanță la curent de ramură în local...

Include modificări de la un depozit la distanță în ramura curentă. de asemenea, În mod implicit, git pull este prescurtarea pentru git fetch urmat de git merge FETCH_HEAD.

Mai precis, git pull ruleaza git fetch cu parametrii de date și solicită git merge să fuzioneze preluate de ramură capete în curent ramură. Cu-rebazare, ruleaza git rebazare în loc de git merge.

ar trebui să fie numele unui depozit la distanță ca a trecut la git-aduce[1]. poate un nume arbitrar de la distanță ref (de exemplu, numele unui tag) sau chiar o colecție de arbitrii cu corespunzătoare de la distanță-de urmărire ramuri (de exemplu, ref/capete/*:ref/telecomenzi/origine/*), dar, de obicei, acesta este numele de o sucursală în depozitul de la distanță.

valori Implicite pentru și sunt citite de la "de la distanță" și "merge" configurare pentru ramura curentă stabilit de git-sucursala-track.

Am crea, de asemenea, vizual de mai jos pentru a vă arăta cum `git fetch " și "git pull" - " împreună...

Această interactive reprezentare grafică este foarte util în understanging git: http://ndpsoftware.com/git-cheatsheet.html

git fetch doar "descărcări" modificările de la distanță la depozit local. git pull popularitate modificările și unește-le în ramură de curent. "În mod implicit, git pull este prescurtarea pentru git fetch", urmat de " git merge FETCH_HEAD."

Bonus:

Vorbind despre pull & aduce in raspunsurile de mai sus, aș dori să vă împărtășesc un truc interesant,

git pull --rebazare

Aceasta comanda de mai sus este cea mai utilă comandă în git viață care a salvat o mulțime de timp.

Înainte de a împinge noul tău se angajează la server, încercați această comandă și se va sincroniza automat cele mai recente modificări de server (cu un aport + îmbinare) și va comite în partea de sus în git log. Nu este nevoie să vă faceți griji despre manual trage/merge.

Găsiți detalii la: http://gitolite.com/git-pull--rebase

Îmi place să am niște reprezentare vizuală a situației pentru a înțelege aceste lucruri. Poate alte dezvoltatorii ar dori să-l văd, așa că aici's my plus. Am'm nu în totalitate sigur că totul este corect, așa că vă rugăm să comentați dacă găsiți orice greșeli.

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

M-am luptat cu asta. De fapt am ajuns aici cu o căutare pe google exact aceeași întrebare. Citind toate aceste răspunsuri în cele din urmă a pictat o imagine în capul meu și am decis să încerc pentru a obține acest lucru în jos, uitându-se la starea celor 2 centrale de tranzacții și 1 sandbox și acțiunile efectuate de-a lungul timpului în timp ce uitam de versiunea de ei. Deci, aici este ceea ce am venit cu. Vă rog să mă corectați dacă am greșit undeva.

Cele trei operațiuni repo cu o aduce:

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

Cele trei operațiuni repo cu o trage

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

Acest lucru m-a ajutat să înțeleg de ce o aduce este destul de important.

Diferenta dintre GIT Fetch și GIT Pull poate fi explicat cu următorul scenariu: (Ținând cont de faptul că imaginile vorbesc mai tare decât cuvintele!, Am asigurat reprezentarea picturală)

Las's ia un exemplu că sunteți de lucru pe un proiect cu membrii echipei. Deci va fi o Ramură de bază a proiectului și toate contribuabili trebuie să furculiță pentru propria lor depozit local și apoi de lucru pe acest filiala locală a modifica/Adauga module apoi împinge înapoi de la ramura principală.

Deci, Starea inițială de cele două Ramuri când incarcatori principalul proiect de pe depozit local va fi o astfel de prognoze - ("A", " B " și " C " sunt Module deja finalizat de proiect)

Acum, au început să lucreze la noul modul (să presupunem că "D"), și atunci când ați terminat " D "modul doriți să-l împingă la filiala principală, Dar în același timp ceea ce se întâmplă este că unul dintre colegii tăi a dezvoltat noul Modul "E", " F "și modificate "C".
Deci, acum ce s-a întâmplat este că, depozit local este lipsit spatele original progresul proiectului și împingând astfel de modificări la filiala principală poate duce la conflict și poate provoca Modul " D " la defecțiune.

Pentru a evita astfel de probleme și să lucreze în paralel cu originalul progresul proiectului lor sunt de Două feluri:

1. Git Fetch- Acest lucru va Descărca toate modificările care au fost făcute la origine/ramură principală a proiectului, care nu sunt prezente în filiala locală. Și va aștepta pentru Git comanda Merge pentru a aplica modificările care au fost aduse la Depozit sau de ramură.

Deci, acum puteți monitoriza cu atenție fișierele înainte de fuziunea este la depozit. Și puteți modifica, de asemenea, "D", dacă este necesar, pentru că a Modificat "C".

2. Git Pull- Acest lucru va actualiza filiala locală cu originea/filiala principală, adică, de fapt, ceea ce face este o combinație de Git Fetch și Git merge unul după altul. Dar acest lucru poate Duce la Conflicte să apară, așa că este recomandat să folosiți Git Pull cu o copie curată.

Vom spune pur și simplu:

git pull == git fetch + git merge

Dacă tu a alerga git pull, nu aveți nevoie pentru a fuziona date locale. Dacă tu a alerga git fetch, înseamnă că trebuie să ruleze `git merge pentru a obține cele mai recente cod pentru mașina dumneavoastră. În caz contrar, mașina locală cod nu s-ar fi schimbat, fără a fuziona.

Deci in Git Gui, atunci când faci fetch, trebuie să îmbinați datele. Aduce în sine a câștigat't face modificări de cod de la locale. Puteți verifica că atunci când actualizați codul de preluarea odată ce aduce și vedea; codul nu va't se schimbe. Apoi îmbinați... Veți vedea codul de schimbat.

git fetch trage în jos codul din serverul de la distanță urmărire ramuri în depozit local. Dacă telecomanda este numit "origine" (implicit), atunci aceste ramuri va fi în termen de origine/, de exempluorigine/master,origine/mybranch-123`, etc. Acestea nu sunt curentă ramuri, acestea sunt locale copii ale acestor filiale de pe server.

git pull nu o git fetch dar apoi de asemenea îmbină codul de urmărire ramură în actuala versiune locală de sucursala. Daca're gata pentru că schimbă, doar pentru git fetch` prima.

git fetch va prelua de la distanță ramuri, astfel încât să puteți git diff " sau " git merge le cu ramura curentă. git pull va rula aduce pe telecomanda brach urmărite de către ramura curentă și apoi îmbinați rezultatul. Puteți utiliza git fetch pentru a vedea dacă există orice actualizări de la distanță ramură fără necesar de a le fuzionează cu filiala locală.