Introduzione

Git è un sistema di controllo versione distribuito: ogni clone è un repository completo con la propria cronologia, non solo una copia di lavoro estratta da un server centrale. Per questo motivo, la collaborazione in Git riguarda essenzialmente la sincronizzazione, ovvero la condivisione di intere branch tra repository anziché lo scambio di singoli changeset.

Questa pagina introduce i quattro comandi che spostano i commit tra il repository locale e quelli remoti: git remote, git fetch, git push e git pull. Ogni comando è trattato in dettaglio nella propria pagina, ma capire come si integrano tra loro è ciò che rende la collaborazione quotidiana prevedibile.

Il modello mentale: locale vs. remoto

Prima di esaminare i singoli comandi, è utile avere un'immagine chiara in mente. Quando si sincronizza, entrano in gioco tre elementi:

• Il repository locale — le branch su cui esegui i commit, ad esempio main.
• Un remote — un segnalibro con un nome (come origin) che punta all'URL di un altro repository.
• Branch di tracciamento remoto — copie locali in sola lettura delle branch del remote, denominate come origin/main. Registrano dove si trovava il remote l'ultima volta che hai comunicato con esso.

La direzione del flusso di dati indica quale comando utilizzare:

• git fetch e git pull scaricano i commit dal remote.
• git push invia i commit verso il remote.
• git remote gestisce le connessioni stesse.

git remote

Il comando git remote è progettato per creare, visualizzare e rimuovere connessioni ad altri repository. Per impostazione predefinita, elenca tutte le connessioni remote precedentemente memorizzate.

Quando cloni un repository, Git crea automaticamente un remote chiamato origin che punta all'URL sorgente, quindi raramente è necessario aggiungerne uno manualmente per i propri progetti. Si aggiungono remote aggiuntivi quando si collabora tramite fork, ad esempio puntando upstream al progetto originale da cui si è fatto il fork.

# List configured remotes
git remote
# origin

# Show their fetch/push URLs
git remote -v
# origin  https://github.com/user/repo.git (fetch)
# origin  https://github.com/user/repo.git (push)

# Add a second remote
git remote add upstream https://github.com/original/repo.git

git fetch

Il comando git fetch scarica commit, file e riferimenti da un repository remoto nel repository locale, aggiornando le branch di tracciamento remoto (come origin/main). Consente di vedere su cosa stanno lavorando gli altri membri del team senza modificare la propria branch di lavoro.

Sia git fetch che git pull scaricano contenuto dal remote, ma git fetch è l'opzione sicura e non distruttiva: avanza solo le branch di tracciamento remoto e non modifica mai i file di lavoro. Nulla viene unito finché non lo si richiede esplicitamente.

# Download new commits from origin (does not change your working branch)
git fetch origin

# Review what arrived before integrating it
git log main..origin/main

# Integrate it yourself when ready
git merge origin/main

Questo schema "fetch, poi revisione, poi merge" è il motivo per cui molti team preferiscono git fetch a git pull: è possibile esaminare le modifiche in arrivo prima che vengano applicate alla branch che si sta modificando.

git push

Il comando git push carica il contenuto del repository locale su un repository remoto. Mentre git fetch importa i commit nelle branch di tracciamento remoto locali, git push esporta i commit locali verso le branch corrispondenti sul remote, rendendoli visibili al resto del team.

# Push the current branch's commits to origin
git push origin main

# First push of a new branch: set up tracking with -u
git push -u origin feature-login

Il push ha successo solo quando può avanzare la branch remota senza perdere commit (un fast-forward). Se qualcun altro ha eseguito un push nel frattempo, Git rifiuta il push e chiede di integrare prima il lavoro altrui, di solito eseguendo git pull o git fetch e il merge. Evita --force sulle branch condivise: può sovrascrivere i commit dei colleghi.

git pull

Il comando git pull è essenzialmente git fetch seguito da un passaggio di integrazione, tutto in un unico comando. Scarica i nuovi contenuti dal remote e li integra immediatamente nella branch corrente.

Per impostazione predefinita git pull combina git fetch con git merge, creando un merge commit quando le cronologie divergono. È possibile configurarlo per usare git rebase (git pull --rebase), che riproduce i commit locali sopra quelli scaricati per ottenere una cronologia lineare.

# Fetch from origin and merge into the current branch
git pull origin main

# Fetch and rebase your local commits on top instead
git pull --rebase origin main

Quando usare quale comando

Una guida rapida alle decisioni per il lavoro quotidiano:

• Stai iniziando a lavorare per la giornata? Esegui git pull (oppure git fetch + revisione + merge) per ottenere le ultime modifiche.
• Vuoi vedere cosa è cambiato senza disturbare il tuo lavoro? Usa git fetch, poi git log o git diff rispetto a origin/<branch>.
• Hai completato una parte del lavoro? Esegui git push per condividerla.
• Il push è stato rifiutato? Il remote ha commit che non hai ancora. Esegui pull (oppure fetch e merge/rebase), risolvi eventuali conflitti, poi esegui di nuovo il push.

Da qui, segui le pagine dedicate a ciascun comando e consulta il capitolo Git workflows per scoprire come i team combinano questi comandi in un processo ripetibile.

Esercitazione