Git Commit: una master class

Un requisito di base di qualsiasi sistema di controllo della versione è memorizzare 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 add comando. In realtà, il add command 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 commit comando. Questo è dove il add comando riappare nel nostro flusso di lavoro. Noi usiamo il add comando per dire a Git quale cambiato file che 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 user.name "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 il file --global opzione.

git config user.name "McKay, David"

git config user.name

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 a livello globale o per un singolo repository includendo o omettendo il --global opzione.

git config user.email "dave@phony-domain.com"

git config --global user.email "dave@fake-domain.com"

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 commit il comando fa riferimento e utilizza questi valori mentre opera.

Usando il comando commit

L’uso di base del commit Il comando 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 add comando per mettere in scena il file, quindi eseguirne il commit. Stiamo usando il -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 add jibber.c

git commit -m "Updated help text"

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

git log

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’usare il file -A (tutti) opzione con add.

Questo mette automaticamente in scena tutto modificata file insieme a tutti attualmente non tracciato File. 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 lo sono RIMOSSO dall’indice.

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

git add -A --dry-run

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

git add -A

git commit -m "Enhanced parsing"

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 commit comando ha una minuscola -a (tutti) opzione. Questo esegue lo staging e il commit dei file in un unico passaggio.

IL commit -a fasi di opzione e commit modificati esistente file, e rimuove file dall’indice se sono stati rimossi dalla directory di lavoro. Esso no mettere automaticamente in scena i file non tracciati.

Come il add comando, il comando commit ha un --dry-run opzione che 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 Git stash comando 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 file pop comando piuttosto che il apply comando. IL pop Il comando applica le modifiche e le rimuove anche dalla scorta.

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

git stash

git checkout classic-parser

git stash pop

Ora possiamo eseguire a commite aggiorna questo ramo.

git commit -a -m "Added pre-parser functions"

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

git checkout new-parser

git status

IMPARENTATO: 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 il --amend opzione 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 vedere questo.

Per correggere questo, useremo il --amend opzione come questa.

git commit --amend -m "Optimized phrase identification"

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 eseguire un commit con il file --amend opzione. IL --no-edit opzione significa che non abbiamo bisogno di fornire un nuovo messaggio di commit. Il messaggio di commit precedente viene mantenuto.

git add 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 reset comando. 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 file reset --soft comando. 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 l’estensione reset --mixed comando. 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 "Experimental tweaks"

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

IMPARENTATO: 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 file revert comando:

git revert 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 git log ancora una volta, 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.

IMPARENTATO: Come usare l’unione di Git