Cheat sheet

Comandi Git: cheat sheet con esempi per ogni giorno

Aggiornato: · Skillaria.Top

I comandi Git essenziali sono git init e git clone per creare il repository, git status, git add e git commit per salvare le modifiche, git branch, git switch e git merge per lavorare con i rami, git push, git fetch e git pull per sincronizzarsi con il server, e git restore, git reset e git revert per annullare le modifiche.

Ecco un cheat sheet pratico di Git: i comandi sono raggruppati per attività, ognuno con un esempio e una breve spiegazione. Conviene tenerlo aperto accanto al terminale: quasi tutto ciò che uno sviluppatore fa con Git in una giornata rientra in 20–30 comandi di queste tabelle.

Per leggere i comandi con consapevolezza, tenete a mente tre aree: la directory di lavoro (i file sul disco), l'indice o staging area (ciò che entrerà nel prossimo commit) e il repository (la cronologia dei commit nella cartella .git). La maggior parte dei comandi Git sposta le modifiche tra queste tre aree o tra il repository locale e quello remoto.

Configurazione di Git

Questi comandi si eseguono una sola volta dopo l'installazione. Il flag --global scrive le impostazioni in ~/.gitconfig e vale per tutti i repository dell'utente; senza di esso valgono solo per il repository corrente.

ComandoChe cosa fa
git config --global user.name "Ivan Petrov"Nome dell'autore dei commit
git config --global user.email "ivan@example.com"E-mail dell'autore dei commit
git config --global init.defaultBranch mainNome del ramo predefinito per i nuovi repository
git config --global core.editor "code --wait"Editor per i messaggi di commit (qui VS Code)
git config --global pull.rebase falseComportamento predefinito di git pull: fusione
git config --global core.autocrlf inputConversione CRLF in LF al commit (macOS/Linux; su Windows di solito true)
git config --list --show-originMostra tutte le impostazioni e il file da cui provengono
git config --global alias.st statusAlias: git st al posto di git status
git --versionVersione di Git installata
git help commitGuida completa di un comando (o git commit -h per quella breve)

Creare e clonare un repository

ComandoChe cosa fa
git initCrea un repository vuoto (la cartella .git) nella cartella corrente
git init my-projectCrea la cartella my-project con un repository al suo interno
git clone https://github.com/user/repo.gitCopia un repository remoto con tutta la cronologia
git clone git@github.com:user/repo.git appClona tramite SSH nella cartella app
git clone --depth 1 URLClone superficiale: solo l'ultimo commit, veloce e poco ingombrante
git clone -b develop URLClona e passa subito al ramo develop

Ciclo base: status, add, commit

È il cuore del lavoro quotidiano: vedere che cosa è cambiato, scegliere ciò che va nell'indice e registrarlo con un commit.

ComandoChe cosa fa
git statusStato: file modificati, nell'indice e non tracciati
git status -sFormato breve: M — modificato, A — aggiunto, ?? — non tracciato
git add file.txtAggiunge un file all'indice
git add .Aggiunge all'indice tutte le modifiche della cartella corrente e sottostanti, comprese le cancellazioni
git add -AAggiunge all'indice tutte le modifiche di tutto il repository
git add -pSceglie in modo interattivo i singoli frammenti (hunk) delle modifiche
git commit -m "Aggiungere il form di accesso"Crea un commit dall'indice con il messaggio indicato
git commit -am "Correggere un refuso"Mette nell'indice tutti i file tracciati modificati e fa il commit; i file nuovi non vengono inclusi
git commit --amendRiscrive l'ultimo commit: aggiunge ciò che era stato dimenticato nell'indice o corregge il messaggio
git commit --amend --no-editIntegra l'ultimo commit senza cambiare il messaggio
git rm file.txtElimina un file dal disco e dall'indice
git rm --cached secret.envSmette di tracciare il file, lasciandolo sul disco
git mv old.js new.jsRinomina o sposta un file

Uno scenario tipico:

git status
git add src/login.js src/login.css
git diff --staged          # verifica che cosa finirà nel commit
git commit -m "Aggiungere il form di accesso"

Non usate --amend sui commit già inviati a un ramo condiviso: crea un nuovo commit con un hash diverso, e i colleghi dovranno gestire la divergenza nella cronologia.

Consultare la cronologia e le modifiche

ComandoChe cosa fa
git logCronologia dei commit del ramo corrente
git log --onelineOgni commit su una riga: hash abbreviato e titolo
git log --oneline --graph --allGrafo di tutti i rami nel terminale
git log -p file.txtCronologia di un file con i diff di ogni commit
git log --author="Ivan" --since="2 weeks ago"Filtro per autore e data
git log -S "getUser"Commit in cui è stata aggiunta o rimossa la stringa getUser
git log main..featureCommit presenti in feature ma non in main
git diffModifiche nella directory di lavoro, non ancora aggiunte all'indice
git diff --stagedModifiche nell'indice rispetto all'ultimo commit (sinonimo di --cached)
git diff main featureDifferenza tra le punte di due rami
git diff HEAD~3 -- src/Modifiche nella cartella src negli ultimi tre commit
git show a1b2c3dMetadati e diff di un commit specifico
git show HEAD:README.mdContenuto di un file nell'ultimo commit
git blame app.jsChi e in quale commit ha modificato per ultimo ogni riga
git shortlog -snNumero di commit per autore

