Come utilizzare Git Log per formattare la cronologia dei commit?



Git è uno strumento che aiuta a organizzare e gestire il codice sorgente delle tue applicazioni. Scopri tutto sul comando git log format history e su come usarlo.

In questo articolo, discuteremo alcune opzioni avanzate per formattare e stampare i log di commit per recuperare le informazioni necessarie dalla cronologia del journal del progetto. Dato che già sappiamo, tiene un diario delle modifiche apportate alla cronologia del progetto, ora esploreremo più modi in cui il comando 'git log' è utile.

In primo luogo, sto passando / verificando il ramo 'feature1' per una cronologia conveniente e più breve.
Usa i comandi -





$cd myProj–Passa al progetto git

$git checkout feature1–Passa al ramo 'feature1'



1. Commit Formatting

1.1 Stampa abbastanza il contenuto dell'output in un dato formato

Sintassi: git log --pretty [=]

dove, può essere uno di una linea, corto, medio, pieno, più pieno, e-mail, crudo, e formato:
quando = parte è omessa, il valore predefinito è medio.

1.1.1 –pretty = oneline

Log del commit di stampa grazioso in una 'singola riga'
Comando: git log --pretty = oneline
Formatta l'output in sequenza:




Commit - Cronologia del formato di registro Git - Edureka

1.1.2 –pretty = short

Formatta l'output del commit 'breve' nel formato:
commit (refname)
Autore:



1.1.3 - abbastanza = medio

Comando: git log --pretty = medium
Stampa l'output del commit nel formato 'medio':
commettere
Autore :
Data:


1.1.4 - abbastanza = pieno

Comando: git log --pretty = full
L'output è nel formato:
commit (refname)
Autore:
Commettere:


1.1.5 –pretty = più pieno

Comando: git log --pretty = fuller
commit (refname)
Autore:
AuthorDate :
Commettere:
CommitDate:


1.1.6 –pretty = email

Comando: git log --pretty = email
Stampa l'output del registro nel formato stile e-mail:
A partire dal
A partire dal:
Data:
Soggetto: [PATCH]


1.1.7 –pretty = grezzo

Comando: git log --pretty = raw
Il formato di output del log non elaborato mostra l'intero commit esattamente come memorizzato nell'oggetto commit.
commettere
albero
genitore
autore
commettere

1.1.8 –format:: formattazione personalizzata

Il formato consente di specificare quali informazioni dell'oggetto commit si desidera stampare nel registro di output del commit
Consideriamo i vari segnaposto che questa opzione fornisce proprio come una funzione 'C printf' con l'aiuto di frammenti di codice:

Comando: git log --pretty = formato: '% h% ad | % s% d [% an] '--date = short
Formato di output:
| [nome dell'autore]

% h = ID hash / sha1commit abbreviati
% H = ID lunghi sha-1
%ad = data di creazione
%S = conferma la riga del titolo dell'oggetto
% d = nomi del puntatore di riferimento (ramo, tag)
%un = nome dell'autore
-Data = breve: stampa solo la data e non l'ora in un formato leggibile

Ora, che ne dici di rendere questo output più a misura d'uomo, usando i colori.
Comando:
git log --pretty = format: '% C (giallo)% h% Creset% ad | % Cgreen% s% Creset% Cred% d% Creset% Cblue [% an] '--date = short


Alcuni altri segnaposto utilizzati nello snippet di codice sopra sono:
% C (giallo) : Trasforma la seguente stringa in giallo
% Creset : Reimposta la stringa seguente al colore predefinito (bianco)
% Cgreen : cambia la seguente stringa in verde
%Suppongo: Cambia la seguente stringa in rosso
% Cblue: Rendi il nome dell'autore di colore blu

Non è necessario ricordare e scrivere l'intero comando ogni volta, basta usare un nome breve come git alias come mostrato di seguito:
Comando:
git config --global alias.c-hist 'log --pretty = format:'% C (giallo)% h% Creset% ad | % Cgreen% s% Creset% Cred% d% Creset% Cblue [% an] '--date = short'

'C-hist' rappresenta c ustomizzato hist ory
Quindi, come avresti osservato, sto impostando il mio globale configurazione git file con i valori.

impara ssis passo dopo passo

Ora, per controllare la cronologia del ramo corrente tutto ciò che devi fare è eseguire il comando, in questo modo:
Comando: vai c-hist

1.2 –abbrev-commit: abbrevia git commit hash-id

Comando: git log --abbrev-commit
Il nome completo dell'oggetto commit esadecimale a 40 byte viene ridotto a 7 byte predefiniti.


Mettiamolo in un club con il ‘--una linea'Opzione per una visualizzazione comoda, in questo modo:
Comando: git log --abbrev-commit --oneline

La cosa più interessante è che puoi anche specificare la lunghezza in byte degli id ​​sha-1 utilizzando l'opzione '–abbrev =', come mostrato di seguito:
Comando: git log --abbrev-commit --abbrev = 5 --oneline



Chiaramente, gli id ​​sha-1 evidenziati sono ridotti alla dimensione di 5 byte.

1.3 –no-abbrev-commit

Mostra il nome completo dell'oggetto di commit esadecimale a 40 byte.
Questo nega –Abbrev-commit e quelle opzioni che implicano
come '–oneline'.
Comando: git log --pretty = oneline --no-abbrev-commit



1.4 –data-relativa

Comando: git log --relative-date

Si prega di notare che l'ora evidenziata è soggetta a modifiche con riferimento all'ora in cui si esegue il comando sul sistema.

1.5 –data =

Puoi anche formattare la data dei log di commit in una delle seguenti opzioni di formato:

1.5.1 –data = relativa

Comando :git log --date = relative
Questo è sinonimo del comando precedente 'git log --relative-date'E stampa gli stessi commit.

1.5.2 –date = locale

Comando : git log --date = local

1.5.3 –date = iso

Comando: git log --date = iso

1.5.4 –date = iso-strict

Comando: git log --date = iso-strict

1.5.5 –date = rfc

Comando: git log --date = rfc

1.5.6 –data = breve

Comando: git log --date = short

1.5.7 –date = raw (mostra la data in secondi)

Comando: git log --date = raw
Stampa l'ora in secondi dal unix epoc time (Jan 01 1970) seguito dal fuso orario.

1.5.8 –data = umano

Comando: git log --date = umano

1.5.9 –date = unix

Mostra la data come unix epoc (UTC) ora.
Comando: git log --date = unix

1.6 –genitori

Stampa anche i genitori di ogni commit nel formato:
Comando: git log --parents
Comando di output Oneliner: git log --parents --oneline

Punti da notare:
C366419 è un commit di unione, quindi ha rispettivamente 2 genitori: feeb30c e 4920adc
allo stesso modo

1d67b50 è un commit di unione, che è il risultato della fusione f2ff2e4 e abb694b
078f9f5 è un commit di unione creato dall'unione 9a2412e e ab3a5e5
Mentre, 86792c6 è il commit iniziale, quindi nessun genitore.

1.7 –bambini

Stampa anche i bambini nel modulo
Comando: git log - bambini --oneline

Nota :
006b9ce è l'ultimo commit, quindi non ha ancora oggetti di commit figli. La prossima modifica che apporti e invii su questo ramo sarà l'oggetto di commit figlio di questo ultimo id sha-1.

1.8 –graph

Disegna una rappresentazione grafica basata su testo della cronologia dei commit prima degli id ​​sha-1.
Comando: git log --graph
Output oneliner migliorato: git log --graph --oneline


Ciò consente di capire quando, come e perché e altri rami sono stati uniti nel ramo attualmente estratto.

1.9 –show-linear-break

Comando: git log --show-linear-break
Questo è un comando utile, per indicare una barriera tra 2 commit consecutivi che non appartengono a un ramo lineare, ovvero i commit che provengono da rami diversi.


Confronta l'output di cui sopra con l'output del comando 'git log –graph' che mostra chiaramente come sono stati uniti i commit 'linear-break'.

Bonus: riepiloga l'output del log git: 'git shortlog'

Il 'git shortlog'Command classifica i log dei commit in base all'autore e stampa un riepilogo generale, indicando i commit effettuati da ciascun autore.
Comando: git log shortlog

Comando : git log shortlog -s
-s sta per –summary, sopprime la descrizione del commit e stampa semplicemente il conteggio dei commit di ogni autore, in questo modo:

Inoltre, puoi anche formattare l'output utilizzando gli stessi segnaposto discussi in '--pretty = formato' opzione
Prova il comando: git shortlog --format = '% h | %S'

Quindi, sarai d'accordo che questo output ha più senso in quanto mostra l'id e il per ogni autore insieme al conteggio totale dei commit.

Nota : È interessante notare che puoi trovare molto facilmente il ramo che ha effettuato un particolare commit. Vale la pena approfondire questa discussione nei prossimi articoli.

Quindi, con questo, arriviamo alla fine di questoCronologia del formato del registro Gitblog, spero che tu l'abbia trovato informativo.

In questo post abbiamo appreso alcune tecniche di formattazione che stampano le informazioni sul progetto in modo più personalizzato e intuitivo. Ora dovresti sapere come utilizzare efficacemente i parametri del comando 'git log' per estrarre tutte le informazioni di cui hai bisogno sul codice sorgente dalla cronologia impegnata. Quindi, con questo, arriviamo alla fine di questo articolo, spero che tu l'abbia trovato informativo.

Se sei curioso di saperne di più puoi dare un'occhiata a questo da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo. Il corso di formazione sulla certificazione DevOps di Edureka aiuta gli studenti a capire cos'è DevOps e acquisire esperienza in vari processi e strumenti DevOps come Puppet, Jenkins, Nagios, Ansible, Chef, Saltstack e GIT per l'automazione di più passaggi in SDLC.

Hai domande per noi? Si prega di menzionarlo nella sezione commenti di questo articolo su 'Cronologia del formato di registro Git' e ti risponderemo.