Sezione · Informatica
Git
Guida pratica a Git: che cos'è, come installarlo su Windows e
Linux e i comandi che servono davvero, con esempi pronti da copiare.
Contenuti verificati sulla versione 2.56.0.
2.56.0 e Git for
Windows 2.56.0.windows.4 (ottobre 2026). Git è
distribuito con licenza GPLv2.
Che cos'è Git
Git è un sistema di controllo di versione distribuito (DVCS): registra la storia di un progetto, permette di tornare indietro, lavorare su più rami e collaborare senza dipendere da un server centrale. È stato creato da Linus Torvalds nel 2005 per gestire il kernel Linux ed è oggi lo standard di fatto per il codice sorgente.
In un DVCS ogni copia del repository contiene tutta la storia: puoi fare commit, consultare il log e creare branch anche offline. Il server remoto serve per condividere e sincronizzare, non per lavorare.
Git non è GitHub
Git è lo strumento che installi sul computer. GitHub, GitLab, Bitbucket e Codeberg sono servizi di hosting che ospitano repository Git e aggiungono funzioni come pull request, issue e CI. Puoi usare Git benissimo senza alcun servizio esterno.
I concetti chiave
| Termine | Significato |
|---|---|
| Repository | Il progetto con tutta la sua storia. La cartella .git contiene i dati; i file che vedi sono il working tree. |
| Working tree | I file su cui stai lavorando, nella cartella del progetto. |
| Staging area | L'area di preparazione (index): ciò che hai scelto di includere nel prossimo commit con git add. |
| Commit | Un'istantanea immutabile dello stato del progetto, con autore, data, messaggio e un identificatore SHA. |
| Branch | Un puntatore mobile a un commit. Il branch predefinito oggi si chiama di solito main. |
| HEAD | Indica il commit o il branch su cui sei posizionato in questo momento. |
| Remote | Un repository remoto collegato, di solito chiamato origin. |
| Upstream | Il branch remoto che il tuo branch locale segue (per esempio origin/main). |
| Tag | Un'etichetta fissa su un commit, usata soprattutto per le versioni (v2.56.0). |
I tre stati di un file
Git vede i file in tre passaggi:
- Modificato — il file è cambiato nel working tree ma non è ancora in staging.
- In staging — la modifica è stata aggiunta con
git adde farà parte del prossimo commit. - Registrato — la modifica è stata salvata nella storia con
git commit.
Il flusso di lavoro tipico
git clone https://example.com/progetto.git
cd progetto
# modifica i file...
git status
git add file.txt
git commit -m "Descrizione della modifica"
git push
Da quel momento il ciclo è sempre lo stesso: modifichi,
controlli con git status e git diff,
prepari con git add, registri con
git commit e condividi con git push.
Primi passi
Dopo l'installazione, configura la tua identità una volta sola:
git config --global user.name "Nome Cognome"
git config --global user.email "nome@example.com"
git config --global init.defaultBranch main
Poi scegli se creare un repository o clonarne uno esistente:
# nuovo repository nella cartella corrente
git init
# copia locale di un repository esistente
git clone https://example.com/progetto.git
Versioni e compatibilità
Questa guida è verificata sulla versione 2.56.0.
I comandi di uso quotidiano sono stabili; git switch e
git restore esistono dalla 2.23, quindi su
distribuzioni molto vecchie puoi trovare solo git checkout.
Fonti
Installazione su Windows
Il pacchetto di riferimento è Git for Windows:
include Git, Git Bash, una GUI e Git Credential Manager. La versione
documentata è 2.56.0(4).
Requisiti
- Windows 10 o 11 (x64); esiste anche la build ARM64.
- PowerShell o Prompt dei comandi per usare
winget. - Permessi di amministratore per un'installazione valida per tutti gli utenti.
Metodo 1 — Installer ufficiale
- Apri git-scm.com/install/windows.
- Scarica Git for Windows/x64 Setup (oppure la versione ARM64).
- Avvia l'installer e segui la procedura guidata.
Scelte consigliate durante l'installazione:
- Editor predefinito: quello che usi davvero (VS Code, Notepad++, Vim).
- PATH: «Git from the command line and also from 3rd-party software», così
gitfunziona da PowerShell e da altri strumenti. - HTTPS transport: OpenSSL o la libreria di Windows; entrambe funzionano.
- Line endings: «Checkout Windows-style, commit Unix-style» (
core.autocrlf=true). - Terminale: MinTTY (Git Bash) è la scelta predefinita e va bene.
- Credential Manager: lascialo attivo, evita di digitare la password ogni volta.
# verifica
git --version
# git version 2.56.0.windows.4
Metodo 2 — winget
Da PowerShell:
winget install --id Git.Git -e --source winget
Per aggiornare:
winget upgrade --id Git.Git -e
Git.Git di winget non è mantenuto dal
progetto Git for Windows e può restare indietro rispetto
all'ultima versione. Dopo un aggiornamento di sicurezza controlla
sempre git --version.
Metodo 3 — Chocolatey
choco install git
choco upgrade git
Vale la stessa avvertenza di winget: il pacchetto è di terze parti.
Versione portable
Se non puoi installare nulla, scarica PortableGit
(archivio autoestraente), estrailo in una cartella e usa
git-bash.exe. Per avere git nel PATH,
aggiungi la sottocartella cmd alle variabili d'ambiente.
Configurazione iniziale
git config --global user.name "Nome Cognome"
git config --global user.email "nome@example.com"
git config --global init.defaultBranch main
git config --global core.autocrlf true
git config --global core.editor "code --wait"
git config --global credential.helper manager
git config --global --list
| Impostazione | Perché |
|---|---|
user.name, user.email | Firmano ogni commit; l'email è quella che vedranno gli altri. |
init.defaultBranch | Nome del branch iniziale: main è lo standard attuale. |
core.autocrlf | Converte i fine riga: CRLF in checkout, LF nel repository. |
core.editor | Editor usato per i messaggi di commit e il rebase interattivo. |
credential.helper | manager usa Git Credential Manager, incluso in Git for Windows. |
Per controllare da dove arriva un'impostazione:
git config --global --show-origin --list.
Git Bash, PowerShell o WSL
- Git Bash offre un terminale POSIX con i comandi Unix più comuni.
- PowerShell funziona bene per Git; attenzione alle virgolette e ai percorsi con spazi.
- WSL è un'installazione separata: Git dentro WSL ha la sua configurazione e i suoi file. Se usi entrambi, tieni aggiornati tutti e due.
Aggiornare e disinstallare
# aggiornamento da Git Bash
git update-git-for-windows
# alternativa con winget
winget upgrade --id Git.Git -e
# disinstallazione
winget uninstall --id Git.Git
Dopo l'aggiornamento chiudi e riapri i terminali aperti.
Problemi comuni
gitnon riconosciuto: il PATH non è aggiornato; riapri il terminale o reinstalla scegliendo l'opzione PATH corretta.- File che risultano tutti modificati: controlla
core.autocrlfe la configurazione dell'editor. - Credenziali richieste ogni volta: verifica
git config --global credential.helper.
Installazione su Linux
Su Linux Git si installa quasi sempre dal repository della distribuzione. La versione disponibile dipende dalla distro: se ti serve l'ultima, usa il PPA su Ubuntu o compila dai sorgenti.
Debian e Ubuntu
sudo apt update
sudo apt install git
Per l'ultima versione stabile su Ubuntu:
sudo add-apt-repository ppa:git-core/ppa
sudo apt update
sudo apt install git
Fedora
sudo dnf install git
Su Fedora 21 e precedenti il comando era yum install git.
Arch Linux
sudo pacman -S git
openSUSE
sudo zypper install git
Alpine Linux
sudo apk add git
Gentoo
sudo emerge --ask --verbose dev-vcs/git
Nix e NixOS
# profilo utente
nix profile install nixpkgs#git
# metodo classico
nix-env -i git
Su NixOS aggiungi pkgs.git a environment.systemPackages.
RHEL, CentOS, Rocky Linux e AlmaLinux
sudo dnf install git
Queste distribuzioni tendono a fornire versioni più vecchie. Se ti serve una versione recente, valuta un repository di terze parti oppure la compilazione dai sorgenti.
Compilare dai sorgenti
Serve per avere l'ultima versione su distribuzioni che non la forniscono. Le dipendenze cambiano da distro a distro; su Debian/Ubuntu:
sudo apt install build-essential libssl-dev libcurl4-openssl-dev \
libexpat1-dev gettext zlib1g-dev
wget https://www.kernel.org/pub/software/scm/git/git-2.56.0.tar.gz
tar -xzf git-2.56.0.tar.gz
cd git-2.56.0
make prefix=/usr/local all
sudo make prefix=/usr/local install
/usr/local, assicurati che sia nel
PATH prima di /usr/bin. Controlla con
which git.
Verifica
git --version
which git
Configurazione iniziale
git config --global user.name "Nome Cognome"
git config --global user.email "nome@example.com"
git config --global init.defaultBranch main
git config --global core.autocrlf input
git config --global core.editor "code --wait"
git config --global pull.rebase false
git config --global --list
Su Linux core.autocrlf input converte i CRLF in LF nel
repository senza modificarli nel working tree.
Per non digitare la password a ogni push, scegli un credential helper:
# salvataggio in chiaro in ~/.git-credentials (comodo, poco sicuro)
git config --global credential.helper store
# cache in memoria per un'ora
git config --global credential.helper "cache --timeout=3600"
# integrazione con il portachiavi di sistema (GNOME/KDE)
git config --global credential.helper libsecret
Per libsecret serve il pacchetto libsecret
e, su alcune distro, git-credential-libsecret.
Chiavi SSH
Se usi GitHub, GitLab o un server Git via SSH, crea una chiave e aggiungila al servizio:
ssh-keygen -t ed25519 -C "nome@example.com"
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
cat ~/.ssh/id_ed25519.pub
Copia il contenuto di id_ed25519.pub nelle impostazioni
SSH del servizio. Verifica con ssh -T git@github.com.
Aggiornare e disinstallare
# Debian/Ubuntu
sudo apt update && sudo apt upgrade git
# Fedora
sudo dnf upgrade git
# Arch
sudo pacman -Syu git
# disinstallazione (esempio Debian/Ubuntu)
sudo apt remove git
git --version: alcune
funzioni recenti potrebbero non esserci.
Digita per filtrare comandi, esempi e ricette.
Cheat sheet
I comandi che userai il 90% delle volte.
| Comando | Cosa fa |
|---|---|
git clone <url> | Copia in locale un repository esistente. |
git init | Crea un nuovo repository nella cartella corrente. |
git status | Mostra lo stato di file e staging. |
git add <file> | Aggiunge un file al prossimo commit. |
git add -p | Sceglie interattivamente quali modifiche includere. |
git commit -m "..." | Registra le modifiche in staging. |
git commit --amend | Corregge l'ultimo commit. |
git log --oneline --graph --all | Mostra la cronologia in modo compatto. |
git diff | Mostra le modifiche non ancora in staging. |
git diff --staged | Mostra le modifiche già in staging. |
git switch <branch> | Passa a un branch. |
git switch -c <branch> | Crea un branch e ci passa subito. |
git branch -a | Elenca i branch locali e remoti. |
git merge <branch> | Unisce un branch in quello corrente. |
git pull --ff-only | Aggiorna senza creare merge inattesi. |
git push | Pubblica i commit sul remoto. |
git push -u origin <branch> | Pubblica e imposta l'upstream. |
git fetch --all --prune | Scarica i riferimenti remoti senza fondere. |
git remote -v | Elenca i repository remoti. |
git restore <file> | Annulla le modifiche non salvate. |
git restore --staged <file> | Toglie un file dallo staging. |
git reset --soft HEAD~1 | Annulla l'ultimo commit mantenendo le modifiche. |
git revert <commit> | Annulla un commit con un nuovo commit. |
git stash | Mette da parte le modifiche in corso. |
git stash pop | Ripristina le modifiche messe da parte. |
git tag -a <tag> -m "..." | Crea un tag annotato. |
git show <commit> | Mostra dettagli e modifiche di un commit. |
git blame <file> | Mostra chi ha modificato ogni riga. |
git reflog | Recupera i movimenti di HEAD. |
git clean -n | Anteprima dei file non tracciati da eliminare. |
git help <comando> | Apre l'aiuto di un comando. |
reflog, --force-with-lease — sono
nel tab Esempi.
Configurazione
# identità (globale)
git config --global user.name "Nome Cognome"
git config --global user.email "nome@example.com"
# branch iniziale e fine riga
git config --global init.defaultBranch main
git config --global core.autocrlf true # Windows
git config --global core.autocrlf input # Linux/macOS
# editor e credenziali
git config --global core.editor "code --wait"
git config --global credential.helper manager
# leggere e modificare
git config --global --list
git config --global --show-origin --list
git config --global --edit
git config --global --unset user.email
# alias
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --decorate --all"
# solo per il repository corrente
git config --local user.email "nome@azienda.example"
Creare e clonare
git init
git init -b main
git clone https://example.com/progetto.git
git clone https://example.com/progetto.git cartella
git clone --depth 1 https://example.com/progetto.git
git clone --branch v2.56.0 https://example.com/progetto.git
git clone --recurse-submodules https://example.com/progetto.git
git clone --bare https://example.com/progetto.git
| Opzione | Effetto |
|---|---|
--depth 1 | Clona solo l'ultimo commit: più veloce, ma senza storia completa. |
--branch <nome> | Clona un branch o un tag specifico. |
--recurse-submodules | Inizializza anche i submodule. |
--bare | Crea un repository senza working tree, utile come remoto. |
Stato e differenze
git status
git status -sb
git diff
git diff --staged
git diff --stat
git diff --name-only
git diff main..feature
git diff <commit1> <commit2> -- file.txt
git diff --check
Salvare le modifiche
git add file.txt
git add .
git add -A
git add -p
git commit -m "Messaggio chiaro e breve"
git commit -am "Solo file già tracciati"
git commit --amend --no-edit
git commit --amend -m "Nuovo messaggio"
git commit --allow-empty -m "Commit vuoto"
git commit --no-verify
Corregge il timeout del login è meglio di
fix.
Ispezionare la cronologia
git log
git log --oneline --graph --decorate --all
git log -n 5
git log --author="Nome" --since="2 weeks ago"
git log -p -- file.txt
git log --follow -- file.txt
git show <commit>
git show <commit>:file.txt
git shortlog -sn
git blame file.txt
git grep "testo"
git grep -n "testo" -- "*.js"
git reflog
git describe --tags
git rev-parse HEAD
Branch
git branch
git branch -a
git branch -vv
git branch --show-current
git branch nuovo-branch
git switch nuovo-branch
git switch -c nuovo-branch
git switch -c nuovo-branch origin/nuovo-branch
git switch -
git branch -m nuovo-nome
git branch -d branch-merged
git branch -D branch-da-forzare
git branch --merged
git branch --no-merged
git push origin --delete vecchio-branch
Merge, rebase e conflitti
git merge feature
git merge --no-ff feature
git merge --squash feature
git merge --abort
git rebase main
git rebase -i HEAD~3
git rebase --continue
git rebase --skip
git rebase --abort
git cherry-pick <commit>
git cherry-pick --continue
git cherry-pick --abort
git revert <commit>
git revert --no-commit <commit>
Risolvere un conflitto
git statuselenca i file in conflitto.- Apri ogni file, scegli o combina le modifiche e rimuovi i marcatori
<<<<<<<,=======,>>>>>>>. git add fileper segnare il conflitto come risolto.- Per un merge:
git commit. Per un rebase:git rebase --continue.
merge.
Remote
git remote -v
git remote add origin https://example.com/progetto.git
git remote set-url origin git@example.com:utente/progetto.git
git remote rename origin upstream
git remote remove origin
git remote show origin
git remote prune origin
git fetch
git fetch --all --prune
git pull
git pull --rebase
git pull --ff-only
git push
git push -u origin main
git push origin feature
git push --tags
git push origin v2.56.0
git push --force-with-lease
git push origin --delete vecchio-branch
git push --force. Se devi riscrivere un branch
remoto, usa --force-with-lease: rifiuta il push se
qualcun altro ha aggiornato il branch nel frattempo.
Annullare e recuperare
# annulla le modifiche non salvate di un file
git restore file.txt
# annulla tutte le modifiche non salvate
git restore .
# togli un file dallo staging, senza perdere le modifiche
git restore --staged file.txt
# riporta un file alla versione di un commit precedente
git restore --source=HEAD~1 file.txt
# annulla l'ultimo commit mantenendo le modifiche in staging
git reset --soft HEAD~1
# annulla l'ultimo commit mantenendo le modifiche nel working tree
git reset HEAD~1
# annulla l'ultimo commit e butta via le modifiche (pericoloso)
git reset --hard HEAD~1
# riporta il branch alla versione remota (pericoloso)
git reset --hard origin/main
# annulla un commit già pubblicato con un nuovo commit
git revert <commit>
# anteprima dei file non tracciati che verrebbero eliminati
git clean -n
# elimina file e cartelle non tracciati
git clean -fd
# elimina anche i file ignorati
git clean -fdx
reset --hard e
clean -fdx cancellano modifiche non recuperabili con un
semplice undo. Controlla sempre con git status e
git clean -n prima di eseguirli.
Recuperare un commit «perso»
git reflog
git reset --hard HEAD@{1}
reflog tiene traccia dei movimenti di HEAD per circa 90
giorni: è la rete di sicurezza dopo un reset sbagliato.
Stash
git stash
git stash push -m "Lavoro in corso"
git stash push -u
git stash list
git stash show -p
git stash pop
git stash apply
git stash drop
git stash clear
git stash branch lavoro-in-corso
Tag
git tag
git tag -l "v2.*"
git tag v2.56.0
git tag -a v2.56.0 -m "Versione 2.56.0"
git show v2.56.0
git push origin v2.56.0
git push --tags
git tag -d v2.56.0
git push origin --delete v2.56.0
File, .gitignore e attributi
git rm file.txt
git rm --cached file.txt
git rm -r cartella/
git mv vecchio.txt nuovo.txt
git check-ignore -v file.log
git ls-files
git ls-files --others --exclude-standard
Esempio di .gitignore:
# file temporanei
*.log
*.tmp
# cartelle di build
build/
dist/
node_modules/
# eccezione: tieni questo file
!importante.log
# solo nella radice del repository
/config.local
# qualsiasi cartella cache, a ogni livello
**/cache/
Per un ignore globale valido per tutti i repository:
git config --global core.excludesfile ~/.gitignore_global
Submodule e worktree
git submodule add https://example.com/libreria.git libreria
git submodule update --init --recursive
git submodule status
git submodule foreach git pull origin main
git worktree add ../progetto-hotfix hotfix
git worktree list
git worktree remove ../progetto-hotfix
Manutenzione e diagnostica
git gc
git gc --aggressive --prune=now
git fsck
git prune
git count-objects -vH
git archive --format=zip --output=progetto.zip HEAD
git bundle create repo.bundle --all
git bundle verify repo.bundle
Aiuto
git help
git help -a
git help -g
git help commit
git commit --help
Workflow quotidiano
git switch main
git pull --ff-only
git switch -c feature/nuova-funzione
# lavora e salva a piccoli passi
git add -p
git commit -m "Aggiunge la nuova funzione"
git push -u origin feature/nuova-funzione
# dopo la review, integra su main
git switch main
git pull --ff-only
git merge --no-ff feature/nuova-funzione
git push
git branch -d feature/nuova-funzione
Se qualcosa va storto
| Situazione | Cosa fare |
|---|---|
| Push rifiutato | git pull --rebase, risolvi i conflitti, poi git push. |
| Commit sbagliato ma non pubblicato | git commit --amend oppure git reset --soft HEAD~1. |
| Commit sbagliato già pubblicato | git revert <commit>: non riscrive la storia. |
| Branch cancellato per errore | git reflog, trova il commit e ricrea il branch con git switch -c nome <commit>. |
| HEAD staccata (detached) | Crea un branch con git switch -c nuovo-branch oppure torna a git switch main. |
| File ignorato per sbaglio | git check-ignore -v file per capire quale regola lo esclude. |
Esempi: i comandi di tutti i giorni
La tabella prende i comandi della cheat sheet e li mette in una situazione concreta. Percorsi, branch e messaggi sono inventati: sostituisci i tuoi. La colonna Cosa succede descrive l’effetto o l’output tipico, non una trascrizione.
| Comando | Esempio | Cosa succede |
|---|---|---|
git clone |
git clone https://example.com/repo.git |
Crea la cartella repo con il progetto, la storia e il remoto origin già configurato. |
git status -sb |
git status -sb |
Mostra branch, upstream e file modificati in forma compatta: ## main...origin/main [ahead 1]. |
git add -p |
git add -p src/app.js |
Chiede pezzo per pezzo quali modifiche includere: y sì, n no, s separa, q esce. |
git commit -m |
git commit -m "Valida l'email" |
Registra ciò che è in staging; se non hai aggiunto nulla, Git rifiuta il commit. |
git diff --staged |
git diff --staged |
Mostra esattamente quello che finirà nel prossimo commit, non le modifiche rimaste fuori. |
git switch -c |
git switch -c feature/login |
Crea il branch dal commit corrente e ci passa: git status ora dice On branch feature/login. |
git merge --no-ff |
git merge --no-ff feature/login |
Crea un commit di merge anche quando il fast-forward sarebbe possibile, così il branch resta visibile nella storia. |
git pull --ff-only |
git pull --ff-only |
Aggiorna solo se può avanzare senza merge; se i branch sono divergenti si ferma e te lo dice. |
git push -u |
git push -u origin feature/login |
Pubblica il branch e imposta l’upstream: i successivi git push e git pull non richiedono argomenti. |
git log --oneline --graph |
git log --oneline --graph --all |
Disegna la cronologia con i rami; --all include anche quelli non ancora mergiati. |
git restore |
git restore src/app.js |
Riporta il file all’ultima versione committata: le modifiche non salvate vanno perse. |
git stash push |
git stash push -m "login a metà" |
Mette da parte le modifiche e pulisce il working tree; git stash list mostra cosa hai messo via. |
git revert |
git revert 4f2a1c9 |
Crea un nuovo commit che annulla quello indicato: la storia resta intatta, quindi va bene anche se è già pubblicato. |
git reflog |
git reflog -n 10 |
Elenca gli ultimi movimenti di HEAD, compresi i commit non più raggiungibili da un branch. |
git show |
git show --stat 4f2a1c9 |
Mostra autore, messaggio e file toccati dal commit, senza il diff completo. |
Ricette per i casi complicati
Ogni ricetta segue lo stesso schema: la situazione di partenza, i comandi nell’ordine in cui vanno eseguiti, il risultato atteso e la trappola da evitare. Gli hash e i nomi dei branch sono esempi.
Ripulire tre commit con rebase interattivo
Situazione. Hai tre commit locali con messaggi provvisori e vuoi pubblicarne uno solo, con un messaggio decente. Non li hai ancora pushati.
git log --oneline -4
# 9c1e0b2 ok
# 4f2a1c9 fix
# 1a7d3e5 wip
# 8b0c4d1 Aggiunge il form di login
git rebase -i HEAD~3
L’editor si apre con i tre commit: lascia pick sul
primo e cambia gli altri in squash.
pick 1a7d3e5 wip
squash 4f2a1c9 fix
squash 9c1e0b2 ok
Al salvataggio Git unisce i tre commit e apre un secondo editor per
il messaggio finale: scrivi una riga sola, per esempio
Aggiunge il form di login con validazione.
Cosa succede. git log --oneline -2
mostra un solo commit sopra 8b0c4d1; il working tree
è pulito e la storia è più leggibile.
Trappola. Il rebase cambia gli hash: se il branch era già pubblicato, chi lo ha scaricato dovrà riallinearsi. Non farlo su un branch condiviso e non usarlo per nascondere un commit che qualcuno ha già revisionato.
Risolvere un conflitto durante un merge
Situazione. git merge feature/login si
ferma con CONFLICT (content): Merge conflict in
src/app.js. Il merge è aperto, ma non concluso.
git status
# both modified: src/app.js
# apri il file e scegli cosa tenere:
# <<<<<<< HEAD
# la tua versione
# =======
# la versione di feature/login
# >>>>>>> feature/login
git add src/app.js
git commit
Cosa succede. Dopo git add,
git status dice All conflicts fixed but you are
still merging; git commit chiude il merge con un
commit che ha due genitori.
Trappola. git add . senza aver letto i
file: i marcatori di conflitto finiscono nel commit. Se ti perdi,
git merge --abort riporta tutto a prima del merge.
Risolvere un conflitto durante un rebase
Situazione. git rebase main si ferma
su src/app.js: il rebase è a metà e Git
aspetta una decisione per ogni commit.
git status
# rebase in progress; next command is 'git rebase --continue'
# risolvi il file, poi:
git add src/app.js
git rebase --continue
# se questo commit non serve più:
git rebase --skip
# se vuoi tornare a prima del rebase:
git rebase --abort
Cosa succede. --continue applica il
commit successivo, o chiude il rebase se era l’ultimo. Alla
fine i tuoi commit stanno sopra main, con hash nuovi.
Trappola. git commit al posto di
--continue crea un commit fuori dal rebase e lascia il
processo aperto. --skip butta via il commit: usalo solo
se il contenuto è davvero già presente altrove.
Recuperare un commit dopo un reset --hard
Situazione. Un
git reset --hard HEAD~1 ha buttato via un commit non
ancora pushato. Il branch non lo raggiunge più, ma il commit
esiste ancora.
git reflog
# 9c1e0b2 HEAD@{0}: reset: moving to HEAD~1
# 4f2a1c9 HEAD@{1}: commit: Aggiunge il form di login
# la via sicura: un branch sul commit recuperato
git switch -c recupero 4f2a1c9
# oppure riporta il branch dov'era
git reset --hard 4f2a1c9
Cosa succede. Il commit torna raggiungibile: il
nuovo branch recupero ci punta e il lavoro è
intatto. Da lì puoi controllare il contenuto e riportarlo
dove serve.
Trappola. Il reflog è locale e scade (90
giorni per HEAD, 30 per i commit non raggiungibili): su un altro
computer non c’è. E non fare un secondo
reset --hard prima di aver creato il branch di
recupero.
Push rifiutato: aggiorna e riprova
Situazione. git push risponde
! [rejected] ... (fetch first): sul remoto ci sono
commit che non hai.
git fetch origin
git log --oneline HEAD..origin/main
git pull --rebase
# risolvi eventuali conflitti, poi:
git push
Cosa succede. I tuoi commit vengono riapplicati
sopra quelli remoti e il push passa senza creare un commit di merge.
Se il branch è tuo e vuoi riscriverlo, dopo il fetch puoi
usare git push --force-with-lease: rifiuta se qualcuno
ha aggiornato il branch nel frattempo.
Trappola. git push --force cancella i
commit altrui. E git pull senza --rebase
crea un merge che magari non vuoi: decidi prima quale delle due
storie vuoi.
Cherry-pick: portare un fix su un altro branch
Situazione. Hai corretto un bug su main
con il commit 7d3e9a1 e ti serve anche sul branch di
manutenzione release/2.55.
git switch release/2.55
git cherry-pick 7d3e9a1
git log --oneline -2
# se il cherry-pick si ferma su un conflitto:
git status
git add file-risolto
git cherry-pick --continue
Cosa succede. Su release/2.55 compare
un nuovo commit con lo stesso contenuto e un hash diverso. Il
commit originale su main resta dov’è.
Trappola. Il cherry-pick duplica il cambiamento: se i due branch si fonderanno, Git può segnalare un conflitto su una modifica già identica. Per un fix che deve vivere su più branch, valuta un merge del branch di manutenzione o un fix separato.
Annullare un merge già pubblicato
Situazione. Hai mergiato feature/login
su main e pushato, ma la feature va ritirata. La storia
è condivisa: non si riscrive.
git log --oneline --merges -3
# 2b8e4f0 Merge branch 'feature/login'
git revert -m 1 2b8e4f0
git push
Cosa succede. Un nuovo commit annulla le modifiche
introdotte dal merge. -m 1 dice a Git di considerare
primo genitore main prima del merge: senza, Git non sa
quale lato tenere e si ferma.
Trappola. Se in futuro vorrai riproporre la feature, un semplice merge non riporterà le modifiche: Git considera già mergiati quei commit. Serve un revert del revert, oppure un nuovo commit sulla feature.