git - remote - pull request cos è




Qual è la differenza tra "git pull" e "git fetch"? (20)

Nota del moderatore: Dato che questa domanda ha già ricevuto sessantasette risposte (alcune cancellate), considera se stai contribuendo o meno a qualcosa di nuovo prima di postarne un altro.

Quali sono le differenze tra git pull e git fetch ?


Qual è la differenza tra git pulle git fetch?

Per capire questo, devi prima capire che il tuo git locale mantiene non solo il tuo repository locale, ma mantiene anche una copia locale del repository remoto.

git fetchaggiorna la tua copia locale del repository remoto. Ad esempio, se il tuo repository remoto è GitHub, potresti voler recuperare tutte le modifiche apportate nel repository remoto alla tua copia locale del repository remoto. Ciò ti consentirà di eseguire operazioni come confrontare o unire.

git pulld'altra parte porterà giù le modifiche nel repository remoto a dove manterrai il tuo codice. In genere, git pulleseguirà git fetchprima un aggiornamento della copia locale del repository remoto, quindi unirà le modifiche nel proprio repository di codice e possibilmente nella propria copia di lavoro.


Bonus:

Parlando di pull & fetch nelle risposte di cui sopra, mi piacerebbe condividere un trucco interessante,

git pull --rebase

Questo comando sopra è il comando più utile nella mia vita git che ha risparmiato un sacco di tempo.

Prima di inviare il tuo nuovo commit al server, prova questo comando e sincronizzerà automaticamente le ultime modifiche del server (con un recupero + unione) e posizionerà il commit nella parte superiore del registro git. Non c'è bisogno di preoccuparsi di pull / fusione manuale.

Trova i dettagli su: http://gitolite.com/git-pull--rebase


È possibile recuperare da un repository remoto, vedere le differenze e quindi tirare o unire.

Questo è un esempio per un repository remoto chiamato origin e un ramo chiamato master tiene traccia origin/master ramo remoto:

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

A volte una rappresentazione visiva aiuta.


La risposta breve e facile è che git pull è semplicemente git fetch seguito da git merge .

È molto importante notare che git pull si fonderà automaticamente se ti piace o meno . Ciò potrebbe, naturalmente, causare conflitti di fusione. Diciamo che il tuo telecomando è di origin e il tuo ramo è master . Se git diff origin/master prima di tirare, dovresti avere qualche idea di potenziali conflitti di fusione e potresti preparare la tua diramazione locale di conseguenza.

Oltre a tirare e spingere, alcuni flussi di lavoro implicano git rebase , come questo, che ho parafrasato dall'articolo collegato:

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

Se ti trovi in ​​una situazione del genere, potresti essere tentato di prendere git pull --rebase . A meno che tu non sappia davvero cosa stai facendo, ti sconsiglio di farlo. Questo avviso proviene dalla pagina man di git-pull , versione 2.3.5 :

Questa è una modalità di funzionamento potenzialmente pericolosa. Riscrive la storia, che non promette nulla di buono quando hai già pubblicato quella storia. Non usare questa opzione se non hai letto attentamente git-rebase (1).


Mi è costato un po 'capire qual era la differenza, ma questa è una spiegazione semplice. master nel tuo localhost è un ramo.

Quando si clona un repository, si recupera l'intero repository sull'host locale. Ciò significa che in quel momento hai un puntatore origine / master su HEAD e il master punta allo stesso HEAD .

quando inizi a lavorare e ti impegni, fai avanzare il puntatore master su HEAD + i tuoi commit. Ma il puntatore origine / master punta ancora a quello che era quando hai clonato.

Quindi la differenza sarà:

  • Se git fetch un git fetch , recupererai tutte le modifiche nel repository remoto ( GitHub ) e sposterai il puntatore origine / master su HEAD . Nel frattempo il tuo supervisore di ramo locale continuerà a indicare dove si trova.
  • Se git pull una git pull , in pratica eseguirà il recupero (come spiegato in precedenza) e unirà tutte le nuove modifiche al ramo master e sposterà il puntatore su HEAD .

Nei termini più semplici, git pull fa un git fetch seguito da una git merge .

Puoi fare un git fetch in qualsiasi momento per aggiornare i tuoi rami di tracciamento remoto sotto refs/remotes/<remote>/ .

Questa operazione non cambia mai nessuno dei tuoi rami locali sotto refs/heads , ed è sicuro di fare senza modificare la tua copia di lavoro. Ho persino sentito parlare di persone che eseguono git fetch periodicamente in un cron job in background (anche se non consiglierei di farlo).

Un git pull è ciò che si farebbe per aggiornare un ramo locale con la sua versione remota, aggiornando anche gli altri rami di tracciamento remoto.

Documentazione Git: git pull


