Git Commit: una master class

Un requisito di base di qualsiasi sistema di controllo della versione è archiviare diverse versioni dei file per te. In Git, il comando che fa questo è commit . Ecco tutto ciò che devi sapere.

Cos'è un commit in Git?

I commit sono la serie di istantanee realizzate durante il ciclo di vita di un progetto che costituiscono la sua storia di sviluppo. I commit sono ciò che ci consente di estrarre una versione del progetto com'era in diversi punti del passato. Perché è importante?

I sistemi di controllo della versione (VCS) sono più comunemente utilizzati con il codice sorgente del software e i progetti di sviluppo. Ma possono essere utilizzati con successo con qualsiasi raccolta di file di testo, come file Markdown contenenti capitoli di un libro.

Potresti non volere che ogni file nelle directory del tuo progetto sia gestito dal VCS, quindi devi essere in grado di nominare i file che vuoi siano controllati dalla versione. Questo li aggiunge alla vista di controllo della versione del progetto. Saranno monitorati per i cambiamenti.

Un altro modo per raggiungere questo obiettivo è utilizzare un elenco di elementi da ignorare. Questo dice a Git quali file, directory o tipi di file dovrebbe sempre ignorare.

Nel corso del tempo, man mano che vengono aggiunti nuovi file al progetto, alcuni dovranno essere aggiunti al sistema di controllo della versione. In Git, questo è gestito dal comando add . In realtà, il comando add fa un doppio servizio, come vedremo.

Per mantenere una cronologia delle modifiche apportate al progetto, chiederai periodicamente a Git di archiviare uno snapshot dello stato del progetto, utilizzando il comando commit . È qui che il comando add riappare nel nostro flusso di lavoro. Usiamo il comando add per dire a Git quali file modificati vogliamo includere nello snapshot. Quindi usiamo commit per dire a Git di creare lo snapshot.

Configurazione del comando commit

Le informazioni sul commit sono memorizzate con esso, in modo che sia sempre possibile sapere chi ha effettuato il commit, quando e cosa contiene il commit. Alcuni di questi metadati vengono catturati al momento del commit, come il messaggio di commit.

I metadati relativi all'identità dei membri del team di sviluppo possono essere configurati da ciascun utente, per evitare di fornire ripetutamente le stesse informazioni.

Per impostare il tuo nome globalmente per tutti i repository sul tuo computer, usa questo comando.

 git config --global nome.utente "Dave McKay" 

Per verificare che il tuo nome sia stato impostato, usa questo comando.

 git config --global user.name 

Se è necessario utilizzare un nome diverso su un particolare repository, passare alla directory del progetto e utilizzare lo stesso comando senza l'opzione --global .

 git config nome.utente "McKay, David"

 git config nome utente 

Ora abbiamo un nome utente predefinito diverso per questo repository e il nostro nome globale è ancora utilizzato per altri repository.

In modo simile, possiamo impostare un indirizzo email globalmente o per un singolo repository includendo o omettendo l'opzione --global .

 git config user.email "[email protected]"

 git config --global user.email "[email protected]"

 git config user.email

 git config --global user.email 

Queste impostazioni sono conservate nei file di configurazione. Le impostazioni globali di Git sono conservate in "~/.gitconfig" e le impostazioni specifiche del repository sono conservate nel file ".git/config" del repository.

Il comando commit fa riferimento e utilizza questi valori mentre opera.

Usando il comando commit

L'utilizzo di base del comando commit consiste nel prendere i file che si trovano nell'area di staging, nota come indice, e archiviarli come commit nel ramo corrente del repository.

Un impegno di base

Abbiamo un progetto con un file modificato. Useremo il comando add per mettere in scena il file, quindi eseguirne il commit. Stiamo usando l'opzione -m (messaggio di commit) in modo da poter fornire una breve descrizione dello scopo delle modifiche. Se non usiamo questa opzione, ci viene richiesto un messaggio di commit mentre il commit ha luogo. È più conveniente aggiungerne uno sulla riga di comando.

 git aggiungi jibber.c

 git commit -m "Testo di aiuto aggiornato" 

Se usiamo il comando git log possiamo rivedere i dettagli dei commit, in ordine cronologico, con il commit più recente in cima alla lista.

 registro git 

I commit vengono visualizzati in less .

Il commit è stato contrassegnato con il nome e l'indirizzo e-mail che abbiamo fornito in precedenza e anche il nostro messaggio di commit viene registrato.

File di staging automatico

La messa in scena di molti file può richiedere un po' di tempo. Un approccio diverso consiste nell'utilizzare l'opzione -A (all) con add .

Questo mette automaticamente in scena tutti i file modificati insieme a tutti i file attualmente non tracciati . Lo staging dei file non tracciati rispetta le impostazioni nel file ".gitignore". Git non metterà in scena i file che gli hai detto di non voler essere inclusi. Infine, i file nell'indice che non si trovano più nella directory di lavoro vengono rimossi dall'indice.

Chiaramente, l'opzione -A può far accadere molte cose tutte in una volta. L'opzione --dry-run ti dà un'anteprima delle modifiche senza eseguirle realmente.

 git add -A --esecuzione a secco 

Nel nostro esempio, metterà in scena due file esistenti modificati e due nuovi file. Andiamo avanti e usiamo l'opzione -A prima di usare il comando commit .

 git aggiungi -A

 git commit -m "Analisi migliorata" 

Possiamo vedere che in tutto quattro file sono stati modificati. Due di questi sono i file appena creati, che sono elencati.

Messa in scena e impegno allo stesso tempo

Il comando commit ha un'opzione minuscola -a (tutto). Questo esegue lo staging e il commit dei file in un unico passaggio.

