Git Fetch:definizione ed esempi

Introduzione

Il git fetch comando scarica gli oggetti sulla macchina locale senza sovrascrivere il codice locale esistente nel ramo corrente. Il comando estrae un record delle modifiche al repository remoto, consentendo di ottenere informazioni dettagliate sulla cronologia di avanzamento prima delle modifiche.

Continua a leggere per scoprire come utilizzare il git fetch comando attraverso esempi pratici.

Prerequisiti

• Git installato, aggiornato e configurato.
• Accesso alla riga di comando/terminale.
• Un collegamento a un repository remoto o un telecomando Git configurato.

Cos'è git fetch?

Il git fetch comando recupera commit, file, rami e tag da un repository remoto. La sintassi generale per il comando è:

git fetch <options> <remote name> <branch name>

Git isola il contenuto recuperato dal codice locale. Pertanto, il recupero fornisce un modo sicuro per rivedere le informazioni prima di impegnarsi nella filiale locale.

Come funziona il comando git fetch?

Il git fetch comando ottiene tutte le modifiche da un repository remoto. I metadati recuperati risiedono in .git directory, mentre la directory di lavoro rimane inalterata.

In effetti, git fetch recupera i metadati senza applicare le modifiche in locale. Il comando git pull combina git fetch e git merge in una.

Poiché lo stato della directory di lavoro rimane inalterato, i contenuti recuperati devono essere estratti con il comando git checkout o uniti con git merge.

Tuttavia, poiché l'unione dei contenuti è un processo manuale, git fetch consente di rivedere il codice prima di modificare qualsiasi cosa. Il processo di revisione aiuta a evitare conflitti di unione.

Opzioni di recupero di Git

Di seguito è riportato l'elenco con le opzioni comunemente utilizzate quando si lavora con git fetch :

• --all - Recupera tutti i telecomandi.
• --append (-a ) - Aggiunge ai contenuti recuperati esistenti senza sovrascrivere.
• --depth=<depth> - Limita a un numero specifico di commit a partire dalla punta della cronologia di ogni filiale remota.
• --deepen=<depth> - Limita a un numero specifico di commit a partire dal limite corrente della cronologia di ogni ramo remoto fino alla punta.
• --shallow-since=<date> - Includi tutti i commit raggiungibili dopo la data specificata.
• --shallow-exclude=<revision> - Esclude i commit da un ramo o tag remoto specificato. Utilizza l'opzione più volte per specificare più esclusioni.
• --dry-run - L'opzione aggiunta a qualsiasi comando mostra cosa succede senza eseguire il comando come demo.
• --multiple - Consente più <repository or group> argomenti.
• --no-tags - Disabilita l'inseguimento automatico dei tag.
• --tags - Recupera tutti i tag da un telecomando.
• --set-upstream - Aggiungi il monitoraggio a monte.

Per vedere tutte le opzioni disponibili, esegui il seguente comando nel terminale:

git fetch --help

Il comando mostra la pagina di aiuto completa con una descrizione dettagliata di tutte le opzioni disponibili.

Recupera i repository Git

Gli esempi richiedono un repository remoto aggiunto. Se hai già una configurazione remota, vai alla sezione successiva. Altrimenti, aggiungi un telecomando Git seguendo i passaggi seguenti:

1. Aprire il terminale e creare una directory per il progetto:

mkdir <directory name>

2. Immettere la directory utilizzando il cd comando:

cd <directory name>

3. Inizializza il repository locale con:

git init

4. Utilizzare il comando seguente per aggiungere un URL remoto al repository locale:

git remote add <short remote name> <remote URL>

Ad esempio:

git remote add origin [email protected]:phoenixNAP-KB/test.git

5. Conferma che il telecomando è stato aggiunto correttamente:

git remote -v

Segui gli esempi nelle sezioni seguenti per vedere come git fetch il comando funziona per vari casi d'uso.

Recupera un repository remoto

Il modo più semplice per utilizzare il git fetch il comando è recuperare un repository remoto:

git fetch <remote name>

Ad esempio:

git fetch origin

L'output mostra il comando che ha recuperato tutti i contenuti dal repository remoto, inclusi rami e tag.

Elenca tutti i rami remoti recuperati con:

git branch -r

Per elencare tutti i tag recuperati, esegui:

git tag

Usa il comando git checkout per rendere i contenuti disponibili localmente in un nuovo ramo o usa git merge per sincronizzare le informazioni del repository locale.

Recupera un ramo specifico

Per recuperare un ramo specifico da un repository, esegui questo comando:

git fetch <remote name> <branch name>

Ad esempio, per recuperare un ramo chiamato test dall'origine , esegui:

git fetch origin test

Il comando recupera solo il contenuto per il ramo specifico. Per controllare il contenuto recuperato in un nuovo ramo, esegui:

git checkout -b test_branch origin/test

I contenuti sono ora disponibili localmente nel ramo test_branch .

Recupera tutti i rami da tutti i telecomandi

Nei casi in cui sono presenti più telecomandi, git fetch offre un comando per recuperare informazioni da tutti i telecomandi.

Per vedere tutti i telecomandi, esegui:

git remote

Recupera tutti i contenuti da tutti i telecomandi con:

git fetch --all

L'output mostra il processo di recupero da tutti i repository remoti.

Sincronizza il repository locale

Usa il git fetch comando con git merge per sincronizzare il repository locale. Segui i passaggi seguenti per vedere come funziona l'esempio:

1. Recupera il repository remoto con:

git fetch <remote name>

2. Confronta il ramo locale con quello remoto elencando le differenze di commit:

git log --oneline <local branch>..<remote name>/<remote branch name>

Ad esempio, se la filiale locale è branch_test e il telecomando è su origine/test , il comando seguente elenca le differenze:

git log --oneline test_branch..origin/test

L'output elenca i commit e i messaggi associati.

3. Controlla la filiale locale in cui desideri unire le modifiche:

git checkout <local branch>

Ad esempio:

git checkout test_branch

4. Sincronizza il ramo locale con il comando git merge:

git merge origin/main

I contenuti sono ora aggiornati con il repository remoto. Se è presente un avviso di conflitto, segui il nostro tutorial per risolvere i problemi di unione:Come risolvere i conflitti di unione in Git.

git fetch vs. git pull

La tabella seguente illustra come il git fetch e i comandi git pull confrontano.

git fetch	git pull
Scarica nuove informazioni da un repository remoto senza fondersi nel ramo corrente.	Scarica tutte le modifiche da un repository remoto e le unisce nel ramo corrente.
Aggiorna i dati del repository in .git directory.	Aggiorna direttamente il repository locale.
Consente di rivedere i commit e le modifiche di altri sviluppatori prima di eseguire il commit del codice.	Consente di portare e aggiornare immediatamente le modifiche al repository locale.
Nessuna possibilità di conflitti di unione durante l'esecuzione del comando.	Possibili conflitti di unione che richiedono una risoluzione immediata.

Dei due comandi, git fetch è l'opzione più sicura quando si recuperano le modifiche al codice da un repository remoto.