Git Fetch | Tutorial Git Online W3Docs

Il comando git fetch scarica commit, file e riferimenti da un repository remoto nel repository locale, senza modificare nessuna parte del tuo lavoro. È il modo sicuro per vedere cosa stanno facendo i tuoi colleghi: nulla nella tua directory di lavoro o nei tuoi branch locali viene modificato finché non decidi di eseguire il merge.

Questa pagina illustra cosa fa git fetch, come aggiorna i branch di tracciamento remoto, le opzioni più utili, come recuperare un branch specifico o un intero remoto, e in cosa git fetch differisce da git pull.

Definizione

Il comando git fetch viene utilizzato per scaricare commit, oggetti e riferimenti da un repository remoto nel repository locale. Serve per vedere su cosa stanno lavorando gli altri membri del team. A differenza di git pull, non unisce mai automaticamente il lavoro scaricato nel branch corrente.

Come funziona con i branch remoti

Git memorizza i commit locali e remoti separandoli tramite i riferimenti di branch. I riferimenti per i branch locali sono memorizzati in /.git/refs/heads/. Per visualizzare l'elenco dei riferimenti dei branch locali, esegui il comando git branch.

git branch

git branch
* master
  crossword
  solver

Esplorando il contenuto della directory /.git/refs/heads/ si ottiene il seguente output:

ls ./.git/refs/heads/

ls ./.git/refs/heads/
master
crossword
solver

I riferimenti ai branch remoti sono memorizzati nella directory ./.git/refs/remotes/. Per visualizzare i branch remoti, usa il flag -r con git branch. Ecco l'output dopo aver recuperato un repository remoto:

git branch -r

git branch -r
  origin/master
  origin/crossword
  origin/solver
  remote-repo/master
  remote-repo/other-feature

L'output mostra i branch remoti con il prefisso origin/. Questi sono branch di tracciamento remoto — copie locali in sola lettura che registrano la posizione di ogni branch sul remoto al momento dell'ultimo fetch. Puoi esaminarli con i comandi git checkout e git log. Dopo aver revisionato le modifiche, puoi unire un branch di tracciamento remoto nel tuo branch locale con git merge. Usa git pull per combinare fetch e merge in un singolo passaggio.

Opzioni comuni

Opzione	Cosa fa
`--all`	Recupera tutti i remoti configurati, non solo uno.
`-k`, `--keep`	Mantiene il file pack scaricato invece di decomprimerlo.
`-p`, `--prune`	Rimuove i riferimenti di tracciamento remoto che non esistono più sul remoto.
`--depth=<depth>`	Limita il numero di commit recuperati dalla cima di ogni branch (fetch superficiale).
`--dry-run`	Mostra cosa verrebbe recuperato senza scaricare effettivamente nulla.

Per rimuovere i riferimenti di tracciamento per i branch che non esistono più sul remoto, usa --prune:

git fetch --prune

Per recuperare da tutti i remoti configurati contemporaneamente, usa --all:

git fetch --all

Come eseguire git fetch di un branch remoto

Qui mostreremo i passaggi per recuperare un branch remoto e aggiornare lo stato di lavoro locale al contenuto remoto. Nell'esempio seguente, abbiamo un repository centrale origin da cui il repository locale è stato clonato con il comando git clone. Esiste un altro repository remoto chiamato test_repo contenente feature_branch che deve essere configurato e recuperato.

Il primo passo è configurare il repository remoto con git remote:

git remote

git remote add test_repo git@hostname:test/test_repo.git

Usando l'URL del repository del collega, abbiamo creato un riferimento ad esso. Per scaricare il contenuto, esegui git fetch del test feature_branch:

git fetch

git fetch test_repo feature_branch
From hostname:test/test_repo
* [new branch]      feature_branch -> test_repo/feature_branch

Questo scarica il contenuto di test_repo/feature_branch nel repository locale come branch di tracciamento remoto — non lo unisce al branch corrente. Ora usa il comando git checkout per ispezionare il branch remoto scaricato:

git checkout test_repo/feature_branch

git checkout test_repo/feature_branch
Note: checking out 'test_repo/feature_branch'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can drop all the commits you make in this
state without influencing branches by executing another checkout.

If you want to generate a new branch for maintaining commits you create, you may
do so (now or later) if you use -b with the checkout command again. Example:

git checkout -b &lt;new-branch-name&gt;

L'output mostra che ci troviamo nello stato di HEAD staccata, il che significa che il riferimento HEAD punta direttamente a un commit invece che a un branch.

Con il comando git checkout è possibile creare un nuovo branch locale a partire dal riferimento test/feature_branch:

git checkout -b local_feature_branch test_repo/feature_branch

git checkout -b local_feature_branch test_repo/feature_branch

Il nuovo branch locale viene creato aggiornando HEAD in modo che punti all'ultimo contenuto remoto.

Sincronizzare origin con git fetch

L'esempio seguente mostra come sincronizzare il repository locale con il branch master del repository centrale:

git fetch origin

git fetch origin

L'output mostrerà i branch che sono stati scaricati:

git fetch origin output

b341bc3..32a45b1  master     -> origin/master
b341bc3..7a52a22  develop    -> origin/develop
* [new branch]      some-feature -> origin/some-feature

Esegui git log usando origin/master come filtro per visualizzare i commit aggiunti al master upstream:

git log --oneline master..origin/master

git log --oneline master..origin/master

Controlla le modifiche e uniscile nel branch master locale:

git checkout master && git log origin/master

git checkout master
git log origin/master

Esegui git merge origin/master per sincronizzarsi con gli sviluppi upstream:

git merge

git merge origin/master

Uno scenario di collaborazione comune

Ecco uno scenario per aiutarti a comprendere meglio questo concetto.

Supponiamo che ci sia un piccolo team di sviluppo composto da due sviluppatori, Alice e Bob. Stanno lavorando a un progetto ospitato su un repository Git remoto chiamato origin. Alice clona il repository sulla sua macchina locale e inizia a lavorare sul branch main, mentre Bob lavora su un branch separato chiamato feature-branch.

1- Alice crea un nuovo file chiamato README.md e vi apporta alcune modifiche. Poi esegue il commit e il push delle sue modifiche sul branch main del repository origin:

$ git add README.md
$ git commit -m "Add README file"
$ git push origin main

2- Nel frattempo, Bob ha apportato alcune modifiche a feature-branch e le ha inviate al repository origin:

$ git add some_file.txt
$ git commit -m "Add new feature"
$ git push origin feature-branch

3- Alice si rende conto di dover incorporare le modifiche di Bob nel proprio lavoro, quindi recupera le modifiche dal repository origin:

$ git fetch origin

4- Dopo il fetch, Alice può vedere che ci sono nuove modifiche in feature-branch:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

5- Alice può ora unire le modifiche di Bob nel suo branch main:

$ git merge origin/feature-branch

6- Alice risolve eventuali conflitti di merge e poi invia le sue modifiche al repository origin:

$ git push origin main

7- Bob può ora recuperare le modifiche apportate da Alice:

$ git fetch origin

8- Bob può ora vedere che ci sono nuove modifiche nel branch main:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

9- Bob può unire le modifiche apportate da Alice nel suo feature-branch:

$ git merge origin/main

10- Bob risolve eventuali conflitti di merge e poi invia le sue modifiche al repository origin:

$ git push origin feature-branch

E così il ciclo continua, con Alice e Bob che usano git fetch per tracciare le modifiche dell'uno e dell'altro e inviare le proprie modifiche al repository origin. Grazie all'uso di git fetch, riescono a mantenere il proprio repository locale aggiornato con le modifiche apportate dai colleghi, il che aiuta a evitare conflitti e garantisce un processo di collaborazione fluido.

Git fetch vs git pull

Sia git fetch che git pull vengono utilizzati per scaricare contenuti dal repository remoto. Il comando git fetch non unisce automaticamente le modifiche nei branch locali; aggiorna semplicemente i branch di tracciamento remoto. Il contenuto recuperato non influisce sulla directory di lavoro locale, consentendo di revisionare i commit in modo sicuro prima di unirli. Il comando git pull scarica il nuovo contenuto e lo unisce automaticamente nel branch corrente. Questo può causare conflitti di merge, quindi si raccomanda di eseguire git pull solo quando la copia di lavoro è pulita.

In breve, git pull è più o meno equivalente a git fetch seguito da git merge:

git pull origin main
# is similar to:
git fetch origin
git merge origin/main

Quando usare git fetch

Usa git fetch quando vuoi:

Vedere cosa è cambiato prima di integrarlo. Esegui prima il fetch, poi ispeziona con git log origin/main.. o git diff main origin/main, e unisci solo quando sei pronto.
Aggiornare i branch di tracciamento remoto senza toccare il tuo lavoro. Utile nel mezzo di un'attività quando la directory di lavoro contiene modifiche non committate che un git pull potrebbe disturbare.
Eliminare i branch obsoleti. git fetch --prune rimuove i riferimenti di tracciamento remoto per i branch eliminati sul remoto.
Revisionare il branch di un collega. Recuperalo, effettua il checkout per leggere il codice e decidi se eseguire il merge.

Esercitazione

Pratica

Quali affermazioni sul comando git fetch sono corrette?

git fetch scarica commit, file e riferimenti da un repository remoto nel repository locale.Dopo aver usato git fetch, i branch locali vengono aggiornati automaticamente per corrispondere al repository remoto.git fetch supporta opzioni come --all, --dry-run, --keep, --prune e --depth.L'uso di git fetch mette in uno stato di 'HEAD staccata' in cui è possibile sperimentare senza influenzare i branch locali.git fetch seguito da git merge è un modo sicuro per revisionare e integrare le modifiche da un repository remoto.git fetch forza l'unione delle modifiche remote nel branch corrente.