Git Commit: una master class

0
54

Computer portatile su sfondo blu che mostra un prompt dei comandi di Linux.
fatmawati achmad zaenuri/Shutterstock.com
Il comando Git commit memorizza copie delle modifiche dalla tua directory di lavoro nel tuo repository Git. Ma può anche essere utilizzato per modificare i commit esistenti e anche per ripristinare i commit.

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.

Sommario

Cos’è un commit in Git?
Configurazione del comando commit
Usando il comando commit
Un impegno di base
File di staging automatico
Messa in scena e impegno allo stesso tempo
Impegnarsi in un ramo diverso
Apportare modifiche ai commit
Rimozione delle modifiche da un commit
Ripristino di un intero commit
Il coltellino svizzero Git

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"

Impostazione del nome utente Git globale

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

git config --global user.name

Controllo del nome utente globale Git

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

Impostazione di un nome utente Git specifico del repository

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

Impostazione degli indirizzi e-mail utente Git predefiniti globali e specifici del repository

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"

Messa in scena e commit di un singolo file

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

Controllo del registro del repository Git

I commit vengono visualizzati in less.

L'ultimo commit nella parte superiore del registro Git

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

Utilizzo di --dry-run per visualizzare in anteprima i file che verranno messi in scena e non messi in scena

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"

Salvataggio di file modificati e appena creati, dopo aver utilizzato l'opzione add -A

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

Utilizzo dell'opzione commit -a per visualizzare in anteprima le modifiche senza eseguirle

Ora eseguiamo il comando.

git commit -a --dry-run

Utilizzando l'opzione commit -a per mettere in scena e eseguire il commit in un unico passaggio

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

Mettere da parte le modifiche, controllare un ramo e applicare le modifiche dalla scorta

Ora possiamo eseguire a commite aggiorna questo ramo.

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

Commiting delle modifiche che sono state recuperate dalla scorta

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

Controllo dello stato di un ramo per assicurarsi che sia aggiornato

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.

Il registro Git con un tipo evidenziato

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

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

Utilizzo dell'opzione commit --amend per correggere un messaggio di commit

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

Il registro Git che mostra 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

Commiting di un file al commit precedente

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~

Reinvio dell'ultimo commit all'area di staging

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

Rimozione di un file dall'area di gestione temporanea di Git

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

git commit -m "Experimental tweaks"

Salvataggio dei file che rimangono nell'area di staging

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:

Il registro Git con un identificatore di commit evidenziato

Copia quel riferimento e usalo nel file revert comando:

git revert e5bd4560aef8164c6ca9d6d4620b9db7f66aecc8

Ripristino di un commit identificato dal relativo ID commit

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.

Modifica del messaggio di ripristino, con il messaggio predefinito evidenziato

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”.

L'azione di ripristino completata, annullando un intero commit

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