Git Commit | Tutorial Git Online W3Docs

Il comando git commit registra le modifiche che hai messo in staging nella cronologia del repository come un nuovo snapshot. Ogni commit è un punto permanente e denominato a cui puoi tornare, confrontare con altri o condividere con i collaboratori. Questa pagina spiega cos'è un commit, come si integra il flusso di lavoro stage-then-commit, le opzioni più utili, come scrivere buoni messaggi di commit e in che modo il modello a snapshot di Git differisce dai sistemi più vecchi come SVN.

Definizione

Il comando git commit salva tutte le modifiche attualmente in staging del progetto. I commit vengono creati per acquisire lo stato corrente di un progetto. Gli snapshot committati sono considerati versioni sicure di un progetto perché risiedono nella cronologia locale e Git non li modificherà silenziosamente. Prima di eseguire git commit, si usa il comando git add per mettere in staging le modifiche che il commit memorizzerà.

Un commit è composto da tre elementi:

Uno snapshot di ogni file tracciato al momento del commit (non un diff — vedi Snapshot, non differenze di seguito).
Metadati: l'autore, un timestamp e il messaggio che scrivi.
Un puntatore parent al commit che lo precede, che è il modo in cui Git costruisce una cronologia navigabile con git log.

Ogni commit è identificato da un hash SHA-1 univoco di 40 caratteri (ad esempio 9fceb02...), che puoi abbreviare ai primi sette caratteri quando vi fai riferimento.

Come funziona

Gli snapshot di Git vengono committati nel repository locale. Git consente di accumulare commit localmente invece di inviare immediatamente le modifiche a un server centrale. Le pubblichi in seguito con git push. Questa separazione offre diversi vantaggi:

Suddividere una funzionalità in commit in modo che ogni passo sia piccolo e verificabile.
Raggruppare le modifiche correlate in un singolo commit autonomo.
Pulire la cronologia locale (squashing, modifica dei messaggi, riordinamento) prima di condividerla.
Lavorare offline — puoi effettuare commit in aereo e fare il push quando ti riconnetti.

Il ciclo di vita tipico di una modifica è directory di lavoro → area di staging → commit: modifichi i file, esegui git add per mettere in staging le parti che vuoi, poi git commit per registrarle. Tutto ciò che non metti in staging rimane nella directory di lavoro e viene escluso dal commit.

Opzioni comuni

git commit -a	Committa uno snapshot di tutte le modifiche nella directory di lavoro. Sono incluse solo le modifiche ai file già tracciati.
git commit -m "commit message"	Crea un commit con un messaggio di commit fornito. Per impostazione predefinita, git commit apre l'editor di testo configurato localmente per inserire un messaggio di commit.
git commit -am "commit message"	Combina le opzioni `-a` e `-m` per mettere in staging tutti i file tracciati modificati e creare un commit con un messaggio inline.
git commit --amend	Modifica l'ultimo commit. Le modifiche in staging vengono aggiunte al commit precedente e l'editor si apre per poter modificare il messaggio.

Attenzione

git commit -a (e -am) mette in staging solo i file che Git sta già tracciando. I file nuovi non vengono mai inclusi automaticamente — devi prima eseguire git add su di essi. Esegui git status in caso di dubbi.

Salvare le modifiche con un commit

Nell'esempio seguente, abbiamo il file w3docs.txt con il contenuto modificato sul branch corrente. Per committare lo snapshot in staging del file, devi prima metterlo in staging con il comando git add.

Comando git add

git add w3docs.txt

Eseguendo git add, il file w3docs.txt verrà spostato nell'area di staging di Git. Usa il comando git status per vedere l'output.

git status

git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: w3docs.txt

L'output indica che w3docs.txt verrà salvato con il prossimo commit. Il commit viene creato eseguendo:

Git commit

git commit

L'esecuzione di git commit apre un editor di testo (che possiamo impostare tramite git config) chiedendo un messaggio di log del commit e un elenco di ciò che viene committato:

git commit nell'editor

