Vizualizarea topologiei ramurilor în Git (Programare, Git)

Benjol a intrebat.

Mă joc cu Git în mod izolat pe propriul meu computer și mi se pare dificil să mențin un model mental al tuturor ramurilor și al comenzilor mele. Știu că pot să fac un git log pentru a vedea istoricul confirmărilor din locul în care mă aflu, dar există o modalitate de a vedea întreaga topografie a ramurilor, ceva asemănător cu aceste hărți ASCII care par a fi folosite peste tot pentru a explica ramurile?

      .-A---M---N---O---P
     /     /   /   /   /
    I     B   C   D   E
        /   /   /   /
      `-------------'

Mi se pare că cineva care ar veni și ar încerca să-mi ia depozitul ar avea dificultăți în a înțelege exact ce se întâmplă.

Cred că sunt influențat de AccuRev’s stream browser

Comentarii

  • duplicat al stackoverflow.com/questions/1064361/… –  > Por Leif Gruenwoldt.
  • @leif81, o jumătate de duplicat, pentru mine. @Masi a exclus explicit gitk în întrebarea sa. –  > Por Benjol.
  • Răspunde acest lucru la întrebarea dumneavoastră? Grafice destul de frumoase ale ramurilor git –  > Por Gonçalo Peres 龚燿禄.
30 răspunsuri
jrockway

Utilizați git log --graph sau gitk. (Ambele acceptă și --all, , care va afișa toate ramurile în loc de doar cea curentă).

Pentru numele ramurilor și o vizualizare compactă, încercați:

git log --graph --decorate --oneline

Comentarii

    49

  • Acest lucru nici măcar nu etichetează comenzile cu ramurile. Nu aș numi-o o vizualizare bună în forma actuală. –  > Por Roman Starkov.
  • Mulțumesc! gitg are, de asemenea, funcția --all și etichetează, de asemenea, comenzile. De asemenea, nu am văzut niciodată în dropdown că poți selecta acolo toate ramurile. –  > Por Thomas.
  • 217

  • Aș recomanda git log --graph --decorate --oneline – afișează câte o confirmare pe linie și decorează cu numele ramurilor. –  > Por sleske.
  • tig (un client git ncurse) oferă, de asemenea, funcția --all opțiune. Destul de utilă! –  > Por Pierre-Adrien.
  • A se vedea, de asemenea, răspunsul lui Andrew cu privire la --simplify-by-decoration opțiunea. –  > Por ruvim.
P Shved

De obicei, eu folosesc

git log --graph --full-history --all --pretty=format:"%h%x09%d%x20%s"

Cu culori (dacă shell-ul dvs. este Bash):

git log --graph --full-history --all --color 
        --pretty=format:"%x1b[31m%h%x09%x1b[32m%d%x1b[0m%x20%s"

Aceasta va imprima o reprezentare pe bază de text ca aceasta:

* 040cc7c       (HEAD, master) Manual is NOT built by default
* a29ceb7       Removed offensive binary file that was compiled on my machine and was hence incompatible with other machines.
| * 901c7dd     (cvc3) cvc3 now configured before building
| * d9e8b5e     More sane Yices SMT solver caller
| | * 5b98a10   (nullvars) All uninitialized variables get zero inits
| |/
| * 1cad874     CFLAGS for cvc3 to work successfully
| *   1579581   Merge branch 'llvm-inv' into cvc3
| |
| | * a9a246b   nostaticalias option
| | * 73b91cc   Comment about aliases.
| | * 001b20a   Prints number of iteration and node.
| |/
|/|
| * 39d2638     Included header files to cvc3 sources
| * 266023b     Added cvc3 to blast infrastructure.
| * ac9eb10     Initial sources of cvc3-1.5
|/
* d642f88       Option -aliasstat, by default stats are suppressed

(Ați putea folosi doar git log --format=oneline, , dar aceasta va lega mesajele de comitere la numere, ceea ce arată mai puțin frumos IMHO).

Pentru a face o scurtătură pentru această comandă, este posibil să doriți să editați fișierul dvs. ~/.gitconfig fișier:

[alias]
  gr = log --graph --full-history --all --color --pretty=tformat:"%x1b[31m%h%x09%x1b[32m%d%x1b[0m%x20%s%x20%x1b[33m(%an)%x1b[0m"

Cu toate acestea, așa cum Sodel Vociferous notează în comentarii, o comandă de formatare atât de lungă este greu de memorat. De obicei, nu este o problemă, deoarece o puteți pune în ~/.gitconfig fișier. Cu toate acestea, dacă uneori trebuie să vă conectați la o mașină la distanță unde nu puteți modifica fișierul de configurare, ați putea folosi o versiune mai simplă, dar mai rapid de tastat:

git log --graph --oneline

Comentarii

  • Dacă vă plac datele: git log –graph –graph –full-history –all –color –date=short –pretty=format:”%x1b[31m%h%x09%x1b[32m%d%x1b[0m%x20%ad %s” –  > Por sehugg.
  • –oneline este un substitut mai ușor de reținut pentru toată acea magie profundă de formatare pretty. –  > Por Daniel Ralston.
  • @SodeltheVociferous, într-adevăr, nu am abordat problema din partea de care vorbești tu; mi-am extins răspunsul. –  > Por P Shved.
  • Notă: --full-history este relevant doar atunci când se utilizează --simplify-by-decoration sau specificarea unui traseu de fișier. –  > Por Slipp D. Thompson.
  • Pot să vă întreb de unde ați luat șirul de format? Sau cum naiba ai inventat chestia asta? –  > Por elliotwesoff.
Slipp D. Thompson

Am 3 pseudonime (și 4 alias-aliase pentru utilizare rapidă) pe care în mod normal le introduc în ~/.gitconfig fișier:

[alias]
    lg = lg1
    lg1 = lg1-specific --all
    lg2 = lg2-specific --all
    lg3 = lg3-specific --all

    lg1-specific = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(auto)%d%C(reset)'
    lg2-specific = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset)%C(auto)%d%C(reset)%n''          %C(white)%s%C(reset) %C(dim white)- %an%C(reset)'
    lg3-specific = log --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset) %C(bold cyan)(committed: %cD)%C(reset) %C(auto)%d%C(reset)%n''          %C(white)%s%C(reset)%n''          %C(dim white)- %an <%ae> %C(reset) %C(dim white)(committer: %cn <%ce>)%C(reset)'

git lg/git lg1 arată astfel:

git lg2 arată așa:

și git lg3 arată astfel:

Trebuie remarcat faptul că aceasta nu este o soluție definitivă – este un șablon pe care îl puteți modifica, adăuga și repara după bunul plac. Dacă doriți să le folosiți, recomandarea mea este să:

  1. Adăugați-le la .gitconfig,
  2. Personalizați-le după bunul plac (diferite alegeri de culori, aranjamente diferite ale liniilor pentru versiunile cu 2 și 3 linii, etc.),
  3. Și apoi salvați o copie într-un Gist sau în alt instrument de fragmente de cod, astfel încât să puteți copia & lipiți-o în .gitconfigs în viitor (sau, alternativ, să vă controlați versiunea fișierelor dotfiles, desigur)..

Notă: Răspuns copiat de la și îmbunătățit pe răspunsul de la stackoverflow.com/questions/1057564/pretty-git-branch-graphs, deoarece este mult mai potrivit aici decât a fost acolo.  Am lăsat copia pe cealaltă întrebare din motive istorice – acum este închisă, iar răspunsul este menționat de o mulțime de alte răspunsuri.

Comentarii

  • Sugestie: înlocuiți %C(bold yellow) cu %C(auto) pentru a avea culori diferite pentru HEAD, , local și sucursale la distanță (ref). –  > Por Atcold.
  • Rețineți că puteți evita adăugarea manuală a indentării în șirul de format utilizând %w(); în acest fel puteți, de asemenea, să aliniați în mod corespunzător mesajele de confirmare mai lungi sau cu mai multe rânduri fără a strica graficul. –  > Por charliegreen.
  • @mbadawi23 Ele sunt redundante de dragul consecvenței între platforme și instalații Git. --abbrev-commit este acolo pentru că liniile a 2-a și a 3-a sunt legate manual cu spații și am vrut să fiu absolut sigur că se va folosi SHA- scurt, așa că mai bine să fim siguri decât să ne pară rău. --decorate este, de asemenea, acolo pentru că, deși valorile implicite din Git fac același lucru, acesta ar putea fi configurat diferit sau diferit în diferite versiuni Git – pentru acestea, vreau neapărat decorare. În cele din urmă, stegulețele suplimentare/redundante nu sunt rele aici – acest lucru merge într-un fișier; nu este ceva ce se tastează tot timpul. –  > Por Slipp D. Thompson.
  • @TimothyPulliam Pentru a înțelege ce comisioane fac „parte din fiecare ramură”, trebuie să urmăriți vizual linia colorată. Aproape toate instrumentele nu vă ajută prea mult în acest sens, deoarece angajamentele Git nu aparțin în mod intrinsec niciunei ramuri – ele sunt implicate (la momentul vizualizării grafice) ca aparținând oricărei ramuri sau etichete care le are în ascendența lor. Dacă nu există nicio ramură/tag care să facă referire la o confirmare și aceasta dispare (dar nu este colectată ca gunoi timp de aproximativ 2 săptămâni); adăugați o ramură/tag care să facă referire la o confirmare care nu a fost referită anterior și aceasta reapare. Sper că toate acestea au sens. –  > Por Slipp D. Thompson.
  • @PedroGarcíaMedina Vreau să spun „rulează acest text citat ca o comandă shell, mai degrabă decât să apelezi o altă comandă git”, și este conceput în principal pentru integrarea altor instrumente cu git (de exemplu, ați putea scrie ceva de genul syncup = !"git pull && make all"). Îl folosesc aici pentru că nu puteam apela un alt alias într-un alias (puteam apela doar o comandă git), dar poate că acest lucru s-a schimbat în versiunile mai noi de git. Voi verifica de două ori și voi simplifica dacă acum se poate face doar cu lg = lg1. –  > Por Slipp D. Thompson.
Andrew

La oricare dintre aceste rețete (bazate pe git log sau gitk), puteți adăuga --simplify-by-decoration pentru a prăbuși părțile liniare neinteresante ale istoricului. Acest lucru face ca mult mai multă topologie să fie vizibilă dintr-o dată. Acum pot înțelege istorii mari care ar fi fost de neînțeles fără această opțiune!

Am simțit nevoia să postez acest lucru pentru că nu pare să fie atât de cunoscut pe cât ar trebui să fie. Nu apare în majoritatea întrebărilor de pe Stack Overflow despre vizualizarea istoricului și mi-a luat destul de mult timp să o caut ca să o găsesc – chiar și după ce știam că o vreau! În cele din urmă am găsit-o în acest Raport de eroare Debian. Prima mențiune pe Stack Overflow pare să fie acest răspuns de Antoine Pelisse.

Comentarii

  • Perfect — exact ceea ce căutam! Ar trebui să primească mai multe upvotes; aproape toată lumea știe deja despre gitk/gitg/git log –graph, dar acestea nu sunt deloc foarte utile dacă vrei să vizualizezi topologia ramurii și nu-ți pasă de comenzi individuale. –  > Por imolit.
  • Este exact ceea ce aveam nevoie, fantastic. Este singurul lucru care m-a ajutat, din toate răspunsurile. --simplify-by-decoration face atât de clar ce se întâmplă. –  > Por Ela782.
  • Acesta ar trebui să fie într-adevăr răspunsul. git log --graph --all --simplify-by-decoration funcționează la fel de bine. –  > Por Irfy.
  • Dacă am putea folosi --simplify-by-decorationîn timp ce adăugăm n comisioane înainte/după fiecare comisie deocratizată (cum ar fi -B și -A pentru grep). –  > Por junvar.
  • Folosesc această soluție atât de des încât o folosesc atât de des încât o am ca pseudonimă „git tree”. –  > Por user16973.
suma de control

Gitk uneori dureros pentru mine să citesc.

Mă motivează să scriu GitVersionTree.

Comentarii

  • @exhuma Am un PR în cu autorul pentru a sprijini Mono (testat pe Ubuntu 13.10 împotriva Mono 2.10) –  > Por Max Ehrlich.
  • Am descoperit că GitVersionTree păstrează ramurile în același loc în timp, ceea ce face mai ușor de văzut cum se schimbă lucrurile. –  > Por sfranky.
  • Tocmai am dat peste asta. Arată foarte bine; abia aștept să o verific. O sugestie (poate că o aveți deja), dar ar fi frumos să se prăbușească mai multe comenzi care nu sunt puncte de bifurcare. Acest lucru ar face mai ușoară vizualizarea topologiei ramurii. –  > Por Edward Falk.
pylang

Aruncați o privire la Gitkraken – o interfață grafică multi-platformă care arată topologia într-un mod lucid.

Iată o scurtă prezentare tutorial video despre unele caracteristici avansate.

Notă: este necesară înregistrarea.

Comentarii

  • Cum se face că acest fir de discuție are GitKraken, dar nu are SourceTree, mai vechi și gratuit? (Știu, știu, Atlassian nu face întotdeauna totul cum trebuie. Dar SourceTree este un instrument destul de bun pentru vizualizare). –  > Por XML.
  • Poate că este un bug în noua versiune. Ce versiune aveți? Încercați o versiune veche? –  > Por pylang.
Yeo

99,999% din timpul meu se uită la istoricul prin git lg iar 0,001% este de git log.

Vreau doar să împărtășesc două aliasuri de jurnal care ar putea fi utile (configurați din .gitconfig):

[Alias]
     lg = log --graph --pretty=format:'%Cred%h%Creset %ad %s %C(yellow)%d%Creset %C(bold blue)<%an>%Creset' --date=short
     hist = log --graph --full-history --all --pretty=format:'%Cred%h%Creset %ad %s %C(yellow)%d%Creset %C(bold blue)<%an>%Creset' --date=short
  • git lg va vedea istoricul ramurii curente.
  • git hist va vedea întregul istoric al ramurii.

VonC

Îmi place, cu git log, , să facă:

 git log --graph --oneline --branches

(de asemenea, cu –all, pentru a vizualiza și ramurile de la distanță)

Funcționează cu versiunile recente ale Git: introdus de la 1.6.3 (Joi, 7 mai 2009)

  • --pretty=<style>” din familia de comenzi log poate fi acum ortografiată ca „--format=<style>„.
    În plus, --format=%formatstring este o prescurtare pentru --pretty=tformat:%formatstring.

  • --oneline” este un sinonim pentru „--pretty=oneline --abbrev-commit„.

PS D:gittestsfinalRepo> git log --graph --oneline --branches --all
* 4919b68 a second bug10 fix
* 3469e13 a first bug10 fix
* dbcc7aa a first legacy evolution
| * 55aac85 another main evol
| | * 47e6ee1 a second bug10 fix
| | * 8183707 a first bug10 fix
| |/
| * e727105 a second evol for 2.0
| * 473d44e a main evol
|/
* b68c1f5 first evol, for making 1.0

De asemenea, puteți limita durata de afișare a jurnalului (numărul de comenzi):

PS D:gittestsfinalRepo> git log --graph --oneline --branches --all -5
* 4919b68 a second bug10 fix
* 3469e13 a first bug10 fix
* dbcc7aa a first legacy evolution
| * 55aac85 another main evol
| | * 47e6ee1 a second bug10 fix

(afișează doar ultimele 5 comenzi)


Ceea ce nu-mi place la soluția selectată în prezent este:

 git log --graph

Afișează mult prea multe informații (atunci când vreau să mă uit doar la un rezumat rapid):

PS D:gittestsfinalRepo> git log --graph
* commit 4919b681db93df82ead7ba6190eca6a49a9d82e7
| Author: VonC <[email protected]>
| Date:   Sat Nov 14 13:42:20 2009 +0100
|
|     a second bug10 fix
|
* commit 3469e13f8d0fadeac5fcb6f388aca69497fd08a9
| Author: VonC <[email protected]>
| Date:   Sat Nov 14 13:41:50 2009 +0100
|
|     a first bug10 fix
|

gitk este grozavă, dar mă obligă să părăsesc sesiunea shell pentru o altă fereastră, în timp ce afișarea rapidă a ultimelor n comenzi este adesea suficientă.

Comentarii

  • Am ales și eu această metodă, dar am făcut un alias, astfel încât tastarea „git graph” este același lucru cu executarea „git log –graph –decorate –oneline”. –  > Por Will Pike.
  • @ConnerPike bună idee. Am și eu aliasul „lg”: vezi stackoverflow.com/a/3667139/6309 –  > Por VonC.
Jack Senechal

Gitg este un instrument excelent pentru Linux, similar cu Gitx pentru OS X. Trebuie doar să rulați „gitg” în linia de comandă de undeva din interiorul structurii arborescente a depozitului dumneavoastră (la fel ca în cazul lui gitx).

Comentarii

  • În foarte multe cuvinte: gitg are un meniu derulant în care se poate alege ce ramură să se vizualizeze. Această listă derulantă are și o opțiune „All” (Toate). –  > Por Phluks.
  • Sau îl puteți porni cu gitg --all, , dacă doriți să evitați să vă încurcați în meniul derulant. –  > Por imolit.
Sardathrion – împotriva abuzurilor SE

Un instrument frumos bazat pe web este ungit. Acesta rulează pe orice platformă pe care node.js & git suportă. Există o video a modului în care funcționează pentru cei cărora le este mai ușor să facă acest lucru decât să citească…

Frank Osterfeld

Am găsit „git-big-picture” destul de util: https://github.com/esc/git-big-picture

Creează grafice 2D destul de frumoase folosind dot/graphviz în loc de vizualizările mai degrabă liniare, „unidimensionale” pe care le produc gitk și prietenii. Cu opțiunea -i, arată punctele de ramificare și comiterile de fuziune, dar lasă la o parte tot ce se află între ele.

Comentarii

  • Destul de simplu de utilizat, dacă nu aveți multe comenzi și doriți o soluție simplă, poate ar putea fi încercat. –  > Por wiswit.
  • Ar trebui să se adapteze foarte bine la numărul de comenzi (dacă folosiți -i), ar putea deveni ilizibil dacă aveți ramuri și fuziuni complexe (dar atunci, care instrument nu are) – –  > Por Frank Osterfeld.
  • Cu proiectul nostru de scară medie, acest lucru generează o imagine uriașă cu tone de linii. Pot să limitez adâncimea la care ajunge? De exemplu, comenzi din ultimele N zile sau cam așa ceva. –  > Por Ondra Žižka.
stroyer

Aruncați o privire la BranchMaster.

L-am scris pentru a vizualiza o structură complexă a ramurilor, prin reducerea la o singură linie a tuturor angajărilor dintre ele. Numerele indică numărul de comenzi.

Comentarii

  • Aceasta este ceea ce caut. Există comenzi/instrumente alternative pentru a face acest lucru? –  > Por Aalex Gabi.
  • @AalexGabi Pune asta în gitconfig, face același lucru, dar în linia de comandă gbranch = log –graph –simplify-by-decoration –pretty=format:’%C(yellow)%h%C(white)%d %C(bold black)%ar %C(reset)%n’ –all –  > Por kracejic.
  • Cum obțineți datele pentru a vizualiza ramurile? –  > Por Snowfish.
  • Singura mea problemă cu aplicația ta este că funcționează, dar nu pot repoziționa nodurile sau derula. –  > Por FilBot3.
cabluri

Nimeni nu a menționat tig? Nu pliază ramurile ca „BranchMaster”, dar…

Este rapid, rulează în terminal.

Pentru că este atât de rapid (+ control de la tastatură), obțineți un UX grozav,este aproape ca și cum ar fi „ls” pentru directoarele care conțin depozite git.

https://jonas.github.io/tig/

Are comenzile rapide obișnuite, / pentru căutare, etc.

(ps. este terminalul din fundalul acestei capturi de ecran, arată mai bine în zilele noastre, dar calculatorul meu refuză să facă o captură de ecran, îmi pare rău)

(pps. Folosesc și eu gitkraken și are vizualizări foarte clare, dar este mult mai greu decât tig)

Comentarii

  • Sunt un iubitor de terminale, iar Tig(text-mode interface for Git) este un instrument bun pentru a interacționa cu depozitele Git, este foarte util, inclusiv vizualizarea grafică și istoricul Git. Îl recomand iubitorilor de terminale ca un instrument suplimentar la linia de comandă Git. –  > Por hermeslm.
Renat

Giggle desenează grafice foarte frumoase.

Comentarii

  • La fel și Grittle, , dacă folosiți OmniGraffle –  > Por Noul Alexandria.
  • Am încercat și văd o linie pe commit și nu o linie pe ramură/tag. E prea detaliat când ai zeci de ramuri/tag-uri. –  > Por Aalex Gabi.
cSn

Tortoise Git are un instrument numit „Revision Graph”. Dacă sunteți pe Windows este la fel de simplu ca și cum ați da click dreapta pe repo-ul vostru –> Tortoise Git –> Revision Graph.

Comentarii

  • ce caracteristică fantastică, folosesc tortoise git de mult timp, dar nu cunosc această caracteristică. –  > Por kreamik.
  • Acest lucru este mult mai simplu. Mulțumesc. –  > Por Anoop.
Edward Tan

Pentru utilizatorii de Mac, verificați (fără joc de cuvinte) instrumentul gratuit și open source GitUp: http://gitup.co/

Îmi place modul în care sunt afișate graficele, este mai clar decât alte instrumente pe care le-am văzut.

Proiectul este aici: https://github.com/git-up/GitUp

Comentarii

  • Acesta este singurul grafic în care se văd ramurile pe axa x și timpul pe axa y. Este foarte intuitiv. GitUp este absolut grozav! macOS nu mai este, așa că trec la Windows și voi simți foarte mult lipsa lui GitUp. –  > Por w00t.
Lokist

Folosesc următoarele pseudonime.

[alias]
    lol = log --graph --decorate --pretty=oneline --abbrev-commit
    lola = log --graph --decorate --pretty=oneline --abbrev-commit --all

Are mai multe informații în schema de culori decât aliasurile pe care le-am văzut mai sus. De asemenea, pare să fie destul de comun, așa că s-ar putea să ai o șansă să existe în mediul altora sau să poți să-l menționezi în conversație fără a fi nevoit să explici.

Cu capturi de ecran și o descriere completă aici:http://blog.kfish.org/2010/04/git-lola.html

Eugene Yarmash

Eu am acest lucru git log alias în ~/.gitconfig pentru a vizualiza istoricul graficului:

[alias]
l = log --all --graph --pretty=format:'%C(auto)%h%C(auto)%d %s %C(dim white)(%aN, %ar)'

Cu aliasul în loc, git l va afișa ceva de genul acesta:

În Git 2.12+ puteți chiar să personalizați culorile liniilor graficului folosind opțiunea log.graphColors opțiunea de configurare.

În ceea ce privește formatul jurnalelor, acesta este similar cu --oneline, , la care se adaugă opțiunea numele autorului (respectând .mailmap) și data autorului relativ. Rețineți că %C(auto) care îi spune lui Git să folosească culorile implicite pentru hash-ul de confirmare etc. este acceptată în Git >= 1.8.3.

Comentarii

  • Este prima dată când văd data reală a autorului și este destul de drăguț! mulțumesc, voi adăuga asta la gitconfig-ul meu! –  > Por Simon C..
  • utilizatorii de Windows ar trebui să înlocuiască ghilimelele simple cu ghilimele duble –  > Por pierDipi.
Sadegh

Am găsit această postare pe blog care arată o modalitate concisă:

git log --oneline --abbrev-commit --all --graph --decorate --color

De obicei, eu creez un alias pentru comanda de mai sus:

alias gl='git log --oneline --abbrev-commit --all --graph --decorate --color'

și pur și simplu folosesc doar gl.

De asemenea, puteți adăuga aliasul la git config . Deschideți ~/.gitconfig și adăugați următoarea linie la [alias]

[alias]
        lg = log --oneline --abbrev-commit --all --graph --decorate --color

și utilizați-o astfel: git lg

pylang

Pentru cei care utilizează editor de text VSCode, , luați în considerare opțiunea extensia Git History Extension de D. Jayamanne:

Comentarii

  • această extensie este cam lentă în opinia mea. De asemenea, nu se actualizează automat și pare neșlefuită. Dar face o treabă bună în vizualizarea arborelui de comenzi… –  > Por aljazerzen.
  • O altă extensie pentru Visual Studio Code este Git Graph de mhutchie. Eu folosesc acest lucru împreună cu GitLens. –  > Por Josef.B.
kEND

Gitx este, de asemenea, un instrument de vizualizare fantastic dacă se întâmplă să fiți pe OS X.

Comentarii

  • gitk (pentru toată lumea) este foarte asemănător. nu exact la fel, dar destul de asemănător. –  > Por xero.
  • Există câteva furci ale lui Gitx – acesta (rowanj) pare a fi cel mai bun în acest moment. –  > Por rjmunro.
xero

Aliasul meu preferat, prin .gitconfig, este:

graph = log --graph --color --all --pretty=format:"%C(yellow)%H%C(green)%d%C(reset)%n%x20%cd%n%x20%cn%x20(%ce)%n%x20%s%n"

Comentarii

  • O mică explicație despre cum va arăta comanda ar fi fost grozavă. –  > Por Max.
David

O altă comandă git log. Aceasta cu coloane cu lățime fixă:

git log --graph --pretty=format:"%x09%h | %<(10,trunc)%cd |%<(25,trunc)%d | %s" --date=short

Frederik Struck-Schøning

Verifică SmartGit. Îmi amintește foarte mult de TortoiseHg și este gratuită pentru utilizare necomercială.

loneshark99

Pe Windows există o unealtă foarte utilă pe care o puteți folosi : git extensions. Este o unealtă gui și face operațiile git foarte ușoare.

De asemenea, este open sourced.

http://gitextensions.github.io

pixel

putem să o facem mai complicată?

Ce zici de simplegit log –all –decorate –oneline –graph (țineți minte A Dog = –All –Decorate –Oneline –Graph)

Comentarii

  • Acesta este același lucru ca și răspunsul acceptat. Cu toate acestea, pentru mnemotehnică –  > Por aljgom.
onemorequestion

Cele mai bine cotate răspunsuri arată git log comenzi ca soluții preferate.

Dacă aveți nevoie de un tabel ca, , să zicem coloană ca ieșire, puteți utiliza comenzile dvs. minunate de jurnal git cu ușoare modificări și unele limitări cu .gitconfig alias.tably de mai jos.

Modificări:

  • trebuie să utilizați %><(<N>[,ltrunc|mtrunc|trunc]) înainte de fiecare locțiitor de commit
  • adăugați un delimitator unic ca separator de coloane
  • adăugați --color opțiunea pentru ieșire colorată

Limitări:

  • puteți plasa graficul git la fiecare coloană, atâta timp cât nu utilizați linii de noutate care nu sunt goale. %n...
  • se poate utiliza ultimul marcaj de confirmare al oricărei linii noi fără%><(<N>[,trunc])
  • dacă sunt necesare caractere suplimentare pentru decorare, cum ar fi (committer:, , < și >) în

    ...%C(dim white)(committer: %cn% <%ce>)%C(reset)...

    pentru a obține o ieșire asemănătoare unui tabel, acestea trebuie scrise direct înainte și după locul de confirmare.

    ...%C(dim white)%<(25,trunc)(committer: %cn%<(25,trunc) <%ce>)%C(reset)...

  • în cazul în care --format=format: nu este ultima opțiune, închideți-o cu %C(reset) așa cum se face în general

  • în comparație cu ieșirea normală a jurnalului git, aceasta este lentă, dar plăcută.

Exemplu preluat de pe acest site:

thompson1     = log --all --graph --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(auto)%d%C(reset)'

va fi cu ^ ca delimitator și fără caractere adăugate

thompson1-new = log --all --graph --color --abbrev-commit --decorate --format=format:'^%C(bold blue)%<(7,trunc)%h%C(reset)^%C(bold green)%<(21,trunc)%ar%C(reset)^%C(white)%<(40,trunc)%s%C(reset)^%C(dim white)%<(25,trunc)%an%C(reset)^%C(auto)%d%C(reset)'

care se compară ca

sau cu mutarea graficului în coloana 5

Pentru a realiza acest lucru, adăugați următoarele la .gitconfig și apelați aliasul de jurnal cu git tably YourLogAlias

[color "decorate"]
    HEAD = bold blink italic 196
    branch = 214
    tag = bold 222

[alias]

    # delimiter used as column seperator
    delim = ^
    # example thompson1
    thompson1     = log --all --graph         --abbrev-commit --decorate --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(auto)%d%C(reset)'
    # modified thompson1 example
    thompson1-new = log --all --graph --color --abbrev-commit --decorate --format=format:'^%C(bold blue)%<(7,trunc)%h%C(reset)^%C(bold green)%<(21,trunc)%ar%C(reset)^%C(white)%<(40,trunc)%s%C(reset)^%C(dim white)%<(25,trunc)%an%C(reset)^%C(auto)%d%C(reset)'
    # set a column for the graph
    thompson1-new-col = 1

tably     = !bash -c '"                                                                                                              
              declare -A col_length;                                                                                                 
              delim=$(git config alias.delim);                                                                                       
              git_log_cmd=$(git config alias.$1);                                                                                    
              git_tre_col=${2:-$(git config alias.$1-col)};                                                                          
                                                                                                                                     
              i=0;                                                                                                                   
              n=0;                                                                                                                   
              while IFS= read -r line; do                                                                                            
                ((n++));                                                                                                             
                while read -d"$delim" -r col_info;do                                                                               
                  ((i++));                                                                                                           
                  [[ -z "$col_info" ]] && col_length["$n:$i"]=${col_length["${last[$i]:-1}:$i"]} && ((i--)) && continue;       
                  [[ $i -gt ${i_max:-0} ]] && i_max=$i;                                                                              
                  col_length["$n:$i"]=$(grep -Eo "\([0-9]*,[lm]*trunc\)" <<< "$col_info" | grep -Eo "[0-9]*" | head -n 1); 
                  [[ -n "${col_length["$n:$i"]}" ]] && last[$i]=$n;                                                              
                  chars_extra=$(grep -Eo "\trunc\).*" <<< "$col_info");                                                        
                  chars_extra=${chars_extra#trunc)};                                                                                 
                  chars_begin=${chars_extra%%\%*};                                                                                  
                  chars_extra=${chars_extra#*\%};                                                                                   
                  case " ad aD ae aE ai aI al aL an aN ar as at b B cd cD ce cE ci cI cl cL cn cN cr                                
                          cs ct d D e f G? gd gD ge gE GF GG GK gn gN GP gs GS GT h H N p P s S t T " in                            
                   *" ${chars_extra:0:2} "*)                                                                                       
                     chars_extra=${chars_extra:2};                                                                                   
                     chars_after=${chars_extra%%\%*};                                                                               
                     ;;                                                                                                              
                   *" ${chars_extra:0:1} "*)                                                                                       
                     chars_extra=${chars_extra:1};                                                                                   
                     chars_after=${chars_extra%%\%*};                                                                               
                     ;;                                                                                                              
                   *)                                                                                                                
                     echo "No Placeholder found. Probably no tablelike output.";                                                   
                     continue;                                                                                                       
                     ;;                                                                                                              
                  esac ;                                                                                                             
                  if [[ -n "$chars_begin$chars_after" ]];then                                                                      
                    len_extra=$(echo "$chars_begin$chars_after" | wc -m);                                                          
                    col_length["$n:$i"]=$((${col_length["$n:$i"]}+$len_extra-1));                                                    
                  fi;                                                                                                                
                                                                                                                                     
                done <<< "${line#*=format:}$delim";                                                                                
                i=1;                                                                                                                 
              done <<< "$(echo -e "${git_log_cmd//\%n/\
}")";                                                                
                                                                                                                                     
              while IFS= read -r graph;do                                                                                            
                chars_count=$(sed -nl1000 "l" <<< "$graph" | grep -Eo "\\\\\\\\|\||\/|\ |\*|_" | wc -l);           
                [[ ${chars_count:-0} -gt ${col_length["1:1"]:-0} ]] && col_length["1:1"]=$chars_count;                               
              done < <([[ -n "$(grep -F graph <<< "$git_log_cmd")" ]] && git log --all --graph --pretty=format:" " && echo);   
                                                                                                                                     
              l=0;                                                                                                                   
              while IFS= read -r line;do                                                                                             
                c=0;                                                                                                                 
                ((l++));                                                                                                             
                [[ $l -gt $n ]] && l=1;                                                                                              
                while IFS= read -d"$delim" -r col_content;do                                                                       
                  ((c++));                                                                                                           
                  if [[ $c -eq 1 ]];then                                                                                             
                    [[ -n "$(grep -F "*" <<< "$col_content")" ]] || l=2;                                                       
                    chars=$(sed -nl1000 "l" <<< "$col_content" | grep -Eo "\\\\\\\\|\||\/|\ |\*|_" | wc -l);       
                    whitespaces=$((${col_length["1:1"]}-$chars));                                                                    
                    whitespaces=$(seq -s" " $whitespaces|tr -d "[:digit:]");                                                     
                    col_content[1]="${col_content[1]}$col_content$whitespaces
";                                                  
                  else                                                                                                               
                    col_content[$c]="${col_content[$c]}$(printf "%-${col_length["$l:$c"]}s" "${col_content:-""}")
";      
                  fi;                                                                                                                
                done <<< "$line$delim";                                                                                            
                for ((k=$c+1;k<=$i_max;k++));do                                                                                      
                  empty_content="$(printf "%-${col_length["$l:$k"]:-${col_length["${last[$k]:-1}:$k"]:-0}}s" "")";         
                  col_content[$k]="${col_content[$k]}$empty_content
";                                                            
                done;                                                                                                                
              done < <(git $1 && echo);                                                                                              
                                                                                                                                     
              while read col_num;do                                                                                                  
                if [[ -z "$cont_all" ]];then                                                                                       
                  cont_all=${col_content[$col_num]};                                                                                 
                else                                                                                                                 
                  cont_all=$(paste -d" " <(echo -e "$cont_all") <(echo -e "${col_content[$col_num]}"));                        
                fi;                                                                                                                  
              done <<< $(seq 2 1 ${git_tre_col:-1};seq 1;seq $((${git_tre_col:-1}+1)) 1 $i_max);                                     
              echo -e "$cont_all";                                                                                                 
              "' "git-tably"

Acesta este mai mult sau mai puțin doar o parte din răspunsul meu https://stackoverflow.com/a/61487052/8006273 unde puteți găsi explicații mai profunde, dar se potrivește frumos la această întrebare și aici.

Dacă există probleme cu comenzile git log, lăsați un comentariu.

Isaac To

Am încercat --simplify-by-decoration dar toate fuziunile mele nu sunt afișate. Așa că, în schimb, am tăiat doar liniile fără simbolurile „
și „/” la antet, păstrând întotdeauna liniile cu „(” care indică ramurile imediat după aceea. Atunci când se afișează istoricul ramurilor, în general nu mă interesează comentariile de confirmare, așa că le elimin și pe acestea. Am ajuns să am următorul alias de shell.

gbh () { 
    git log --graph --oneline --decorate "[email protected]" | grep '^[^0-9a-f]*[\/][^0-9a-f]*( [0-9a-f]|$)|^[^0-9a-f]*[0-9a-f]* (' | sed -e 's/).*/)/'
}

klm123

Eu folosesc Visual Studio Code editor, și m-am trezit foarte mulțumit de extensia Git Graph a acestuia, realizată de mhutchie. (Și nu sunt singurul, există 1 milion de utilizatori ai extensiei!).

Dacă vi s-a întâmplat să vă placă editorul, atunci mergeți la fila de extensii (cubulețele din partea stângă din mijloc) și tastați „Git Graph” și instalați

Pentru a o utiliza, mergeți la fila de control git și apăsați butonul View Git Graph

rookie4evr

Site-ul oficial Git a înrolat câteva instrumente GUI specifice platformei terțe. Apăsați aiciInstrumente GUI git pentru platforma Linux

Eu am folosit gitg și GitKraken pentru platforma Linux. Ambele sunt bune pentru a înțelege arborele de comitere

Tags: