Hur man inspekterar ett projekts historia med Git Log

En av de mest grundläggande tjänsterna som Git tillhandahåller är projektets historia. Eftersom Git håller reda på alla ändringar av filer som görs i ett arkiv kan det erbjuda mycket kraftfulla loggningsfunktioner. Du kan fråga en projekts historik på många olika sätt och du kan extrahera och visa olika data med ett flexibelt kommando.

De git-logg kommandot är enormt, det största av alla vanliga Git-kommandon. Handboken är över 2500 linjer lång. Lyckligtvis, git-logg ger mycket av sitt mest användbara beteende från några få viktiga alternativ.

Grundläggande loggning med standardbeteendet

Som standard git-logg visar en omvänd kronologisk lista över åtaganden. Varje engagemang innehåller dess hash, författare, datum och engagemangsmeddelande:

Kommandot använder en personsökare (t.ex. mindre, mer) för att visa hela utdata så att du enkelt kan navigera i resultaten. Du kan konfigurera Git för att använda ett program efter eget val, till exempel mest personsökare.

Här är lite git-loggutdata från förvaret för git-källkoden sig:

begå 670b81a890388c60b7032a4f5b879f2ece8c4558 (HEAD -> master, origin / next,
origin / master, origin / HEAD)
Författare: Junio ​​C Hamano 
Datum: må 14 juni 13:23:28 2021 +0900
Den andra satsen
Avloggad: Junio ​​C Hamano 

Resultatet börjar med kommit hash (670...) följt av en lista över grenar som för närvarande pekar på det åtagandet (HEAD -> master, etc.)

Nästa rad beskriver författaren till detta åtagande, med namn och e-postadress.

Fullständigt datum och tid för åtagandet följer på nästa rad.

Slutligen visas hela innehållet i engagemangsmeddelandet. Du kan styra det mesta av allt annat som git-loggen erbjuder med kommandoradsalternativ. Det finns två huvudtyper av alternativ:

• Formatering, som definierar hur Git visar varje engagemang.
• Filtrering, som definierar vilken som begår git-logg inkluderar.

Förutom alternativ för kommandoraden accepterar git log argument som anger filer, åtaganden, grenar eller andra typer av referenser. Dessa tillämpar ytterligare filtrering.

Formatera Git Log Output

En av de enklaste justeringarna är --en linje alternativ som ger en mycket kort output:

git log - online

Varje rad i loggen innehåller nu bara en förkortad commit-hash och ämnet för meddelandet. Detta är ett utmärkt sätt att få en översikt över de senaste åtagandena för projektet:

Tyvärr, utan något annat sammanhang, är denna information inte alltid så användbar. Det kan ge dig en vag känsla för projektet, men det saknar datum och annan användbar information om författare och filer.

Visa en filialgraf

De --Graf med alternativet kan du visualisera relationer mellan grenar. Det är väldigt grundläggande men kan hjälpa till att lösa upp en komplicerad historia.

git log --oneline --graph

Relaterad: Hur man skapar en ny filial i Git

Anpassad vacker produktion

Du kan uppnå mer komplicerad formatering genom att specificera den i detalj med hjälp av --Söt alternativ. Syntaxen går från mycket enkel till mycket mer komplex, så se en manual för fullständiga detaljer.

git log - ganska = kort

Är i princip samma som git-logg utan datum eller fullständigt meddelande:

git log --pretty = oneline

Är ekvivalent med git log - online.

git-logg - ganska = fylligare

Innehåller mycket detaljer. Det skiljer till och med författare och förpliktare som i teorin kan vara olika människor:

Med formatera: variant kan du tillhandahålla en sträng som innehåller vilket innehåll du vill, inklusive platshållare som ersätts av olika data. Här är några exempel på platshållare:

• % H begå hash
• % h förkortat kommunicera hash
• % annons författarens datum
• % ar författarens datum, släkting
• % s begå meddelandets ämne
• % b begå meddelandekroppen
• % s förkortad föräldra hash

Du kan lägga till fasta tecken i utgången och färga den. Det här exemplet visar också en variation på datumformat:

git log --pretty = format: '% C (auto)% h [% ad]% s' --datum = kort

Observera att parenteser omger datumet. Oavsett vilken formatering du väljer, om du vill att utdata ska vara användbara i en pipeline eller för andra former av textbehandling, bör du överväga hur du avgränsar varje del av utdata.

Visar Diff i loggen

En viktig detalj när man tittar på förvarets historia är skillnaderna själva. De representerar trots allt det som faktiskt har förändrats i koden! Till att börja med kan du få en sammanfattning av ändringar tillsammans med varje åtagande med hjälp av --shortstat:

git log --shortstat

Detta lägger till en rad som:

1 fil ändrad, 48 infogningar (+), 2 raderingar (-)

Till botten av varje åtagande. Du ser ofta denna typ av sammanfattning - till exempel på sidor på GitHub - och det är ett användbart sätt att snabbt bedöma omfattningen av ett specifikt engagemang. För mer detaljerad information kan du inkludera full patch-utdata (diffs) med hjälp av -p flagga:

git log -p

Filtrering av Git Log Output

Oavsett vilken formatering du använder ser du fortfarande den fullständiga loggen över alla åtaganden i den aktuella grenen. Även om Git delar upp dem i sidor kan det fortfarande vara mycket output. Med följande alternativ kan du anpassa vilka åtaganden loggen innehåller.

Begränsning per belopp

Om du bara vill trimma resultaten för att visa de senaste få åtagandena använder du -[siffra] syntax:

git log -2

Begränsning efter datum

För att begränsa uppsättningen åtaganden till ett visst datumintervall, använd --eftersom (--efter) och --fram tills (--innan) alternativ. Dessa tar vart och ett ett datum i ISO 8601-format. Du kan använda endera --eftersom eller --fram tills på egen hand, eller båda tillsammans för att specificera ett intervall. Alternativen --efter och --innan är synonymer.

git log --since = "2021-01-01" --until = "2021-05-01"

Begränsning per fil

Git-loggen kan fokusera på en specifik fil snarare än på alla filer i ditt arkiv. Det här är bra för att hjälpa dig att ta reda på hur en viss fil har förändrats över tiden. Lägg bara till filnamnet i slutet av ditt git-kommando:

git-loggfilnamn

Du ser bara de åtaganden som påverkade filnamn.

Skillnader mellan grenar

Du kan ha några unika krav när du visar loggen för en filial. I stället för att se hela historiken kanske du till exempel bara vill se vad som har förändrats i den specifika grenen. Git log kan hjälpa till via ref1..ref2 syntax. Det finns tre lite olika tillvägagångssätt som du kan använda:

1. Visa åtaganden som är i huvudsak men inte gren:

   git-logg - ursprung / gren..origin / main

2. Visa åtaganden som är i gren, men inte huvud:

   git-logg - ursprungslinje /huvud..ursprung/gren

3. Visa åtaganden som endast finns i filial eller huvud:

   git-logg - ursprung / gren...ursprung / huvud

Precis som du kan visa historik mellan filialer med hjälp av ref1..ref2 syntax kan du också visa historik mellan taggar på samma sätt. När allt kommer omkring är både taggar och grenar typ av referens.

git log --abbrev-commit --pretty = format: '% h% ar% s' v2.32.0-rc3..v2.32.0

Om du förbereder release-anteckningar för ett större projekt, git shortlog bör vara din första anlöpshamn. Det ger en lista över författare med engagerade ämnen bredvid dem. Du kan skicka ett referensintervall för att begränsa historiken på ett liknande sätt till git log:

git shortlog v2.32.0-rc3..v2.32.0

De git show-kommando är ännu mer mångsidig än git-logg. Det kan fungera med taggar och andra typer av git-objekt utöver kommissionens historia. Det delar många alternativ med git-logg, men du behöver det verkligen om du behöver gräva ner i detaljer på lägre nivå.

Granska det förflutna med Git Log

Git log är ett komplicerat kommando, men du kan få mycket användning av de mest grundläggande alternativen. Att bläddra i ett förråds historia är ett utmärkt sätt att förstå hur ofta förändringar inträffar och hur många människor gör dem. När du väl har förstått ett projekts historia har du en bra position för att själv kunna bidra till det.

Gå med i den sociala kodningstrenden och bidra till GitHub Repositories

Vill du träna dina kodande muskler och hjälpa till med öppen källkodsprojekt? Så här kan du bidra till GitHub.

Läs Nästa

Om författaren