Visualiserende taktopologie in Git

Ik speel met git geïsoleerd op mijn eigen machine, en ik vind het moeilijk om een ​​mentaal model van al mijn takken te behouden en te committen. Ik weet dat ik een git logkan doen om de begaangeschiedenis te zien van waar ik ben, maar is er een manier om de hele taktopografie te zien, zoiets als deze ASCII-kaarten die overal lijken te worden gebruikt om uit te leggen takken?

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

Het voelt gewoon alsof er iemand langs komt en probeert mijn repository op te halen, zou moeite hebben om precies uit te werken wat er aan de hand was.

Ik denk dat ik beïnvloed door Accurov’s Stream browser


1, Autoriteit 100%

Gebruik git log --graphof gitk. (Beide accepteren ook --all, die alle takken zullen tonen in plaats van alleen de huidige.)

Probeer:

voor filiaalnamen en een compacte weergave,

git log --graph --decorate --oneline

2, Autoriteit 43%

Ik gebruik meestal

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

met kleuren (als uw shell bash is):

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

Hiermee drukt u tekst-gebaseerde weergave als volgt af:

* 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

(U kunt gewoon git log --format=onelinegebruiken, maar het zal binden met commit-berichten aan cijfers, die er minder mooie IMHO uitziet).

Om een ​​snelkoppeling te maken voor deze opdracht, wilt u mogelijk uw ~/.gitconfigbestand bewerken:

[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"

Echter, zoals sodelleren de luidruchtige notities in de opmerkingen, zo’n lange opmaakopdracht is moeilijk te onthouden . Meestal is het geen probleem, omdat u het in de ~/.gitconfig-bestand kunt plaatsen. Als u echter soms moet inloggen op een externe machine waarin u het configuratie-bestand niet kunt wijzigen, kunt u een eenvoudiger maar sneller gebruiken om versie te typen:

git log --graph --oneline

3, Autoriteit 42%

Ik heb 3 aliassen (en 4 alias-aliassen voor snel gebruik) dat ik normaal in mijn ~/.gitconfigbestand gooi:

[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 lg1ziet er als volgt uit:

git lg2ziet er als volgt uit:

en git lg3ziet er als volgt uit:

Er moet op worden opgemerkt dat dit niet bedoeld is als een eind-all-be-all-oplossing – het is een sjabloon voor u om te veranderen, voeg toevoegen aan en repareer uw voorkeur. Als u deze wilt gebruiken, is mijn aanbeveling:

  1. voeg ze toe aan uw .gitconfig,
  2. Pas aan uw voorkeur aan (verschillende kleurenkeuzes, verschillende lijnregelingen voor de 2- en 3-lijnsversies, enz.),
  3. en sla vervolgens een kopie op naar een GIST- of andere CODE-snippet-tool zodat u kunt kopiëren & amp; Plak het in .gitconfigS In de toekomst (of alternatief versie bedient uw dotfiles natuurlijk) .

OPMERKING: Antwoord gekopieerd van en verbeterd op het antwoord op Stackoverflow.com/Questions/1057564/pretty-git-branch-graphs Omdat het hier veel passend is dan het was er. & NBSP; & NBSP; verliet de kopie op de andere vraag om historische redenen – het is nu gesloten en Het antwoord wordt verwezen door een stel andere antwoorden.


4, Autoriteit 7%

De uitvoer van Gitk is soms pijnlijk voor mij om te lezen:

Het motiveerde me om te schrijven gitversiontree :


5, Autoriteit 5%

Bekijk GitKraken– een platformonafhankelijke GUI die de topologie op een heldere manier laat zien.

Hier is een korte videozelfstudieover enkele geavanceerde functies.

Opmerking: registratie is vereist.


Antwoord 6, autoriteit 4%

99,999% van mijn tijd kijkt naar de geschiedenis door git lgen de 0,001% is door git log.

Ik wil alleen twee log-aliassen delen die nuttig kunnen zijn (configureren vanuit .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 lgzal de huidige filiaalgeschiedenis zien.
  • git histzal de hele filiaalgeschiedenis zien.

Antwoord 7, autoriteit 4%

Ik vind het leuk om met git logte doen :

git log --graph --oneline --branches

(ook met –all, om ook vertakkingen te bekijken)

Werkt met recente Git-releases: geïntroduceerd sinds 1.6.3(Do 7 mei 2009)

  • --pretty=<style>” optie voor de log-familie van commando’s kan nu worden gespeld als “--format=<style>“.
    Bovendien is --format=%formatstringeen afkorting voor --pretty=tformat:%formatstring.

  • --oneline” is een synoniem voor “--pretty=oneline --abbrev-commit“.

PS D:\git\tests\finalRepo> 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

Je kunt ook de spanwijdte van de logweergave (aantal commits) beperken:

PS D:\git\tests\finalRepo> 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

(toon alleen de laatste 5 commits)


Wat ik niet leuk vind aan de huidige geselecteerde oplossing is:

git log --graph

Het gaf veel te veel informatie weer (als ik alleen naar een korte samenvatting wil kijken):

PS D:\git\tests\finalRepo> 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
|

gitkis geweldig, maar dwingt me om de shell-sessie te verlaten voor een ander venster, terwijl het snel weergeven van de laatste n commits vaak genoeg is.


Antwoord 8, autoriteit 3%

Gitgis een geweldige tool voor Linux, vergelijkbaar met Gitx voor OS X. Gewoon uitvoeren ‘gitg’ op de opdrachtregel van ergens in de boomstructuur van je repository (hetzelfde met gitx).


Antwoord 9, autoriteit 2%

Ik vond git-big-picturebest handig.

Het maakt mooie 2D-grafieken met dot/Graphvizin plaats van het nogal lineaire, “one -dimensionale” weergaven gitken vrienden produceren. Met de -ioptie toont het de vertakkingspunten en merge commits, maar laat alles daartussen weg.


Antwoord 10, autoriteit 2%

Een leuke webgebaseerde tool is ungit. Het draait op elk platform dat Node.jsen Git ondersteunt. Er is een videovan hoe het werkt voor degenen die dat soort dingen makkelijker dan lezen…


Antwoord 11, autoriteit 2%

Bekijk BranchMaster.

Ik heb het geschreven om een complexe vertakkingsstructuur te visualiseren, door alle commits ertussen samen te vouwen tot een enkele regel. De cijfers geven het aantal commits aan.


Antwoord 12, autoriteit 2%

Er is ook Tig. Het vouwt geen takken zoals “BranchMaster”, maar…

Het is snel, draait in de terminal.

Omdat het zo snel (+ toetsenbordbediening) is, krijg je een geweldige UX. Het is bijna hetzelfde als mijn “ls” voor mappen die Git-repositories bevatten.

Het heeft de gebruikelijke sneltoetsen, /om te zoeken, enz.

(PS: Het is de terminal op de achtergrond van deze schermafbeelding. Het ziet er tegenwoordig beter uit, maar mijn computer weigert een schermafbeelding te maken, sorry)

(PPS: ik gebruik ook GitKrakenen het heeft echt duidelijke visualisaties, maar het is veel zwaarder dan Tig)


Antwoord 13

Giggletekent hele mooie grafieken.


Antwoord 14

Voor Mac-gebruikers, bekijk (geen woordspeling bedoeld) de gratis, open source tool GitUp.

Ik hou van de manier waarop de grafieken worden weergegeven. Het is duidelijker dan sommige andere tools die ik heb gezien.

Het project is op GitHub.


Antwoord 15

tortoisegit heeft een tool genaamd “Revision Grafiek”. Als u op Windows bent, is het net zo eenvoudig als met de rechtermuisknop op uw repository → Tortoise Git Revisiegrafiek .


16

Ik gebruik de volgende aliassen.

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

Het heeft meer informatie in het kleurenschema dan aliassen die ik hierboven zag. Het lijkt ook vrij gebruikelijk te zijn, dus je hebt misschien een kans om het in de omgeving van anderen te bestaan ​​of het in gesprek te kunnen vermelden zonder het te moeten uitleggen.

Met screenshots en een volledige beschrijving in git lola .


17

Ik heb dit git logalias in ~/.gitconfigom de grafiekgeschiedenis te bekijken:

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

Met de alias op zijn plaats, git ltoont zoiets:

in git 2.12 + u kunt Stel zelfs de lijnkleuren van de grafiek aan met behulp van de log.graphColorsConfiguration-optie.

Het formaat van de logs is vergelijkbaar met --oneline, met de toevoeging van de naam van de auteur(met respect voor .mailmap) en de relatieve auteurdatum. Merk op dat de syntaxis %C(auto), die Git vertelt om de standaardkleuren te gebruiken voor commit-hash, enz., wordt ondersteund in Git >= 1.8.3.


Antwoord 18

Ik heb dit gevonden blogpostdie een beknopte manier laat zien:

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

Ik maak meestal een alias aan voor het bovenstaande commando:

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

En gebruik gewoon gl.

Je kunt de alias ook toevoegen aan de Git-configuratie. Open bestand ~/.gitconfigen voeg de volgende regel toe aan de sectie [alias]:

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

En gebruik het als volgt:

git lg

Antwoord 19

Voor degenen die de VSCode-teksteditorgebruiken, overweeg dan de Git History Extensiondoor D. Jayamanne:


Antwoord 20

Gitx is ook een fantastische visualisatietool als je toevallig OS X gebruikt.


Antwoord 21

Mijn persoonlijke favoriete alias, via .gitconfig, is:

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"

Antwoord 22

Nog een git log-opdracht. Deze met kolommen met vaste breedte:

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

Antwoord 23

Bekijk SmartGit. Het doet me erg denken aan de TortoiseHg-filiaalvisualisatie en het is gratis voor niet-commercieel gebruik.


Antwoord 24

Op Windows is er een zeer handige tool die je kunt gebruiken: Git Extensions. Het is een GUI-tool en maakt Git-bewerkingen erg gemakkelijk.

Het is ook open source.


Antwoord 25

De meest gewaardeerde antwoorden tonen git log-opdrachten als favoriete oplossingen.

Als je een tablelike, zeg maar kolomachtige output nodig hebt, kun je je geweldige git logcommando’s gebruiken met kleine aanpassingen en enkele beperkingen met de .gitconfig alias.tablyfragment hieronder.

Aanpassingen:

  • je moet %><(<N>[,ltrunc|mtrunc|trunc])gebruiken voor elke tijdelijke aanduiding voor een commit
  • voeg een uniek scheidingsteken toe als kolomscheidingsteken
  • voeg de optie --colortoe voor gekleurde uitvoer

Beperkingen:

  • je kunt de CPU-grafiek bij elke kolom plaatsen, zolang je geen niet-lege nieuwe regels gebruikt %n...

  • de laatste plaatsaanduiding voor een nieuwe regel kan worden gebruikt zonder
    %><(<N>[,trunc])

  • als er extra tekens nodig zijn voor decoratie zoals (committer: , <en >)in

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

    om een tabelachtige uitvoer te krijgen, moeten ze direct voor en na de tijdelijke aanduiding voor de commit worden geschreven

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

  • als de optie --format=format:niet de laatste is, sluit deze dan met %C(reset)zoals meestal gedaan

  • vergeleken met de normale git log-uitvoer is deze traag, maar leuk

Voorbeeldovergenomen van deze 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)'

zal zijn met ^als scheidingsteken en zonder toegevoegde tekens

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)'

wat vergelijkbaar is met

Of door de grafiek naar kolom 5 te verplaatsen:

Om dit te bereiken, voegt u het volgende toe aan uw .gitconfig-bestand en roept u uw log-alias aan met
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/\\\\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\n\";                                                  \
                  else                                                                                                               \
                    col_content[$c]=\"${col_content[$c]}$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\n\";      \
                  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\n\";                                                            \
                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"

Dit is min of meer slechts een deel van mijn antwoord https://stackoverflow.com/a/61487052/8006273waar je diepere uitleg kunt vinden, maar past ook hier goed bij deze vraag.

Als er problemen zijn met je git logcommando’s, laat dan een reactie achter.


Antwoord 26

Ik gebruik de visuele studio-code editor, en ik vond mezelf erg blij met de Git Grafiek verlenging ervan, gemaakt door Mhutchie. (En ik ben niet alleen, er zijn 1 miljoen gebruikers van de extensie!).

Als u toevallig de editor houdt, ga dan naar het tabblad Extensie (de ligboxen in het midden van het midden) en typ het “GIT-grafiek” en installeer

Ga naar het tabblad GIT-besturing en druk op de knop GIT GIFTIER


27

Ik heb het --simplify-by-decorationmaar al mijn fucten worden niet getoond. Dus snoei ik in plaats daarvan voor lijnen met nee “\” en “/” -symbolen bij de koptekers, terwijl het altijd lijnen bijhoudt met “(” takken meteen daarna aan takken. Bij het tonen van de takgeschiedenis, ben ik in het algemeen ongeïnteresseerd in commentaar van commentaar, dus Ik verwijder ze ook. Ik eindig met de volgende Shell Alias.

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

28

Ik wil mijn compactPRESET VOOR git logopdracht:
(groen is mijn standaardconsole kleur)

Het is ontworpen om zo compact en tabelachtig mogelijk te zijn (zonder overtollige ruimtes toe te voegen) terwijl ze nog steeds informatief en gemakkelijk te lezen zijn. Dit is eigenlijk een compacte versie van mediumFORMATION GIT gebruikt standaard.

Kenmerken:

  • vaste itemposities;
  • Standaardkleuren van plegen hash en ref-namen;
  • BEGIN-auteur datum is in lokale tijdzone;
  • Boekbericht is gewikkeld op 128 tekens en ingesprongen;
  • Extended Commit-bericht wordt ook (indien aanwezig) weergegeven met eventuele trailing-newlines verwijderd.

U kunt het toevoegen aan uw config-bestand met deze opdrachten:
(Merk op dat ze het datumformaat voor alle git logFormattes!)

wijzigen

$ git config --global log.date 'format-local:%d %b %Y %H:%M'
$ git config --global pretty.compact '%C(auto)%h %C(cyan)%<(17,trunc)%an%C(auto) %D%n        %C(cyan)%ad%C(auto) %w(128,0,26)%s%w(0,0,26)%+b%-(trailers:key=FAKE)'

… en gebruik het dan zo (met --graph, --allof andere opties):

$ git log --graph --pretty=compact

Als u het ook wilt maken, kunt u dit doen met deze opdracht:

$ git config --global format.pretty compact

of als u van aliassen houdt:

$ git config --global alias.logc "log --date=format-local:'%d %b %Y %H:%M' --pretty='%C(auto)%h %C(cyan)%<(17,trunc)%an%C(auto) %D%n        %C(cyan)%ad%C(auto) %w(128,0,26)%s%w(0,0,26)%+b%-(trailers:key=FAKE)'"

Als u wijzigingen wilt aanbrengen, bekijk dan de behartigen sectie van git logreferentie.


29

Officiële site van Git heeft een aantal specifiek GUI-gereedschap van de derde partij ingeschakeld. Open git GUI-hulpmiddelen voor Linux-platform .

Ik heb gitgen gitkraken voor het Linux-platform . Beide zijn goed voor het begrijpen van de plattegrond.

Other episodes