L'opzione commit -a mette in scena e conferma i file esistenti modificati e rimuove i file dall'indice se sono stati rimossi dalla directory di lavoro. Non mette automaticamente in scena i file non tracciati.

Come il comando add , il comando commit ha un'opzione --dry-run che ti consente di visualizzare in anteprima le sue azioni prima di eseguirlo.

 git commit -a --dry-run 

Ora eseguiamo il comando.

 git commit -a --dry-run 

I file vengono messi in scena e impegnati per noi.

Impegnarsi in un ramo diverso

Se hai apportato alcune modifiche ai file nella tua directory di lavoro, ti rendi conto di non aver effettuato il checkout del ramo corretto, devi fare in modo che le modifiche vengano salvate nel ramo corretto senza influire sul ramo corrente.

Git non ha un comando per impegnarsi in un ramo diverso. Ma puoi correggere questa situazione con un po' di destrezza Git.

Useremo il comando Git stash per fare una copia delle modifiche. Quindi controlleremo il ramo corretto e applicheremo le modifiche dalla scorta. Per applicare le modifiche nascoste stiamo usando il comando pop piuttosto che il comando apply . Il comando pop applica le modifiche e le rimuove anche dalla scorta.

Abbiamo apportato alcune modifiche al ramo new-parser del nostro repository. Avrebbero dovuto essere realizzati nel ramo classic-parser .

 git scorta

 git checkout parser classico

 git stash pop 

Ora possiamo eseguire un commit e aggiornare questo ramo.

 git commit -a -m "Aggiunte funzioni pre-parser" 

Se torniamo al ramo new-parser possiamo vedere che è aggiornato, il che significa che le modifiche sono state rimosse dalla tua directory di lavoro e il tuo repository e i tuoi file sono sincronizzati.

 git checkout new-parser

 stato git 

CORRELATO: Come aggiornare e mantenere rami Git separati

Apportare modifiche ai commit

Se hai bisogno di migliorare il tuo messaggio di commit, forse hai individuato un errore di battitura, o hai dimenticato di mettere in scena un file che avrebbe dovuto essere incluso nel commit, puoi usare l'opzione --amend per sistemare le cose. L'avvertenza è che questo non dovrebbe essere usato su commit che sono stati inviati a un repository remoto.

Nel nostro ultimo messaggio di commit, "fraze" avrebbe dovuto essere "phrase". Se usiamo git log possiamo vederlo.

Per correggere questo, useremo l'opzione --amend come questa.

 git commit --amend -m "Identificazione frase ottimizzata" 

Se usiamo git log ancora una volta, possiamo vedere che il vecchio commit è stato sostituito da uno nuovo con il messaggio di commit corretto.

Se vogliamo aggiungere un file che abbiamo dimenticato di mettere in scena, possiamo eseguire il commit di quel file in modo che appaia come parte del commit precedente.

Useremo add per mettere in scena il file, quindi faremo un commit con l'opzione --amend . L'opzione --no-edit significa che non abbiamo bisogno di fornire un nuovo messaggio di commit. Il messaggio di commit precedente viene mantenuto.

 git aggiungi jibber.c

 git commit --amend --no-edit 

Rimozione delle modifiche da un commit

Se hai inavvertitamente messo in scena e commesso un file che non avevi intenzione di fare, puoi rimuovere quel file dal commit usando il comando reset . Ripristineremo il commit nell'area di staging, o index. Quindi rimuoveremo il file ed eseguiremo nuovamente il commit del resto dei file.

Per reimpostare l'ultimo commit nell'area di staging, utilizziamo il comando reset --soft . HEAD~ è una scorciatoia per "il commit dietro l'HEAD della sequenza temporale del commit del progetto", o in inglese, "l'ultimo commit".

 git reset --soft HEAD~ 

Per rimuovere il file che non avrebbe dovuto essere incluso, utilizziamo il comando reset --mixed . Ciò reimposta tali modifiche nella directory di lavoro, ricreando il file modificato come file senza messa in scena e senza commit.

 git reset --mixed jibber.c 

Dobbiamo eseguire il commit degli altri file rimasti nell'indice.

 git commit -m "modifiche sperimentali" 

Gli altri due file che erano nel commit originale vengono ricommessi per noi.

CORRELATO: Come correggere, modificare o annullare i commit di Git (modificare la cronologia di Git)

Ripristino di un intero commit

A volte annullare un intero commit è la cosa più semplice da fare. Riporta la directory di lavoro e il repository allo stato in cui si trovavano prima del commit.

Dobbiamo utilizzare l'ID di riferimento con hash del commit. Possiamo trovarlo usando git log :

Copia quel riferimento e usalo nel comando revert :

 ripristino git e5bd4560aef8164c6ca9d6d4620b9db7f66aecc8 

Questo aprirà il tuo editor predefinito in modo da poter modificare un messaggio di ripristino. C'è un messaggio predefinito inserito per te. Puoi usarlo o modificarlo a tuo piacimento.

Quando sei soddisfatto del tuo messaggio di ripristino, salva il file ed esci dall'editor. In nano, puoi farlo con "Ctrl+O" e "Ctrl+X".

Usando ancora una volta git log , possiamo vedere che è stato aggiunto un nuovo commit che annulla le modifiche del commit ripristinato.

Il coltellino svizzero Git

Ovviamente, commit è uno dei comandi Git più importanti. Può fare molto, quindi c'è molto da imparare. Fare i conti con le sue funzionalità meno utilizzate è tempo ben speso. Quando devi correggere un errore, proprio ora, sarai felice di esserti preparato in anticipo.

CORRELATO: Come usare Git merge