I riferimenti ai commit sono utili ovunque: HEAD è il commit corrente, HEAD~1 il suo genitore, HEAD~3 tre passi indietro lungo il primo genitore, HEAD^2 il secondo genitore di un merge commit.

Rami: creare, cambiare, eliminare

Dalla versione 2.23 Git ha git switch per i rami e git restore per i file: hanno separato il sovraccarico git checkout. Le forme vecchie continuano a funzionare.

ComandoChe cosa fa
git branchElenco dei rami locali; quello corrente è segnato con *
git branch -aRami locali e remoti (di tracciamento)
git branch -vvRami con l'ultimo commit e il ritardo/vantaggio rispetto all'upstream
git branch feature/loginCrea un ramo senza spostarsi
git switch feature/loginPassa al ramo
git switch -c feature/loginCrea un ramo e vi passa (equivale a git checkout -b)
git switch -Torna al ramo precedente
git branch -m new-nameRinomina il ramo corrente
git branch -d feature/loginElimina il ramo, se è già stato unito
git branch -D feature/loginElimina il ramo a forza, anche se non unito
git branch --mergedRami già uniti nel corrente — candidati all'eliminazione

Fusione e rebase

ComandoChe cosa fa
git merge featureUnisce feature nel ramo corrente (fast-forward, se possibile)
git merge --no-ff featureCrea sempre un merge commit
git merge --squash featureRaccoglie nell'indice tutte le modifiche del ramo in un unico blocco, poi git commit
git merge --abortAnnulla una fusione con conflitti e torna allo stato iniziale
git rebase mainSposta i commit del ramo corrente sopra main
git rebase -i HEAD~4Interattivo: unire (squash), rinominare, riordinare, eliminare gli ultimi 4 commit
git rebase --continueProsegue dopo la risoluzione di un conflitto
git rebase --abortAnnulla completamente il rebase
git cherry-pick a1b2c3dApplica un commit al ramo corrente come nuovo commit

Risolvere un conflitto di fusione è quasi sempre uguale:

git merge feature
# CONFLICT (content): Merge conflict in app.js
git status                 # i file compaiono nella sezione "both modified"
# modificate app.js ed eliminate i marcatori <<<<<<< ======= >>>>>>>
git add app.js
git commit                 # Git propone il messaggio pronto per il merge commit

Regola fondamentale del rebase: non rifate il rebase di commit già presenti in un ramo condiviso e su cui altri stanno costruendo il lavoro.

Lavorare con i repository remoti

ComandoChe cosa fa
git remote -vElenco dei remote e dei loro indirizzi
git remote add origin git@github.com:user/repo.gitCollega un repository remoto con il nome origin
git remote set-url origin NUOVO_URLCambia l'indirizzo del remote (per esempio da HTTPS a SSH)
git remote remove upstreamScollega un remote
git fetchScarica nuovi commit e rami senza toccare i vostri file
git fetch --pruneCome sopra, più l'eliminazione dei riferimenti a rami cancellati sul server
git pullgit fetch + fusione del ramo upstream nel corrente
git pull --rebasegit fetch + rebase dei vostri commit sopra quelli ricevuti
git pushInvia i commit del ramo corrente al suo upstream
git push -u origin feature/loginPrimo invio del ramo con impostazione dell'upstream
git push --force-with-leaseSovrascrive il ramo remoto solo se non ci sono nuovi commit altrui
git push origin --delete feature/loginElimina il ramo sul server
git push --tagsInvia tutti i tag locali

Invece di git push --force abituatevi a --force-with-lease: se un collega ha già inviato commit nello stesso ramo, il comando si rifiuta di sovrascrivere il suo lavoro.

Annullare le modifiche

È la parte più delicata di Git. La domanda chiave prima di scegliere il comando: le modifiche sono ancora solo nei file, già nell'indice, in un commit locale oppure in un commit pubblicato?

SituazioneComando
Annullare le modifiche a un file (tornare com'era nell'ultimo commit)git restore app.js
Togliere un file dall'indice, mantenendo le modifichegit restore --staged app.js
Recuperare un file da un commit specificogit restore --source=a1b2c3d app.js
Annullare l'ultimo commit, lasciando le modifiche nell'indicegit reset --soft HEAD~1
Annullare l'ultimo commit, lasciando le modifiche nei filegit reset HEAD~1 (modalità --mixed predefinita)
Eliminare l'ultimo commit con tutte le sue modifichegit reset --hard HEAD~1
Annullare un commit pubblicato con un nuovo commit «inverso»git revert a1b2c3d
Annullare un merge commitgit revert -m 1 <hash-del-merge>
Vedere quali file non tracciati verrebbero eliminatigit clean -n
Eliminare file e cartelle non tracciatigit clean -fd
Ritrovare un commit «perso» dopo un reset o un rebasegit reflog, poi git reset --hard HEAD@{2}

