git fetch (Italiano)

Il comandogit fetch scarica commit, file e refs da un repository remoto nel repository locale. Il recupero è quello che fai quando vuoi vedere su cosa stanno lavorando tutti gli altri. È simile asvn update in quanto ti consente di vedere come è progredita la cronologia centrale, ma non ti costringe a unire effettivamente le modifiche nel tuo repository. Git isola il contenuto recuperato dal contenuto locale esistente; non ha assolutamente alcun effetto sul lavoro di sviluppo locale., Il contenuto recuperato deve essere estratto esplicitamente utilizzando il comandogit checkout. Ciò rende il recupero un modo sicuro per rivedere i commit prima di integrarli con il repository locale.

Quando si scaricano contenuti da un repository remoto, i comandigit pull egit fetch sono disponibili per eseguire l’operazione. Puoi considerare git fetch la versione ‘sicura’ dei due comandi. Scaricherà il contenuto remoto ma non aggiornerà lo stato di lavoro del repository locale, lasciando intatto il lavoro corrente., git pull è l’alternativa più aggressiva; scaricherà il contenuto remoto per il ramo locale attivo ed eseguirà immediatamentegit merge per creare un commit di unione per il nuovo contenuto remoto. Se sono in corso modifiche in sospeso, ciò causerà conflitti e avvierà il flusso di risoluzione dei conflitti di unione.

Come git fetch funziona con i rami remoti

Per capire meglio come funzionagit fetch discutiamo come Git organizza e memorizza i commit., Dietro le quinte, nella directory ./.git/objects del repository, Git memorizza tutti i commit, locali e remoti. Git mantiene i commit di branch remoti e locali distintamente separati attraverso l’uso di referenze di branch. I riferimenti per le filiali locali sono memorizzati nel ./.git/refs/heads/. L’esecuzione del comandogit branch produrrà un elenco dei riferimenti del ramo locale. Di seguito è riportato un esempio di git branch output con alcuni nomi di rami demo.,

git branch
master
feature1
debug2

L’esame del contenuto della directory /.git/refs/heads/ rivelerebbe un output simile.

ls ./.git/refs/heads/
master
feature1
debug2

I rami remoti sono proprio come i rami locali, tranne che mappano i commit dal repository di qualcun altro. I rami remoti sono preceduti dal telecomando a cui appartengono in modo da non confonderli con i rami locali. Come i rami locali, Git ha anche riferimenti per i rami remoti. I refs del ramo remoto vivono nella directory./.git/refs/remotes/., Il prossimo frammento di codice di esempio mostra i rami che potresti vedere dopo aver recuperato un repository remoto chiamato convenientemente remote-repo:

git branch -r
# origin/master
# origin/feature1
# origin/debug2
# remote-repo/master
# remote-repo/other-feature

Questo output visualizza i rami locali che avevamo precedentemente esaminato ma ora li visualizza con prefisso origin/. Inoltre, ora vediamo i rami remoti preceduti da remote-repo. Puoi controllare un ramo remoto proprio come uno locale, ma questo ti mette in uno stato indipendente HEAD (proprio come controllare un vecchio commit). Puoi considerarli come rami di sola lettura., Per visualizzare i rami remoti, è sufficiente passare il flag-r al comandogit branch.

È possibile ispezionare i rami remoti con i soliti comandi git checkout e git log. Se si approvano le modifiche contenute in un ramo remoto, è possibile unirlo in un ramo locale con un normale git merge. Quindi, a differenza di SVN, la sincronizzazione del repository locale con un repository remoto è in realtà un processo in due fasi: fetch, quindi merge. Il comandogit pull è una comoda scorciatoia per questo processo.,

Git recupera comandi e opzioni

git fetch <remote>

Recupera tutti i rami dal repository. Questo scarica anche tutti i commit e i file richiesti dall’altro repository.

git fetch <remote> <branch>

Come il comando precedente, ma recupera solo il ramo specificato.

git fetch --all

Una mossa di potenza che recupera tutti i telecomandi registrati e le loro filiali:

git fetch --dry-run

L’opzione --dry-run eseguirà un’esecuzione demo del comando., Produrrà esempi di azioni che intraprenderà durante il recupero ma non le applicherà.

git fetch a remote branch

Il seguente esempio mostrerà come recuperare un ramo remoto e aggiornare lo stato di lavoro locale ai contenuti remoti. In questo esempio, supponiamo che esista un’origine repo centrale da cui il repository locale è stato clonato utilizzando il comando git clone. Supponiamo anche un repository remoto aggiuntivo chiamato coworkers_repo che contiene un feature_branch che configureremo e recupereremo., Con queste ipotesi set continuiamo l’esempio.

In primo luogo dovremo configurare il repository remoto usando il comandogit remote.

git remote add coworkers_repo [email protected]:coworker/coworkers_repo.git

Qui abbiamo creato un riferimento al repository del collega utilizzando l’URL del repository. Passeremo ora quel nome remoto a git fetch per scaricare il contenuto.

git fetch coworkers_repo coworkers/feature_branch
fetching coworkers/feature_branch

Ora abbiamo localmente il contenuto di coworkers / feature_branch avremo bisogno di integrare questo nella nostra copia di lavoro locale., Iniziamo questo processo usando il comandogit checkout per controllare il ramo remoto appena scaricato.

git checkout coworkers/feature_branch
Note: checking out coworkers/feature_branch'.
You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.
If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:
git checkout -b <new-branch-name>

L’output di questa operazione di checkout indica che siamo in uno stato indipendenteHEAD. Questo è previsto e significa che il nostroHEAD ref sta puntando a un ref che non è in sequenza con la nostra storia locale. Essendo cheHEAD è puntato sul ref coworkers/feature_branch, possiamo creare un nuovo ramo locale da quel ref., L’output’ detached HEAD ‘ ci mostra come farlo usando il comando git checkout:

git checkout -b local_feature_branch

Qui abbiamo creato un nuovo ramo locale chiamato local_feature_branch. Questo mette gli aggiornamenti HEAD per puntare all’ultimo contenuto remoto e possiamo continuare lo sviluppo su di esso da questo punto.

Sincronizza origine con git fetch

L’esempio seguente illustra il tipico flusso di lavoro per sincronizzare il repository locale con il ramo master del repository centrale.,

git fetch origin

Questo mostrerà i rami che sono stati scaricati:

I commit da questi nuovi rami remoti sono mostrati come quadrati invece di cerchi nel diagramma sottostante. Come puoi vedere, git fetch ti dà accesso all’intera struttura del ramo di un altro repository.,

Per vedere cosa si impegna sono stati aggiunti a monte master, è possibile eseguire un git log utilizzando origin/master come un filtro:

git log --oneline master..origin/master

Per approvare le modifiche e unirli in tuo master branch utilizzare i seguenti comandi:

git checkout master
git log origin/master

Quindi possiamo usare git merge origin/master:

git merge origin/master

L’origine/master e master rami ora lo stesso commit, e si sono sincronizzati con il monte sviluppi.,

Git fetch summary

In revisione,git fetch è un comando primario utilizzato per scaricare contenuti da un repository remoto. git fetch in collaborazione con git remote git branch git checkout e git reset per aggiornare un repository locale per lo stato di un telecomando. Il comandogit fetch è un elemento critico dei flussi di lavoro git collaborativi., git fetch has similar behavior to git pull, however, git fetch can be considered a safer, nondestructive version.