Un caso d'uso di git fetch è che quanto segue ti dirà qualsiasi cambiamento nel ramo remoto dal tuo ultimo tiro ... in modo da poter controllare prima di fare un tiro effettivo, che potrebbe cambiare i file nel tuo ramo corrente e copia di lavoro.

git fetch
git diff ...origin

git fetchrecupererà i rami remoti in modo da poterli git diffo git mergeloro con il ramo corrente. git pulleseguirà il recupero sul brach remoto tracciato dal ramo corrente e quindi unirà il risultato. È possibile utilizzare git fetchper vedere se ci sono aggiornamenti al ramo remoto senza doverli unire con il ramo locale.


Brevemente

git fetch è simile a pull ma non si unisce. cioè recupera aggiornamenti remoti ( refs e objects ) ma il tuo locale rimane lo stesso (cioè l' origin/master viene aggiornato ma il master rimane lo stesso).

git pull tira giù da un telecomando e si fonde all'istante.

Di Più

cloni git clone clone un repo.

git rebase salva elementi dal ramo corrente che non si trova nel ramo upstream in un'area temporanea. Il tuo ramo è ora lo stesso di prima di iniziare le modifiche. Quindi, git pull -rebase abbatterà le modifiche remote, riavvolgerà il tuo ramo locale, riprodurrà le tue modifiche sulla parte superiore del tuo ramo corrente una alla volta fino a quando non sarai aggiornato.

Inoltre, git branch -a ti mostrerà esattamente cosa sta succedendo a tutte le tue filiali, locali e remote.

Questo post del blog è stato utile:

La differenza tra git pull, git fetch e git clone (e git rebase) - Mike Pearce

e copre git pull , git fetch , git clone e git rebase .

====

AGGIORNARE

Ho pensato di aggiornarlo per mostrare come lo utilizzeresti in pratica.

  1. Aggiorna il repository locale dal telecomando (ma non unire):

    git fetch

  2. Dopo aver scaricato gli aggiornamenti, vediamo le differenze:

    git diff master origin / master

  3. Se sei soddisfatto di questi aggiornamenti, quindi unisci:

    tira fuori

Gli appunti:

Al punto 2: Per maggiori informazioni sulle differenze tra locale e remoto , vedere: confrontare il ramo git locale con il ramo remoto?

Al punto 3: Probabilmente è più accurato (ad es. Su un repository in rapida evoluzione) per creare un'origine del re git rebase origin qui. Vedi il commento di @Justin Ohms in un'altra risposta.

Vedi anche: longair.net/blog/2009/04/16/git-fetch-and-merge


OK , ecco alcune informazioni su git pull e git fetch , in modo che tu possa capire le differenze effettive ... in poche parole semplici, recupera i dati più recenti, ma non le modifiche al codice e non ha problemi con il tuo attuale codice locale , ma ottieni le modifiche al codice e uniscilo alla tua filiale locale, continua a leggere per ottenere maggiori dettagli su ciascuna:

git fetch

Scaricherà tutti i riferimenti e gli oggetti e tutti i nuovi rami nel tuo repository locale ...

Recupera rami e / o tag (collettivamente, "ref") da uno o più altri repository, insieme agli oggetti necessari per completare le loro storie. I rami di monitoraggio remoto vengono aggiornati (vedere la descrizione di seguito per i modi per controllare questo comportamento).

Per impostazione predefinita, viene recuperato anche qualsiasi tag che punta alle cronologie che vengono recuperate; l'effetto è di recuperare i tag che puntano ai rami a cui sei interessato. Questo comportamento predefinito può essere modificato usando le opzioni --tags o --no-tags o configurando remote..tagOpt. Utilizzando un refspec che recupera i tag in modo esplicito, puoi recuperare tag che non puntano ai rami che ti interessano.

git fetch può prelevare da un singolo repository o URL con nome, o da più repository contemporaneamente se viene fornito e c'è un telecomando. entrata nel file di configurazione. (Vedi git-config 1 ).

Quando non viene specificato alcun telecomando, per impostazione predefinita verrà utilizzato il telecomando di origine, a meno che non sia configurato un ramo a monte per il ramo corrente.

I nomi dei ref che vengono recuperati, insieme ai nomi degli oggetti a cui puntano, sono scritti in .git / FETCH_HEAD. Questa informazione può essere utilizzata da script o altri comandi git, come git-pull.

tira fuori

Applicherà le modifiche da remoto al ramo corrente in locale ...

Incorpora le modifiche da un repository remoto nel ramo corrente. Nella sua modalità predefinita, git pull è una scorciatoia per git fetch seguito da git merge FETCH_HEAD.

Più precisamente, git pull esegue git fetch con i parametri specificati e chiama git merge per unire le branch branch recuperate nel ramo corrente. Con --rebase, esegue git rebase invece di git merge.

dovrebbe essere il nome di un repository remoto come passato a git-fetch 1 . può nominare un ref remoto arbitrario (ad esempio, il nome di un tag) o anche una raccolta di ref con corrispondenti diramazioni remote (ad esempio, refs / heads / : refs / remotes / origin / ), ma di solito è il nome di un ramo nel repository remoto.

I valori predefiniti per e vengono letti dalla configurazione "remota" e "unisci" per il ramo corrente come impostato da git-branch --track.

Creo anche l'immagine sotto per mostrarti come git fetch e git pull lavorano insieme ...

1


Cercando di essere chiaro e semplice.

Il git pull comando è in realtà una shortcutper git fetch seguita dalla fusione git o il git rebase di comando a seconda della configurazione. Puoi configurare il tuo repository Git in modo che git pull sia un fetch seguito da un rebase.


Git ottiene il ramo dell'ultima versione dal remoto al locale usando due comandi:

  1. git fetch: Git sta per ottenere l'ultima versione da remota a locale, ma non si unisce automaticamente. git fetch origin master git log -p master..origin/master git merge origin/master

    I comandi sopra indicano che scaricare l'ultima versione del ramo principale dall'origine dal ramo principale remoto a quello di origine. E quindi confronta il ramo master locale e il ramo master di origine. Infine, unisci.

  2. git pull: Git sta per ottenere l'ultima versione dal telecomando e unirsi al locale.

    git pull origin master

    Il comando sopra è l'equivalente di git fetche git merge. In pratica, git fetchforse più sicuro perché prima della fusione possiamo vedere le modifiche e decidere se unire.


In realtà Git mantiene una copia del tuo codice e del repository remoto.

Il comando git fetchrende aggiornata la tua copia locale recuperando i dati dal repository remoto. Il motivo per cui abbiamo bisogno di questo è perché qualcun altro potrebbe aver apportato alcune modifiche al codice e vuoi tenerti aggiornato.

Il comando git pullporta le modifiche nel repository remoto a dove mantieni il tuo codice. Normalmente, git pullciò avviene innanzitutto eseguendo un 'git fetch' per aggiornare la copia locale dell'archivio remoto e quindi unire le modifiche nel proprio repository di codice e possibilmente nella propria copia di lavoro.


git pull == (git fetch + git merge)

git fetch non cambia alle filiali locali.

Se si dispone già di un repository locale con una configurazione remota per il progetto desiderato, è possibile afferrare tutti i rami e i tag per il telecomando esistente utilizzando git fetch. ... Fetch non apporta modifiche ai rami locali, quindi sarà necessario unire un ramo remoto con un ramo locale abbinato per incorporare le nuove modifiche di recupero. da Github


Questa rappresentazione grafica interattiva è molto utile per semplificare git: http://ndpsoftware.com/git-cheatsheet.html

git fetch semplicemente "scarica" ​​le modifiche dal remoto al tuo repository locale. git pull scarica le modifiche e le unisce al ramo attuale. "Nella sua modalità predefinita, git pull è una scorciatoia per git fetch seguito da git merge FETCH_HEAD ."


Ho lottato anche con questo. Infatti sono arrivato qui con una ricerca su google della stessa identica domanda. Leggendo tutte queste risposte alla fine ho dipinto un quadro nella mia testa e ho deciso di provare a capirlo guardando lo stato dei 2 repository e 1 sandbox e le azioni eseguite nel tempo mentre guardavo la loro versione. Quindi ecco cosa mi è venuto in mente. Per favore correggimi se ho incasinato ovunque.

I tre repository con un recupero:

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

I tre repos con un tiro

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

Questo mi ha aiutato a capire perché un recupero è piuttosto importante.


L'unica differenza tra git pulled git fetchè che:

git pull tira da un ramo remoto e lo fonde.

git fetch recupera solo dal ramo remoto ma non si unisce

cioè git pull = git fetch + git merge ...


git-pull - Fetch from and merge with another repository or a local branch
SYNOPSIS

git pull   …
DESCRIPTION

Runs git-fetch with the given parameters, and calls git-merge to merge the 
retrieved head(s) into the current branch. With --rebase, calls git-rebase 
instead of git-merge.

Note that you can use . (current directory) as the <repository> to pull 
from the local repository — this is useful when merging local branches 
into the current branch.

Also note that options meant for git-pull itself and underlying git-merge 
must be given before the options meant for git-fetch.

Tireremmo se volete che le storie si uniscano, voi otterreste se solo "volete il codez" dato che qualcuno ha etichettato alcuni articoli qui intorno.


git pull = git fetch + git merge 




git-fetch