# Enter the commit message of your changes. Lines that start
# with '#' will be ignored, an empty message breaks off the commit.
# On branch master
# Changes needed to be committed:
# (use "git reset HEAD ..." to unstage)
#
#modified: w3docs.txt

Il formato di commit convenzionale di Git riassume la modifica nella prima riga in meno di 50 caratteri, seguita da una riga vuota e da una spiegazione dettagliata. Per esempio:

Messaggio di git commit

Change the message displayed by w3docs.txt

- Update the sayHello() function to get the username
- Change the sayGoodbye() function to a more welcoming message

La prima riga è il soggetto; il resto è il corpo. Salva e chiudi l'editor per completare il commit.

Scrivere un buon messaggio di commit

Un messaggio chiaro rende la cronologia ricercabile e semplifica la revisione. La convenzione ampiamente adottata è:

Mantieni la riga del soggetto sotto i 50 caratteri e scrivila all'imperativo ("Add login form", non "Added" o "Adds").
Non terminare il soggetto con un punto.
Lascia una riga vuota tra il soggetto e il corpo — molti strumenti ne dipendono.
Vai a capo nel corpo a circa 72 caratteri e spiega il perché della modifica, non solo cosa è cambiato.

Committare con un messaggio inline

Per modifiche piccole e a singolo scopo di solito si evita l'editor e si passa il messaggio direttamente:

git commit -m "Update greeting in w3docs.txt"

Usa git commit -am "..." per mettere in staging ogni file tracciato modificato e committare in un unico passaggio.

Come aggiornare (modificare) un commit

git commit --amend sostituisce il commit più recente invece di aggiungerne uno nuovo. È utile quando hai dimenticato di mettere in staging un file o vuoi correggere un refuso nell'ultimo messaggio. L'editor si apre pre-compilato con il messaggio precedente:

git add e git commit

git add w3docs.txt
git commit --amend

Per modificare solo il messaggio senza aprire l'editor:

git commit --amend -m "Corrected commit message"

Attenzione

L'amend riscrive l'ultimo commit e gli assegna un nuovo hash. Modifica solo i commit che non hai già inviato e condiviso — riscrivere la cronologia pubblica obbliga tutti gli altri a riconciliare le proprie copie. Per annullare un commit che non hai ancora condiviso, usa git reset.

Git commit vs svn commit

SVN è un modello applicativo centralizzato, mentre Git è un modello applicativo distribuito. Il commit di SVN invia le modifiche dal client locale a un repository centralizzato. In Git gli snapshot vengono committati nel repository locale. I commit di Git possono essere inviati a repository remoti arbitrari.

Snapshot, non differenze

Git si basa sugli snapshot, mentre SVN tiene traccia delle differenze nei file. Un svn commit registra un diff che viene applicato al file originale nel repository. Git registra lo stato completo del progetto in ogni commit. Quando salva lo stato del progetto, Git acquisisce uno snapshot dei file correnti e memorizza un riferimento a tale snapshot. Se un file non è cambiato, Git non lo memorizza di nuovo, ottimizzando così lo spazio di archiviazione.

Comandi correlati

git add — metti in staging le modifiche prima di committarle.
git status — verifica cosa è in staging e cosa non lo è.
git log — esplora la cronologia dei commit effettuati.
git reset — togli file dallo staging o annulla un commit.
git push — pubblica i commit locali in un repository remoto.

Esercitazione

Pratica

Quali sono le caratteristiche e le opzioni del comando 'git commit'?

'git commit' salva tutte le modifiche attualmente in staging del progetto.Il comando 'git commit' viene usato per aggiungere modifiche all'area di staging.'git commit -a' committa uno snapshot di tutte le modifiche nella directory di lavoro.'git commit -m' consente di creare un commit con un messaggio di commit specificato.L'uso di 'git commit --amend' modifica l'ultimo commit.I commit di Git vengono inviati direttamente al repository centrale.Git acquisisce uno snapshot dell'aspetto corrente del file e memorizza un riferimento a tale snapshot in ogni commit.