git reset --hard e git clean -f eliminano in modo irreversibile le modifiche non committate: il reflog conserva solo i commit, non le modifiche nella directory di lavoro. Prima di usarli fate uno git stash o almeno un git status.

Stash: mettere da parte il lavoro non finito

ComandoChe cosa fa
git stashMette da parte le modifiche dei file tracciati e ripulisce la directory di lavoro
git stash push -u -m "wip: form"Mette da parte anche i file non tracciati, con un'etichetta
git stash listElenco degli stash: stash@{0}, stash@{1}…
git stash show -p stash@{0}Mostra il diff di uno stash
git stash popRipristina l'ultimo stash e lo rimuove dall'elenco
git stash apply stash@{1}Ripristina uno stash lasciandolo nell'elenco
git stash drop stash@{1}Elimina uno stash
git stash branch fix-formCrea un ramo dal commit in cui è stato creato lo stash e vi applica le modifiche

Tag e release

ComandoChe cosa fa
git tagElenco dei tag
git tag -a v1.2.0 -m "Release 1.2.0"Tag annotato con autore, data e messaggio
git tag v1.2.0 a1b2c3dTag leggero su un commit specifico
git push origin v1.2.0Invia un singolo tag
git tag -d v1.2.0Elimina il tag in locale
git push origin --delete v1.2.0Elimina il tag sul server
git describe --tagsTag più vicino e numero di commit successivi, per esempio v1.2.0-3-ga1b2c3d

Comandi avanzati

ComandoChe cosa fa
git bisect start, git bisect bad, git bisect good v1.1.0Ricerca binaria del commit che ha introdotto un errore; alla fine git bisect reset
git worktree add ../hotfix mainUna seconda cartella di lavoro con un altro ramo dello stesso repository
git submodule update --init --recursiveScarica i submodule dopo il clone
git grep "TODO"Ricerca rapida nei file tracciati
git format-patch -1 HEAD / git apply fix.patchSalva un commit in una patch e applica una patch alla directory di lavoro
git gcCompatta gli oggetti e pulisce il repository (di solito lo fa Git da solo)

Errori frequenti e come correggerli

Avete fatto il commit su main invece che su un nuovo ramo

Se il commit non è ancora stato inviato, create un ramo sul commit corrente e riportate indietro main:

git branch feature/login      # il ramo punta al vostro commit
git reset --hard HEAD~1       # main torna indietro di un passo
git switch feature/login

Avete dimenticato un file nell'ultimo commit

git add dimenticato.js
git commit --amend --no-edit

Push rifiutato: rejected, non-fast-forward

Sul server ci sono commit che voi non avete. Prima recuperateli, poi inviate:

git pull --rebase
git push

Avete committato per errore un file con le password

Toglietelo dal tracciamento e inseritelo in .gitignore: git rm --cached .env, poi il commit. Se il commit è già stato inviato, considerate il segreto compromesso e rigeneratelo — dalla cronologia non è sparito.

Per il lavoro quotidiano bastano poche righe: status, add, commit, switch, merge, pull, push e log --oneline. I comandi di annullamento — restore, reset, revert — si scelgono in base al fatto che il commit sia stato pubblicato o meno, mentre reflog va ricordato come rete di sicurezza per i casi estremi. Tutti i comandi di questo cheat sheet li esercitiamo in pratica nel corso di Git, provandoli nel proprio repository.

Domande frequenti

Quanti comandi Git deve conoscere un principiante?

Per iniziare bastano 10–12: init, clone, status, add, commit, log, diff, branch, switch, merge, pull e push. Gli altri si imparano man mano che servono.

In cosa git switch differisce da git checkout?

git switch serve solo a cambiare e creare rami, mentre git checkout serve anche a ripristinare file. La separazione in switch e restore evita di cancellare per errore delle modifiche confondendo un ramo con un file.

Come vedere la guida di un comando Git?

Eseguite git help nome-comando per il manuale completo oppure git nome-comando -h per l'elenco breve dei flag. La stessa documentazione è disponibile su git-scm.com.

Si possono accorciare i comandi Git lunghi?

Sì, con gli alias: git config --global alias.lg "log --oneline --graph --all" permette di digitare git lg.

Questi comandi funzionano su Windows?

Sì, i comandi sono identici su tutti i sistemi. Su Windows conviene eseguirli in Git Bash, in PowerShell o nel terminale dell'editor di codice.

Impara l’argomento in video

Questo argomento è trattato in modo approfondito, con pratica, nel corso «Git da zero a sviluppatore sicuro».

Vai al corso