漂亮的git分支图

时间：2009-06-29 10:12:28

标签： git git-log

我看过一些书籍和文章有一些看起来很漂亮的git分支和提交图。如何制作git历史的高质量可打印图像？

35 个答案:

答案 0 :(得分：1678)

更新：这个答案得到了应有的关注。它最初发布是因为我认为图形看起来不错，它们可以在Illustrator中用于出版物 - 并且没有更好的解决方案。但现在存在更多适用于此Q的答案，例如fracz，Jubobs'或Harry Lee！请继续投票!!

更新2：我已经在Visualizing branch topology in git问题上发布了这个答案的改进版本，因为它更合适。该版本包含 lg3 ，它显示了作者和提交者信息，所以你真的应该检查出来。将这个答案留给历史（＆amp; rep，我会承认）的原因，虽然我真的很想删除它。

2¢：我通常会在~/.gitconfig文件中输入两个别名：

[alias]
lg1 = 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(bold yellow)%d%C(reset)' --all
lg2 = 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 yellow)%d%C(reset)%n''          %C(white)%s%C(reset) %C(dim white)- %an%C(reset)' --all
lg = !"git lg1"

git lg / git lg1看起来像这样：
git lg1

和git lg2看起来像这样：
git lg2

答案 1 :(得分：862)

这里的许多答案都很棒，但是对于那些只需要一个简单的一行到点答案的人而不必设置别名或任何额外的，这里是：

git log --all --decorate --oneline --graph

不是每个人都会一直git log做一次，但是当你需要它时，请记住：

  

“ A Dog ”= git log - a ll - d ecorate - o neline - 的克拍摄和

enter image description here

答案 2 :(得分：310)

对于文字输出，您可以尝试：

git log --graph --abbrev-commit --decorate --date=relative --all

或：

git log --graph --oneline --decorate --all

或：here's  用于绘制DAG图的graphviz别名。

我个人使用gitx，gitk --all和gitnub。

答案 3 :(得分：207)

Gitgraph.js允许在没有存储库的情况下绘制漂亮的git分支。只需编写一个Javascript代码，用于配置您的分支和提交，并在浏览器中呈现它。

var gitGraph = new GitGraph({
   template: "blackarrow",
   mode: "compact",
   orientation: "horizontal",
   reverseArrow: true
});

var master = gitGraph.branch("master").commit().commit();
var develop = gitGraph.branch("develop").commit();
master.commit();
develop.commit().commit();
develop.merge(master);

sample graph generated with Gitgraph.js

或使用metro模板：

GitGraph.js metro theme

或使用提交消息，作者和标签：

GitGraph with commit messages

使用JSFiddle进行测试。

使用Git Grapher通过@bsara生成它。

答案 4 :(得分：109)

构建于TikZ & PGF之上，gitdags是一个小型的LaTeX软件包，可以让您毫不费力地生成矢量图形提交图等等。

自动生成现有存储库的提交图是而不是 gitdags的目的;它生成的图表仅用于教育目的。

我经常使用它为我对Git问题的答案生成图表，作为ASCII提交图的替代方法：

以下是一个展示简单rebase影响的图表示例：

enter image description here 

\documentclass{article}

\usepackage{subcaption}
\usepackage{gitdags}

\begin{document}

\begin{figure}
  \begin{subfigure}[b]{\textwidth}
    \centering
    \begin{tikzpicture}
      % Commit DAG
      \gitDAG[grow right sep = 2em]{
        A -- B -- { 
          C,
          D -- E,
        }
      };
      % Tag reference
      \gittag
        [v0p1]       % node name
        {v0.1}       % node text
        {above=of A} % node placement
        {A}          % target
      % Remote branch
      \gitremotebranch
        [origmaster]    % node name
        {origin/master} % node text
        {above=of C}    % node placement
        {C}             % target
      % Branch
      \gitbranch
        {master}     % node name and text 
        {above=of E} % node placement
        {E}          % target
      % HEAD reference
      \gitHEAD
        {above=of master} % node placement
        {master}          % target
    \end{tikzpicture}
    \subcaption{Before\ldots}
  \end{subfigure}

  \begin{subfigure}[b]{\textwidth}
    \centering
    \begin{tikzpicture}
      \gitDAG[grow right sep = 2em]{
        A -- B -- { 
          C -- D' -- E',
          {[nodes=unreachable] D -- E },
        }
      };
      % Tag reference
      \gittag
        [v0p1]       % node name
        {v0.1}       % node text
        {above=of A} % node placement
        {A}          % target
      % Remote branch
      \gitremotebranch
        [origmaster]    % node name
        {origin/master} % node text
        {above=of C}    % node placement
        {C}             % target
      % Branch
      \gitbranch
        {master}      % node name and text 
        {above=of E'} % node placement
        {E'}          % target
      % HEAD reference
      \gitHEAD
        {above=of master} % node placement
        {master}          % target
    \end{tikzpicture}
    \subcaption{\ldots{} and after \texttt{git rebase origin/master}}
  \end{subfigure}
  \caption{Demonstrating a typical \texttt{rebase}}
\end{figure}

\end{document}

答案 5 :(得分：73)

Gitg是GNOME的Gitk和GitX的克隆（它也适用于KDE等），它显示了一个非常彩色的图形。

积极开发（截至2012年）。它允许您按时间顺序或topologically对提交（图形节点）进行排序，并隐藏不会导致选定分支的提交。

适用于大型存储库和复杂的依赖关系图。

示例截图，显示了linux-git和linux-2.6存储库：

linux-git

linux-2.6

答案 6 :(得分：57)

SourceTree非常好。它打印出一个外观漂亮和中等大小的历史记录和分支图:(以下是在一个实验性的Git项目中完成，只是为了看到一些分支）。支持Windows 7+和Mac OS X 10.6 +。

enter image description here

http://www.sourcetreeapp.com/

答案 7 :(得分：56)

我刚刚编写了一个工具，可以使用HTML / Canvas生成漂亮的git提交图。

并提供一个易于使用的jQuery插件。

[github] https://github.com/tclh123/commits-graph

预览：

preview

答案 8 :(得分：53)

git-forest是一个优秀的perl脚本，我已经使用了一年多，我几乎不再使用git log命令了。

这些是我喜欢这个剧本的一些东西：

  • 它使用unicode字符在图表中绘制线条，为图形线条提供更连续的外观。
  • 您可以将--reverse与图表输出结合使用，这是常规git log命令无法实现的。
  • 它在内部使用git log来获取提交列表，因此您传递给git log的所有选项也可以传递给此脚本。

我使用git-forest的别名如下：

[alias]
tree = "forest --pretty=format:\"%C(red)%h %C(magenta)(%ar) %C(blue)%an %C(reset)%s\" --style=15 --reverse"

这是终端上输出的样子：

enter image description here

答案 9 :(得分：42)

根据我在an answer to a related question中找到的Graphviz脚本，我已经攻击了a ruby script，它创建了一个git存储库的摘要视图。它省略了所有线性历史，只是展示了有趣的＃34;提交，即具有多个父母，多个孩子或由分支或标签指向的那些。这是为jquery生成的图表的片段：

jquery sample

git-big-picture和BranchMaster是类似的工具，它们只尝试显示图表的高级结构，只显示标记，分支，合并等的相关性。

This question还有更多选择。

答案 10 :(得分：40)

我写了一个用于将git日志转换为漂亮SVG图的web工具： Bit-Booster - Offline Commit Graph Drawing Tool

将git log --pretty='%h|%p|%d'的输出直接上传到工具中，然后点击＆＃34;下载graph.svg＆＃34;链接。

该工具是纯客户端的，因此您的Git数据都不会与我的服务器共享。您还可以在本地保存HTML + JS并使用＆＃34; file：///＆＃34;运行它。网址＆＃39; S。在Ubuntu 12.04上的Chrome 48和Firefox 43上验证。

它生成的HTML可以直接发布到任何页面（包括blogspot博客引擎！）。看一下这里的一些博客文章：

http://bit-booster.blogspot.ca/

以下是该工具生成的示例HTML文件的屏幕截图：

http://bit-booster.com/graph.html（工具）

答案 11 :(得分：36)

取决于他们的样子。我使用gitx制作像这样的照片：

simple plot

您可以在24路章鱼合并中对git log --graph与gitk进行比较（最初来自http://clojure-log.n01se.net/date/2008-12-24.html）：

24-way git octopus merge. Original URL was <code>http://lwn.net/images/ns/kernel/gitk-octopus.png</code>

答案 12 :(得分：34)

我添加了三个自定义命令：git tree，git stree和git vtree。我会按顺序检查它们。

[alias]
    tree = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset) %C(auto)%d%C(reset)\n         %C(black)[%cr]%C(reset)  %x09%C(black)%an: %s %C(reset)'

enter image description here

使用git stree和git vtree我使用bash来帮助格式化。

[alias]
    logx = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset)+%C(dim black)(%cr)%C(reset)+%C(auto)%d%C(reset)++\n+++       %C(bold black)%an%C(reset)%C(black): %s%C(reset)'
    stree = !bash -c '"                                                                             \
        while IFS=+ read -r hash time branch message; do                                            \
            timelength=$(echo \"$time\" | sed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\");     \
            timelength=$(echo \"16+${#time}-${#timelength}\" | bc);                                 \
            printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"\";          \
        done < <(git logx && echo);"'

git_stree 

[alias]
    logx = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset)+%C(dim black)(%cr)%C(reset)+%C(auto)%d%C(reset)++\n+++       %C(bold black)%an%C(reset)%C(black): %s%C(reset)'
    vtree = !bash -c '"                                                                             \
        while IFS=+ read -r hash time branch message; do                                            \
            timelength=$(echo \"$time\" | sed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\");     \
            timelength=$(echo \"16+${#time}-${#timelength}\" | bc);                                 \
            printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"$message\";  \
        done < <(git logx && echo);"'

git_vtree

编辑：这适用于git版本1.9a。颜色值'auto'显然是在这个版本中首次亮相。这是一个很好的补充，因为分支名称将获得不同的颜色。这样可以更容易区分本地和远程分支。

答案 13 :(得分：30)

有关更详细的文字输出，请尝试：

git log --graph --date-order -C -M --pretty=format:"<%h> %ad [%an] %Cgreen%d%Creset %s" --all --date=short

您可以在$ HOME / .gitconfig

中编写别名 
[alias]
    graph = log --graph --date-order -C -M --pretty=format:\"<%h> %ad [%an] %Cgreen%d%Creset %s\" --all --date=short

答案 14 :(得分：27)

gitg ：基于gtk的存储库查看器，这是新的但有趣且有用的 http://git.gnome.org/browse/gitg
我目前使用它

答案 15 :(得分：27)

这是我对此事的看法：

截图：

Screenshot

用法：

git hist - 显示当前分支的历史记录

git hist --all - 显示所有分支（包括遥控器）的图表

git hist master devel - 显示两个或多个分支之间的关系

git hist --branches - 显示所有本地分支

添加--topo-order以在拓扑上对提交进行排序，而不是按日期排序（默认在此别名中）

优点：

  • 看起来就像普通--decorate，所以使用不同分支名称的单独颜色
  • 添加提交者电子邮件
  • 添加提交相对和绝对日期
  • 按日期排序提交

设定：

git config --global alias.hist "log --graph --date-order --date=short \
--pretty=format:'%C(auto)%h%d %C(reset)%s %C(bold blue)%ce %C(reset)%C(green)%cr (%cd)'"

答案 16 :(得分：25)

虽然有时我使用gitg，但总是回到命令行：

[alias]
    #quick look at all repo
    loggsa = log --color --date-order --graph --oneline --decorate --simplify-by-decoration --all
    #quick look at active branch (or refs pointed)
    loggs  = log --color --date-order --graph --oneline --decorate --simplify-by-decoration
    #extend look at all repo
    logga  = log --color --date-order --graph --oneline --decorate --all
    #extend look at active branch
    logg   = log --color --date-order --graph --oneline --decorate
    #Look with date
    logda  = log --color --date-order --date=local --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ad%Creset %C(auto)%d%Creset %s\" --all
    logd   = log --color --date-order --date=local --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ad%Creset %C(auto)%d%Creset %s\"        
    #Look with relative date
    logdra = log --color --date-order --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ar%Creset %C(auto)%d%Creset %s\" --all
    logdr = log --color --date-order --graph --format=\"%C(auto)%h%Creset %C(blue bold)%ar%Creset %C(auto)%d%Creset %s\"  

    loga   = log --graph --color --decorate --all

    # For repos without subject body commits (vim repo, git-svn clones)
    logt  = log --graph --color --format=\"%C(auto)%h %d %<|(100,trunc) %s\"
    logta  = log --graph --color --format=\"%C(auto)%h %d %<|(100,trunc) %s\" --all        
    logtsa = log --graph --color --format=\"%C(auto)%h %d %<|(100,trunc) %s\" --all --simplify-by-decoration

正如您所看到的，几乎是按键保存别名，基于：

  • - 颜色：清晰的外观
  • - graph：visualize parents
  • - 日期顺序：最容易理解的看看repo
  • - 装饰：谁是谁
  • - oneline：很多时候你需要了解一个提交
  • - 简化装饰：基本的第一眼（只是标签，相关的合并，分支）
  • - all：使用带有和不带此选项的所有别名保存击键
  • - date = relative（％ar）：了解repo中的活动（有时一个分支是几乎在master下提交但几个月前从他那里提交）

在最新版本的git（1.8.5及更高版本）中，您可以从装饰占位符％d中的％C（自动）中受益

从这里你需要的是对gitrevisions的一个很好的理解，以过滤你需要的东西（像master..develop，其中--simplify-merges可以帮助长期分支）

命令行背后的电源是根据您的需求快速配置（了解repo isn＆n唯一键日志配置，因此有时需要添加--numstat，或--raw或--name-status这里git log和aliases是快速，强大和（随着时间）你可以实现的最漂亮的图形。更多，默认情况下通过寻呼机显示输出（比如说更少），你总是可以在结果中快速搜索。不相信？你可以始终使用gitgraph

等项目解析结果

答案 17 :(得分：18)

一个漂亮，干净的表格状git图，用于shells

with hashes as usally besides the graph tree

除了图树外通常还带有散列值

or in an extra column

或在额外的列中

编辑：您想立即开始阅读所有说明吗？跳转到编辑6 。

信息：有关外壳的更像分支的彩色版本，请参见我的第二个答案（https://stackoverflow.com/a/63253135/）。

到目前为止，在该问题的所有答案中，没有一个显示出像贝壳一样干净的表输出。 最接近的是我从this answer from gospes开始的地方。

我的方法的核心点是仅计算显示给用户的树字符。然后使用空格将其填充到个人长度。

除了git以外，您还需要这些工具

  • grep
  • 粘贴
  • printf
  • sed
  • seq
  • tr
  • wc

主要随Linux发行版一起提供。

代码段是

while IFS=+ read -r graph hash time branch message;do
  
  # count needed amount of whitespaces and create them
  whitespaces=$((9-$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)))
  whitespaces=$(seq -s' ' $whitespaces|tr -d '[:digit:]')
  
  # show hashes besides the tree ...
  #graph_all="$graph_all$graph$(printf '%7s' "$hash")$whitespaces \n"
  
  # ... or in an own column
  graph_all="$graph_all$graph$whitespaces\n"
  hash_all="$hash_all$(printf '%7s' "$hash")  \n"
  
  # format all other columns
  time_all="$time_all$(printf '%12s' "$time") \n"
  branch_all="$branch_all$(printf '%15s' "$branch")\n"
  message_all="$message_all$message\n"
done < <(git log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(214)%>(15,trunc)%d%C(reset)+%C(white)%s%C(reset)' && echo);

# paste the columns together and show the table-like output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")

要计算所需的空格，我们使用

  sed -nl1000 'l' <<< "$graph"

要获得所有字符（每行最多1000个字符），而不是仅选择树字符： / \ _和空格

  grep -Eo '\\\\|\||\/|\ |\*|_'

最终对它们进行计数，并从我们选择的长度值中减去结果，该值在示例中为9。

我们要使用计算出的空白量

  seq -s' ' $whitespaces

并用

截断位置号 
  tr -d '[:digit:]'

，而不是将它们添加到图形线的末尾。就是这样！

Git已经有了'%><(amount_of_characters,truncate_option)'语法，可以很好地选择format the length of the output specifiers，

可以在左侧的“>”或右侧的“ <”中添加空格，并可以从开头的“ ltrunc”，中间的“ mtrunc”或结尾的“ trunc”截断字符。

重要，上面的printf cmd使用相同的git长度值。

很有趣，可以根据自己的需求来设计自己的干净表格外观外观。

额外：

要获取正确的长度值，可以使用以下代码段

while read -r graph;do
    chars=$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)
    [[ $chars -gt ${max_chars:-0} ]] && max_chars=$chars
done < <(git log --all --graph --pretty=format:' ')

，并使用$ max_chars作为上面的正确长度值。

编辑1 ： 刚刚注意到，下划线字符也在git树中使用，并相应地编辑上面的代码段。如果缺少其他字符，请发表评论。

编辑2 ： 如果要摆脱分支和标记条目周围的括号，只需在git命令中使用“％D”而不是“％d”，就像在EDIT 3中一样。

编辑3 ： 也许“自动”颜色选项是您最喜欢的分支和标记条目选项？

git bracketless auto color head and tag tablelike shell output

更改git命令的此部分（颜色 214 ）

%C(214)%>(15,trunc)%D%C(reset)

到自动 

%C(auto)%>(15,trunc)%D%C(reset)

编辑4 ：或者您喜欢该部分自己的颜色混合，即带有眨眼的奇特输出？

git tree fancy styled tablelike output

要能够首先设置标题，分支名称和标签的样式，我们需要像EDIT 3一样在git命令中使用“自动”颜色选项。

然后我们可以通过添加这三行来用我们自己的颜色替换已知的颜色值

 # branch name styling
 branch=${branch//1;32m/38;5;214m}
 # head styling
 branch=${branch//1;36m/3;5;1;38;5;196m}
 # tag styling
 branch=${branch//1;33m/1;38;5;222m}

就在行前

 branch_all="$branch_all$(printf '%15s' "$branch")\n"
在我们的代码段中。替换值产生上面的颜色。

例如head的替换值是

3;5;1;38;5;196

其中3;斜体字代表5；闪烁，颜色为1; 38; 5; 196。 For more infos start here.注意：此行为取决于您喜欢的终端，因此可能无法使用。

但是，您可以选择任何喜欢的颜色值。

git颜色值和ANSI等效项的概述

enter image description here

您找到带有git color/style option here的列表。

如果您需要控制台上的输出以获得准确的颜色（上图是通过stackoverflow缩小的），则可以使用以下方式生成输出：

for ((i=0;i<=255;i++));do
  while IFS='+' read -r tree hash;do 
    echo -e "$(printf '%-10s' "(bold $i)") $hash  $(sed -nl500 'l' <<< "$hash"|grep -Eom 1 '[0-9;]*[0-9]m'|tr -d 'm')"
  done < <(git log --all --graph --decorate=short --color --pretty=format:'+%C(bold '$i')%h%C(reset)'|head -n 1)
done
git项目路径中的

使用git日志输出中的第一次提交。

编辑5 ： 正如成员“ Andras Deak”提到的那样，有一些方法可以使用此代码：

1）作为别名：

alias does not accept parameters but a function can，因此只需在您的.bashrc中定义

   function git_tably () {
     unset branch_all graph_all hash_all message_all time_all max_chars

     ### add here the same code as under "2) as a shell-script" ###

   }

直接在您的git项目路径下或从您希望使用git项目路径作为第一个参数的任何位置调用git_tably函数（源自表形式）。

2）作为shell脚本：

我将其与将git项目目录作为第一个参数传递给它的选项一起使用，或者如果为空，则像正常行为一样采用工作目录。整个我们都有

# edit your color/style preferences here or use empty values for git auto style
tag_style="1;38;5;222"
head_style="1;3;5;1;38;5;196"
branch_style="38;5;214"

# determine the max character length of your git tree
while IFS=+ read -r graph;do
  chars_count=$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)
  [[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count
done < <(cd "${1:-"$PWD"}" && git log --all --graph --pretty=format:' ')

# create the columns for your prefered table-like git graph output
while IFS=+ read -r graph hash time branch message;do

  # count needed amount of whitespaces and create them
  whitespaces=$(($max_chars-$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)))
  whitespaces=$(seq -s' ' $whitespaces|tr -d '[:digit:]')

  # show hashes besides the tree ...
  #graph_all="$graph_all$graph$(printf '%7s' "$hash")$whitespaces \n"

  # ... or in an own column
  graph_all="$graph_all$graph$whitespaces\n"
  hash_all="$hash_all$(printf '%7s' "$hash")  \n"

  # format all other columns
  time_all="$time_all$(printf '%12s' "$time") \n"
  branch=${branch//1;32m/${branch_style:-1;32}m}
  branch=${branch//1;36m/${head_style:-1;36}m}
  branch=${branch//1;33m/${tag_style:-1;33}m}
  branch_all="$branch_all$(printf '%15s' "$branch")\n"
  message_all="$message_all$message\n"

done < <(cd "${1:-"$PWD"}" && git log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)' && echo);

# paste the columns together and show the table-like output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")

3）作为git别名：

也许最舒适的方法是在.gitconfig中添加git别名

[color "decorate"]
    HEAD = bold blink italic 196
    branch = 214
    tag = bold 222
    
[alias]
    count-log = log --all --graph --pretty=format:' '
    tably-log = log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)'
    tably     = !bash -c '"                                                                                                    \
                  while IFS=+ read -r graph;do                                                                                 \
                    chars_count=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
                    [[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count;                                          \
                  done < <(git count-log && echo);                                                                             \
                  while IFS=+ read -r graph hash time branch message;do                                                        \
                    chars=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l);       \
                    whitespaces=$(($max_chars-$chars));                                                                        \
                    whitespaces=$(seq -s\" \" $whitespaces|tr -d \"[:digit:]\");                                               \
                    graph_all=\"$graph_all$graph$whitespaces\n\";                                                              \
                    hash_all=\"$hash_all$(printf \"%7s\" \"$hash\")  \n\";                                                     \
                    time_all=\"$time_all$(printf \"%12s\" \"$time\") \n\";                                                     \
                    branch_all=\"$branch_all$(printf \"%15s\" \"$branch\")\n\";                                                \
                    message_all=\"$message_all$message\n\";                                                                    \
                  done < <(git tably-log && echo);                                                                             \
                  paste -d\" \" <(echo -e \"$time_all\") <(echo -e \"$branch_all\") <(echo -e \"$graph_all\")                  \
                                <(echo -e \"$hash_all\") <(echo -e \"$message_all\");                                          \
                '"

比仅在任何项目路径下调用git tably。

Git如此强大，您可以直接如上图和taken from here所示更改头，标签，...。

Another fancy option用于选择最喜欢的树木颜色

[log]
    graphColors = bold 160, blink 231 bold 239, bold 166, bold black 214, bold green, bold 24, cyan

这会让您发疯，但始终像表格一样git log输出

fanciest_git_tree_tablelike_image

眨眼太多！只是为了证明可能。指定的颜色太少会导致颜色重复。

A complete .gitconfig reference is just one click away.

编辑6 ： 由于您的赞成票，我对该代码段进行了改进。 现在，您几乎可以使用任何git log命令来提供它了，而不必再修改代码了。试试吧！

它如何工作？

  • 一如既往地在.gitconfig中定义git log命令（格式如下）
  • 定义一个正的树列号，其中显示git图（可选）

然后致电

git tably YourLogAlias

在任何git项目路径下或

git tably YourLogAlias TreeColNumber

其中TreeColNumber从上面覆盖始终定义的值。

git tably YourLogAlias | less -r

将输出减少到更少，这对于庞大的历史记录很有用。

您的git日志别名必须遵循以下格式规则：

  • 每列都必须由列定界符指示，您必须选择该定界符，否则可能会导致问题

    即^中的...format:'^%h^%cr^%s'生成树，哈希，时间和提交列

  • 在您的log命令中的每个提交占位符之前，您必须使用
    %><(<N>[,ltrunc|mtrunc|trunc])，其中有一个trunc选项

    （有关语法说明，请参见https://git-scm.com/docs/pretty-formats）

    但是，如果没有新行，最后一个提交占位符都可以使用

    即...format:'^%<(7,trunc)%h^%<(12,trunc)%cr^%s'

  • 如果需要额外的字符来装饰，例如{p}中的(committer: ， <和>)

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

    要获得类似表格的输出，必须在提交占位符之前和之后直接编写

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

  • 使用%C(white)...%C(rest)之类的列颜色需要使用--color选项获得彩色输出

    即...--color...format:'^%C(white)%<(7,trunc)%h%C(rest)...

  • 如果您使用--stat选项或类似选项，请在末尾添加换行符%n

    即...--stat...format:'...%n'...

  • 只要不使用换行符或仅使用空白format:'...%n'

    ，就可以将git图形放置在每一列

    对于非空换行符...%n%CommitPlaceholder...，只有在每行的第n列都存在且使用相同宽度的情况下，才可以将git图放置在每n + 1列

  • 您为特定日志别名定义的树列号的名称必须为YourLogAlias-col

与普通的git log输出相比，这很慢但很好。

现在，将经过改进的代码段添加到您的.gitconfig中 

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

    # delimiter used in every mylog alias as column seperator
    delim     = ^
    
    # short overview about the last hashes without graph
    mylog     = log --all --decorate=short --color --pretty=format:'^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(bold 214)%<(7,trunc)%h%C(reset)' -5
    
    # log with hashes besides graph tree
    mylog2    = log --all --graph --decorate=short --color --pretty=format:'%C(bold 214)%<(7,trunc)%h%C(reset)^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(auto)%>(15,trunc)%D%C(reset)^%C(white)%<(80,trunc)%s%C(reset)'
    mylog2-col= 3
    
    # log with hashes in an own column and more time data
    mylog3    = log --all --graph --decorate=short --color --pretty=format:'^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(cyan)%<(10,trunc)%cs%C(reset)^%C(bold 214)%<(7,trunc)%h%C(reset)^%C(auto)%<(15,trunc)%D%C(reset)^%C(white)%s%C(reset)'
    mylog3-col= 4
    
    tably     = !bash -c '" \
                \
                \
                declare -A col_length; \
                apost=$(echo -e \"\\u0027\"); \
                delim=$(git config alias.delim); \
                git_log_cmd=$(git config alias.$1); \
                git_tre_col=${2:-$(git config alias.$1-col)}; \
                [[ -z "$git_tre_col" ]] && git_tre_col=1; \
                [[ -z "$git_log_cmd" ]] && { git $1;exit; }; \
                \
                \
                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%$apost*}; \
                    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}\")\"; \
                \
                \
                git_log_fst_part=\"${git_log_cmd%%\"$apost\"*}\"; \
                git_log_lst_part=\"${git_log_cmd##*\"$apost\"}\"; \
                git_log_tre_part=\"${git_log_cmd%%\"$delim\"*}\"; \
                git_log_tre_part=\"${git_log_tre_part##*\"$apost\"}\"; \
                git_log_cmd_count=\"$git_log_fst_part$apost $git_log_tre_part$apost$git_log_lst_part\"; \
                col_length[\"1:1\"]=$(eval git \"${git_log_cmd_count// --color}\" | wc -L); \
                \
                \
                i=0; \
                while IFS=\"$delim\" read -r graph rest;do \
                  ((i++)); \
                  graph_line[$i]=\"$graph\"; \
                done < <(eval git \"${git_log_cmd/ --color}\" && echo); \
                \
                \
                i=0; \
                l=0; \
                while IFS= read -r line;do \
                  c=0; \
                  ((i++)); \
                  ((l++)); \
                  [[ $l -gt $n ]] && l=1; \
                  while IFS= read -d\"$delim\" -r col_content;do \
                    ((c++)); \
                    [[ $c -le $git_tre_col ]] && c_corr=-1 || c_corr=0; \
                    if [[ $c -eq 1 ]];then \
                      [[ \"${col_content/\\*}\" = \"$col_content\" ]] && [[ $l -eq 1 ]] && l=$n; \
                      count=$(wc -L <<< \"${graph_line[$i]}\"); \
                      whitespaces=$(seq -s\" \" $((${col_length[\"1:1\"]}-$count))|tr -d \"[:digit:]\"); \
                      col_content[$git_tre_col]=\"${col_content}$whitespaces\"; \
                    else \
                      col_content[$c+$c_corr]=\"$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\"; \
                    fi; \
                  done <<< \"$line$delim\"; \
                  for ((k=$c+1;k<=$i_max;k++));do \
                    [[ $k -le $git_tre_col ]] && c_corr=-1 || c_corr=0; \
                    col_content[$k+$c_corr]=\"$(printf \"%-${col_length[\"$l:$k\"]:-${col_length[\"${last[$k]:-1}:$k\"]:-0}}s\" \"\")\"; \
                  done; \
                  unset col_content[0]; \
                  echo -e \"${col_content[*]}\"; \
                  unset col_content[*]; \
                done < <(eval git \"$git_log_cmd\" && echo); \
                "' "git-tably"

表格中的位置

  • 第一段将delim（iter），YourLogAlias和YourLogAlias-col加载到Shell变量中
  • 秒数读出每一列的长度
  • 第三位算最大树的长度
  • 第四个将树加载到数组中
  • 第五个组织并打印表格形式的输出

结果：

enter image description here

enter image description here

enter image description here

或带有新的TreeColNumber即时

enter image description here

再次：乐于根据您的需求来设计自己的干净表格外观外观。

您还可以在注释中共享您喜欢的格式化git log别名。我会不时在上面的文字中添加评分最高的图片，并添加图片。

答案 18 :(得分：17)

稍微调整一下Slipp's awesome answer，你可以使用他的别名来记录一个分支：

[alias]
lgBranch1 = log --graph --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(bold white)— %an%C(reset)%C(bold yellow)%d%C(reset)' --abbrev-commit --date=relative
lgBranch2 = log --graph --format=format:'%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(reset) %C(bold green)(%ar)%C(reset)%C(bold yellow)%d%C(reset)%n''          %C(white)%s%C(reset) %C(bold white)— %an%C(reset)' --abbrev-commit
lg = !"git lg1"

离开你现在可以做的--all 

git lgBranch1 <branch name>

甚至

git lgBranch1 --all

答案 19 :(得分：14)

我在git log中有~/.gitconfig个别名来查看图表历史记录：

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

有了这个，git l将输出如下内容：

enter image description here

在Git 2.12 +中，您甚至可以使用log.graphColors配置选项自定义图表的线条颜色。

至于原木＆＃39;格式，它与--oneline类似，添加了作者姓名（尊重.mailmap）和相对作者日期。请注意，Git＆gt; = 1.8.3支持%C(auto)语法，它告诉Git使用提交哈希的默认颜色等。

答案 20 :(得分：12)

GitGraph

生成Git存储库提交历史记录的PNG或SVG表示。

https://code.google.com/p/gitgraph

答案 21 :(得分：11)

git -c core.pager='less -SRF' log --oneline --graph --decorate

这是我的终端变体，类似于这里的许多答案。我喜欢调整传递给less的标志以防止自动换行。

example output

我将其设置为别名以便快速访问，因为命令有点麻烦。

答案 22 :(得分：10)

我建议tig https://github.com/jonas/tig ，一个更好的git命令行工具。

您可以使用自制软件在macOS上安装tig：

$ brew install tig
$ tig

enter image description here

答案 23 :(得分：10)

您是否尝试过gitk或gitk --all？但是它没有打印/保存img作为功能。

答案 24 :(得分：6)

试试ditaa。它可以将任何ASCII图转换为图像。虽然没有考虑到Git分支的设计，但结果给我留下了深刻的印象。

来源（txt文件）：

        +--------+
        | hotfix |
        +---+----+
            |
--*<---*<---*
       ^ 
       |
       \--*<---*
               |
           +---+----+
           | master |
           +--------+

命令：

java -jar ditaa0_9.jar ascii-graph.txt

结果：

enter image description here

它还支持背景颜色，虚线，不同形状等。请参阅the examples。

答案 25 :(得分：6)

有一个时髦的Git提交图作为Raphael网页图形库的演示之一。

演示是静态的，但它应该很容易获取代码并将其静态数据替换为实时数据集 - 我认为它只是GIT提交JSON格式的数据。

演示在这里：http://dmitrybaranovskiy.github.io/raphael/github/impact.html

答案 26 :(得分：6)

用于外壳的更具分支颜色的版本。

e

其他一些答案显示图树被外部工具很好地着色，部分带有彩色的线信息。 这是我使用Shell的方法，它与我在这里的第一个答案结合使用，以获得类似表的输出（https://stackoverflow.com/a/61487052）。

功能：

  • 您可以定义所有树木的颜色
  • 您可以将每一列染成相应的分支颜色
  • 您可以将树列放在不同的位置
  • 您可以使用各种git日志别名
  • 您可以为每个别名定义一个树列编号
  • 您可以将其发送到less -r中以获取大量历史记录

使用方式：

按照显示的几个答案定义您的git log别名，例如来自Slipp D.，albfan，kaoru，并带有下面提到的格式说明，并将其与代码段一起粘贴到您的.gitconfig中。 与通常一样，从项目路径中调用它

git colored YourLogAlias或使用

git colored YourLogAlias TreeColumnNumber可以动态地放置树状列。

格式说明：

您的git日志别名必须遵循以下格式规则：

  • 使用唯一字符作为每个提交占位符的列分隔符，即^
    ...format:'%h%cr%s'->
    ...format:'^%h^%cr^%s'
  • 用一种颜色对整个列进行着色，或将其保留为空白以采用相应的分支颜色
    ...format:'^%h^%cr^%s'->
    ...format:'^%h^%cr^%C(white)%s%C(reset)'（哈希和时间以分支颜色显示）
  • 您必须通过%><(<N>[,ltrunc|mtrunc|trunc])使用其中一个trunc选项指定任何列的宽度，但是一行上的任何最后一个提交占位符都可以不使用它
    ...format:'^%h^%cr^%C(white)%s%C(reset)'->
    ...format:'^%<(7,trunc)%h^%<(12,trunc)%cr^%C(white)%<(50,trunc)%s%C(reset)'
  • 如果您需要多余的装饰字符，请将其直接放在提交占位符周围，即Commit:
    ...^%C(white)%<(50,trunc)%s%C(reset)...->
    ...^%C(white)%<(50,trunc)Commit:%s%C(reset)...
  • 如果您使用换行符%n，请将它们放在列分隔符之前或末尾
    ...^%C(white)%<(50,trunc)Commit:%s%C(reset)'->
    ...%n^%C(white)%<(50,trunc)Commit:%s%C(reset)%n'
  • 如果您使用上面的%C(white)之类的列颜色，则需要添加--color选项
    ...format:'^%<(7,trunc)%h...->
    ...--color...format:'^%<(7,trunc)%h...
  • 如果您使用--stat选项或类似选项，请在末尾添加换行符%n
    ...--stat...format:'...'->
    ...--stat...format:'...%n'

其他：

  • 用于带有非空换行符...%n%CommitPlaceholder...的git日志别名， 仅当每行的第n列都存在并且使用相同的宽度时，才可以将git图放置在每n + 1列

    • 如果在.gitconfig中为YourLogAlias-col

    定义一个TreeColumnNumber，则必须使用

  • YourLogAlias作为名称。

  • 与普通的git log输出相比，这很慢，但是很好

示例：

git colored lgc1 e

git colored lgc2 e

git colored lgc3 e

git colored lgc4 e

代码段：

将以下行添加到您的.gitconfig 

[alias]

# Define your unique column seperator
delim      = ^

# Define your git log aliases and optional tree column numbers
lgc1       = log --all --graph --color --pretty=format:'^%<(7,trunc)%h^%C(white)%<(15,trunc)- %ar -%C(reset)^%<(35,trunc)%s^%C(white)%an%C(reset)'

lgc2       = log --all --graph --color --pretty=format:'%D^%<(7,trunc)%h^%<(35,trunc)%s^%C(white)%<(20,trunc)%an%C(reset)^%C(white) (%ar)%C(reset)'
lgc2-col   = 2

lgc3       = log --all --graph --color --pretty=format:'%<(7,trunc)%h%d^%<(11,trunc)%cs%C(reset)^%s%n^%C(white)%<(11,trunc)%cr%C(reset)^%C(white)%<(25,trunc)From %an%C(reset)^%C(white)%ae%C(reset)%n'
lgc3-col   = 2

lgc4       = log --all --graph --color --pretty=format:'%h^%C(white)%<(25,trunc)%an%C(reset)^%C(white)%<(31,trunc)%aD%C(reset)^%s%n^%C(dim white)%<(25,trunc)%ae%C(reset)^%>(31,trunc)%D%C(reset)%n'
lgc4-col   = 3

# Define your whitespace seperated tree color list
color-list = "1;38;5;222 1;38;5;69 1;38;5;250 1;38;5;70 1;31 1;38;5;93 1;33 2;38;5;11 1;38;5;48 1;35 1;32 1;38;5;111 1;38;5;160 1;38;5;130 1;36 38;5;21"

也将bash代码段添加到您的.gitconfig中

# This is the bash snippet which does all the magic
colored = !bash -c '" \
  \
  \
  declare -A col_length col_colored; \
  apost=$(echo -e \"\\u0027\"); \
  delim=$(git config alias.delim); \
  git_log_cmd=$(git config alias.$1); \
  graph_col=${2:-$(git config alias.$1-col)}; \
  color_list=( $(git config alias.color-list) ); \
  [[ -z \"$graph_col\" ]] && graph_col=1; \
  [[ -z \"$git_log_cmd\" ]] && { git $1;exit; }; \
  \
  \
  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_info:1:1}\" = \"C\" ]] && col_colored[\"$n:$i\"]=1; \
      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%$apost*}; \
      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}\")\"; \
  \
  \
  git_log_fst_part=\"${git_log_cmd%%\"$apost\"*}\"; \
  git_log_lst_part=\"${git_log_cmd##*\"$apost\"}\"; \
  git_log_tre_part=\"${git_log_cmd%%\"$delim\"*}\"; \
  git_log_tre_part=\"${git_log_tre_part##*\"$apost\"}\"; \
  git_log_cmd_count=\"$git_log_fst_part$apost $git_log_tre_part$apost$git_log_lst_part\"; \
  col_length[\"1:1\"]=$(eval git \"${git_log_cmd_count// --color}\" | wc -L); \
  \
  \
  i=0; \
  while IFS=\"$delim\" read -r graph rest;do \
    ((i++)); \
    graph_line[$i]=\"$graph\"; \
  done < <(eval git \"${git_log_cmd/ --color}\" && echo); \
  \
  \
  i=0; \
  l=0; \
  msg_err=; \
  color_list_ind=-1; \
  color_list_num=${#color_list[*]}; \
  color_repeat_ind=1; \
  if [[ $color_list_num -eq 0 ]];then \
    echo \"No tree colors specified via color-list under section [alias] in your .gitconfig\"; \
    echo \"Therefore collecting available git colors, which may take a while ...\"; \
    while read -d\"[\" -r char;do \
      color=$(sed -nl99 \"l\" <<< \"$char\"); \
      case \"$color\" in \
        *\"m\"*) \
          color=${color%%m*}; \
          ;; \
        *) \
          continue; \
          ;; \
      esac; \
      case \" $color_list \" in \
        *\" $color \"*) \
          continue; \
          ;; \
        *) \
          color_list=\"$color_list$color \"; \
          ;; \
      esac; \
    done <<< \"$(git log --all --color --graph --pretty=format:)\"; \
    echo -e \"Temporary used color-list = \\\"${color_list% }\\\"\\n\"; \
    color_list=( ${color_list% } ); \
    color_list_num=${#color_list[*]}; \
  fi; \
  while IFS= read -r line;do \
    ((i++)); \
    j=-1; \
    case_off=; \
    graph_colored=; \
    graph_line_last=\"${graph_line[$i-1]}\"; \
    graph_line=\"${graph_line[$i]}\"; \
    graph_line_next=\"${graph_line[$i+1]}\"; \
    while IFS= read -r char;do \
      ((j++)); \
      case \"$case_off$char\" in \
        [^\\ \\_\\*\\/\\|\\\\]|\"case_off\"*) \
          graph_colored=\"${graph_colored}\\033[${point_color}m$char\\033[0m\"; \
          case_off=\"case_off\"; \
          ;; \
        \" \") \
          graph_colored=\"${graph_colored}$char\"; \
          case \"$char_last\" in \
            \" \") \
              unset color_ind[$j]; \
              ;; \
          esac; \
          ;; \
        \"*\") \
          case \"${graph_line_last:$j:1}\" in \
            \"*\") \
              :; \
              ;; \
            \"|\") \
              case \"${graph_line_last:$(($j-1)):1}\" in \
                \"\\\\\") \
                  color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
                  ;; \
                *) \
                  :; \
                  ;; \
              esac; \
              ;; \
            \" \") \
              case \"${graph_line_last:$(($j-1)):1}\" in \
                \"\\\\\") \
                  color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
                  ;; \
                \"/\") \
                  case \"${graph_line_last:$(($j+1)):1}\" in \
                    \"/\") \
                      color_ind[$j]=${color_ind[$j+1]}; \
                      ;; \
                    \" \") \
                      new_col_ind=${#color[*]}; \
                      while true;do \
                        ((color_list_ind++)); \
                        [[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
                        [[ $color_list_ind -ge $color_list_num ]] && break; \
                        new_color=${color_list[$color_list_ind]}; \
                        case \"$new_color\" in \
                          \"\"|[\\ ]*) \
                            continue; \
                            ;; \
                          \"${color[${color_ind[$j-1]}]}\") \
                            [[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
                            ;;& \
                          *) \
                            color[$new_col_ind]=$new_color; \
                            color_ind[$j]=$new_col_ind; \
                            last_new_colored_line=$i; \
                            break; \
                            ;; \
                        esac 2>/dev/null; \
                      done; \
                      ;; \
                    *) \
                      [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                      ;; \
                  esac; \
                  ;; \
                \" \") \
                  case \"${graph_line_last:$(($j+1)):1}\" in \
                    \"/\") \
                      color_ind[$j]=${color_ind[$j+1]}; \
                      ;; \
                    *) \
                      new_col_ind=${#color[*]}; \
                      while true;do \
                        ((color_list_ind++)); \
                        [[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
                        [[ $color_list_ind -ge $color_list_num ]] && break; \
                        new_color=${color_list[$color_list_ind]}; \
                        case \"$new_color\" in \
                          \"\"|[\\ ]*) \
                            continue; \
                            ;; \
                          \"${color[${color_ind[$j-1]}]}\") \
                            [[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
                            ;;& \
                          *) \
                            color[$new_col_ind]=$new_color; \
                            color_ind[$j]=$new_col_ind; \
                            last_new_colored_line=$i; \
                            break; \
                            ;; \
                        esac 2>/dev/null; \
                      done; \
                      ;; \
                  esac; \
                  ;; \
                *) \
                  [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                  ;; \
              esac; \
              ;; \
            \"\"|[^\\ \\_\\*\\/\\|\\\\]) \
              new_col_ind=${#color[*]}; \
              while true;do \
                ((color_list_ind++)); \
                [[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
                [[ $color_list_ind -ge $color_list_num ]] && break; \
                new_color=${color_list[$color_list_ind]}; \
                case \"$new_color\" in \
                  \"\"|[\\ ]*) \
                    continue; \
                    ;; \
                  \"${color[${color_ind[$j-1]}]}\") \
                    [[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
                    ;;& \
                  *) \
                    color[$new_col_ind]=$new_color; \
                    color_ind[$j]=$new_col_ind; \
                    last_new_colored_line=$i; \
                    break; \
                    ;; \
                esac 2>/dev/null; \
              done; \
              ;; \
            *) \
              [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
              ;; \
          esac; \
          graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
          point_color=${color[${color_ind[$j]}]}; \
          ;; \
        \"|\") \
          case \"${graph_line_last:$j:1}\" in \
            \" \") \
              case \"${graph_line_last:$(($j-1)):1}\" in \
                \"/\") \
                  color_ind[$j]=${color_ind[$j+1]}; \
                  ;; \
                \"\\\\\") \
                  color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
                  ;; \
                *) \
                  case \"${graph_line_last:$(($j+1)):1}\" in \
                    \"/\") \
                      color_ind[$j]=${color_ind[$j+1]}; \
                      ;; \
                    *) \
                      [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                      ;; \
                  esac; \
                  ;; \
              esac; \
              ;; \
            \"|\") \
              case \"${graph_line_last:$(($j-1)):1}\" in \
                \"\\\\\") \
                  case \"${graph_line:$(($j+1)):1}\" in \
                    \"\\\\\") \
                       :; \
                       ;; \
                    \" \") \
                      color_ind[$j]=${color_ind_last[$j-1]}; \
                      ;; \
                    *) \
                      [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                      ;; \
                  esac; \
                  ;; \
                *) \
                  :; \
                  ;; \
              esac; \
              ;; \
            \"*\") \
              case \"${graph_line:$(($j-1)):1}\" in \
                \"/\") \
                  if [[ $last_new_colored_line -eq $(($i-1)) ]];then \
                    new_col_ind=${#color[*]}; \
                    while true;do \
                      ((color_list_ind++)); \
                      [[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
                      [[ $color_list_ind -ge $color_list_num ]] && break; \
                      new_color=${color_list[$color_list_ind]}; \
                      case \"$new_color\" in \
                        \"\"|[\\ ]*) \
                          continue; \
                          ;; \
                        \"${color[${color_ind[$j-1]}]}\") \
                          [[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
                          ;;& \
                        *) \
                          color[$new_col_ind]=$new_color; \
                          color_ind[$j]=$new_col_ind; \
                          break; \
                          ;; \
                      esac 2>/dev/null; \
                    done; \
                  else \
                    color_ind[$j]=${color_ind_last[$j]}; \
                  fi; \
                  ;; \
                *) \
                  :; \
                  ;; \
              esac; \
              ;; \
            \"/\") \
              color_ind[$j]=${color_ind[$j]}; \
              ;; \
            *) \
              [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
              ;; \
          esac; \
          graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
          ;; \
        \"/\") \
          case \"${graph_line_last:$(($j)):1}\" in \
            \"|\") \
              case \"${graph_line_last:$(($j+1)):1}\" in \
                \"/\") \
                  case \"${graph_line_next:$j:1}\" in \
                    \"|\") \
                      color_ind[$j]=${color_ind[$j+1]}; \
                      ;; \
                    \" \") \
                      color_ind[$j]=${color_ind[$j]}; \
                      ;; \
                    *) \
                      [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                      ;; \
                  esac; \
                  ;; \
                *) \
                  color_ind[$j]=${color_ind[$j]}; \
                  ;; \
              esac; \
              ;; \
            *) \
              case \"${graph_line_last:$(($j+2)):1}\" in \
                \"/\"|\"_\") \
                  color_ind[$j]=${color_ind[$j+2]}; \
                  ;; \
                *) \
                  case \"${graph_line_last:$(($j+1)):1}\" in \
                    \"/\"|\"_\"|\"|\") \
                      color_ind[$j]=${color_ind[$j+1]}; \
                      ;; \
                    \"*\") \
                      case \"${graph_line:$(($j+1)):1}\" in \
                        \"|\") \
                          if [[ $last_new_colored_line -eq $(($i-1)) ]];then \
                            color_ind[$j]=${color_ind_last[$j+1]}; \
                          else \
                            new_col_ind=${#color[*]}; \
                            while true;do \
                              ((color_list_ind++)); \
                              [[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
                              [[ $color_list_ind -ge $color_list_num ]] && break; \
                              new_color=${color_list[$color_list_ind]}; \
                              case \"$new_color\" in \
                                \"\"|[\\ ]*) \
                                  continue; \
                                  ;; \
                                \"${color[${color_ind[$j-1]}]}\") \
                                  [[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
                                  ;;& \
                                *) \
                                  color[$new_col_ind]=$new_color; \
                                  color_ind[$j]=$new_col_ind; \
                                  break; \
                                  ;; \
                              esac 2>/dev/null; \
                            done; \
                          fi; \
                          ;; \
                        *) \
                          color_ind[$j]=${color_ind_last[$j+1]}; \
                          ;; \
                      esac; \
                      ;; \
                    *) \
                      case \"${graph_line_last:$j:1}\" in \
                        \"\\\\\") \
                          :; \
                          ;; \
                        \" \") \
                          case \"${graph_line_last:$(($j+1)):1}\" in \
                            \"*\") \
                              color_ind[$j]=${color_ind[$j+1]}; \
                              ;; \
                            *) \
                              [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                              ;; \
                          esac; \
                          ;; \
                        *) \
                          [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                          ;; \
                      esac; \
                      ;; \
                  esac; \
                  ;; \
              esac; \
              ;; \
          esac; \
          graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
          ;; \
        \"\\\\\") \
          case \"${graph_line_last:$(($j-1)):1}\" in \
            \"|\"|\"\\\\\") \
              color_ind[$j]=${color_ind_last[$j-1]:-${color_ind[$j-1]}}; \
              ;; \
            \"*\") \
              new_col_ind=${#color[*]}; \
              while true;do \
                ((color_list_ind++)); \
                [[ $color_list_ind -ge $color_list_num ]] && color_list_ind=$color_repeat_ind; \
                [[ $color_list_ind -ge $color_list_num ]] && break; \
                new_color=${color_list[$color_list_ind]}; \
                case \"$new_color\" in \
                  \"\"|[\\ ]*) \
                    continue; \
                    ;; \
                  \"${color[${color_ind[$j-1]}]}\") \
                    [[ $(($color_list_num-$color_repeat_ind)) -gt 1 ]] && continue; \
                    ;;& \
                  *) \
                    color[$new_col_ind]=$new_color; \
                    color_ind[$j]=$new_col_ind; \
                    break; \
                    ;; \
                esac 2>/dev/null; \
              done; \
              ;; \
            \" \") \
              case \"${graph_line_last:$(($j-2)):1}\" in \
                \"\\\\\"|\"_\") \
                  color_ind[$j]=${color_ind_last[$j-2]:-${color_ind[$j-2]}}; \
                  ;; \
                *) \
                  case \"${graph_line_last:$j:1}\" in \
                    \"|\") \
                      color_ind[$j]=${color_ind_last[$j]:-${color_ind[$j]}}; \
                      ;; \
                    *) \
                      [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                      ;; \
                  esac; \
                  ;; \
              esac; \
              ;; \
            *) \
              [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
              ;; \
          esac; \
          graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char$char\\033[0m\"; \
          ;; \
        \"_\") \
          case \"${graph_line:$(($j-2)):1}\" in \
            \"\\\\\"|\"_\") \
              color_ind[$j]=${color_ind[$j-2]}; \
              ;; \
            \" \"|\"/\") \
              k=2; \
              while [[ \"${graph_line:$(($j+$k)):1}\" = \"_\" ]];do \
                k=$(($k+2)); \
              done; \
              case \"${graph_line:$(($j+$k)):1}\" in \
                \"/\") \
                  case \"${graph_line_last:$(($j+$k+1)):1}\" in \
                    \"*\") \
                      color_ind[$j]=${color_ind[$j+$k+1]}; \
                      ;; \
                    \" \") \
                      case \"${graph_line_last:$(($j+$k)):1}\" in \
                        \"\\\\\") \
                          color_ind[$j]=${color_ind[$j+$k]}; \
                          ;; \
                        *) \
                          [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                          ;; \
                      esac; \
                      ;; \
                    \"|\") \
                      case \"${graph_line:$(($j+$k+1)):1}\" in \
                        \"|\") \
                          color_ind[$j]=${color_ind[$j+$k+2]}; \
                          ;; \
                        \" \") \
                          color_ind[$j]=${color_ind[$j+$k+1]}; \
                          ;; \
                        *) \
                          [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                          ;; \
                      esac; \
                      ;; \
                    *) \
                      [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                      ;; \
                  esac; \
                  ;; \
                *) \
                  [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
                  ;; \
              esac; \
              ;; \
            *) \
              [[ -n \"$msg_err\" ]] && echo -e \"Unknown case in graph_line $i: $graph_line for char $char at position $j\nwith the former graph_line $(($i-1)): $graph_line_last\"; \
              ;; \
          esac; \
          graph_colored=\"${graph_colored}\\033[${color[${color_ind[$j]}]}m$char\\033[0m\"; \
          ;; \
      esac; \
      char_last=$char; \
    done <<< \"$(grep -Eo \".\" <<< \"${graph_line%%$delim*}\")\"; \
    for key in ${!color_ind[*]};do \
      color_ind_last[$key]=${color_ind[$key]}; \
    done; \
    \
    \
    c=0; \
    ((l++)); \
    [[ $l -gt $n ]] && l=1; \
    while IFS= read -d\"$delim\" -r col_content;do \
      ((c++)); \
      [[ $c -le $graph_col ]] && c_corr=-1 || c_corr=0; \
      if [[ $c -eq 1 ]];then \
        [[ \"${col_content/\\*}\" = \"$col_content\" ]] && [[ $l -eq 1 ]] && l=$n; \
        whitespaces=$(seq -s\" \" $((${col_length[\"1:1\"]}-$j))|tr -d \"[:digit:]\"); \
        col_content[$graph_col]=\"${graph_colored}$whitespaces\"; \
      elif [[ ${col_colored[\"$l:$c\"]:-0} -eq 0 ]];then \
        col_content[$c+$c_corr]=\"\\033[${point_color:-0}m$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\\033[0m\"; \
      else \
        col_content[$c+$c_corr]=\"$(printf \"%-${col_length[\"$l:$c\"]}s\" \"${col_content:-\"\"}\")\"; \
      fi; \
    done <<< \"$line$delim\"; \
    for ((k=$c+1;k<=$i_max;k++));do \
      [[ $k -le $graph_col ]] && c_corr=-1 || c_corr=0; \
      col_content[$k+$c_corr]=\"$(printf \"%-${col_length[\"$l:$k\"]:-${col_length[\"${last[$k]:-1}:$k\"]:-0}}s\" \"\")\"; \
    done; \
    unset col_content[0]; \
    echo -e \"${col_content[*]}\"; \
    unset col_content[*]; \
  done < <(git $1 && echo); \
  "' "git-colored"

说明：

  • 第一段将delim（iter），颜色列表和You​​rLogAlias加载到外壳变量中
  • 秒数读出每一列的长度
  • 第三个计数最大值。树的长度
  • 第四个将树加载到数组中
  • 第五种基于案例分析为树着色
  • 第六个将非树列着色并打印表格形式的输出

最大的部分是用于设置树色的案例分析。其他部分在我对表状shell输出的链接答案中进行了解释。

请在注释中显示您喜欢的格式化日志别名，因为我只是示例。上面的文本中不时包含投票最多的五个。

答案 27 :(得分：5)

我不知道直接工具，但也许您可以破解脚本将数据导出为点格式并使用graphviz进行渲染。

答案 28 :(得分：4)

对于OSX用户，我已经采用@gospes示例并稍微修改了gsed（通过自制程序安装gnu-sed）并调整了颜色（使用黑色背景，不知道原始如何示例可能会呈现它在示例中的方式，因为它在具有黑色背景的终端上指定黑色文本。）

[alias]
    # tree, vtree, stree support
    logx = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset)+%C(bold black)(%cr)%C(reset)+%C(auto)%d%C(reset)++\n+++       %C(bold black)%an%C(reset)%C(bold black): %s%C(reset)'
    tree = log --all --graph --decorate=short --color --format=format:'%C(bold blue)%h%C(reset) %C(auto)%d%C(reset)\n         %C(bold black)[%cr]%C(reset)  %x09%C(bold black)%an: %s %C(reset)'
    stree = !bash -c '" \
    while IFS=+ read -r hash time branch message; do \
        timelength=$(echo \"$time\" | gsed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\"); \
        timelength=$(echo \"16+${#time}-${#timelength}\" | bc); \
        printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"\"; \
    done < <(git logx && echo);"' | less -r
    vtree = !bash -c '" \
    while IFS=+ read -r hash time branch message; do \
      timelength=$(echo \"$time\" | gsed -r \"s:[^ ][[]([0-9]{1,2}(;[0-9]{1,2})?)?m::g\"); \
      timelength=$(echo \"16+${#time}-${#timelength}\" | bc); \
      printf \"%${timelength}s    %s %s %s\n\" \"$time\" \"$hash\" \"$branch\" \"$message\"; \
    done < <(git logx && echo);"' | less -r

OSX的关键是首先安装gnu sed（具有-r选项）。最容易使用homebrew，它不会覆盖系统安装的sed，而是安装gnu sed作为＆＃34; gsed＆＃34;。希望这有助于@ {SlippD.Thompson commented above关于OSX无法正常工作。

答案 29 :(得分：4)

〜/ .oh-my-zsh / plugins / git / git.plugin.zsh中的一些别名

gke='\gitk --all $(git log -g --pretty=%h)'
glg='git log --stat'
glgg='git log --graph'
glgga='git log --graph --decorate --all'
glgm='git log --graph --max-count=10'
glgp='git log --stat -p'
glo='git log --oneline --decorate'
glog='git log --oneline --decorate --graph'
gloga='git log --oneline --decorate --graph --all'
glol='git log --graph --pretty='\''%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'\'' --abbrev-commit'
glola='git log --graph --pretty='\''%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'\'' --abbrev-commit --all'

答案 30 :(得分：3)

如果您的存储库位于Gitlab上，则可以使用其图形表示形式，因为它在浏览器中以SVG呈现。

enter image description here

答案 31 :(得分：2)

除了'Slipp D. Thompson'的答案之外，我建议你添加这个别名，使其具有相同的装饰，但只需提交一行：

git config --global alias.tre "log --graph --decorate --pretty=oneline --abbrev-commit --all --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(bold yellow)%d%C(reset)'"

答案 32 :(得分：2)

看着这个对话试图使用我最喜欢的git-cola＆amp; git-dag。从View->DAG...运行git-cola并将{strong>日志： master --替换为--all会显示包含所有分支的漂亮图表。

答案 33 :(得分：1)

VS Code有一个惊人的扩展

https://marketplace.visualstudio.com/items?itemName=mhutchie.git-graph

Git Graph

答案 34 :(得分：0)

如果您使用的是Mac OS，则可以尝试GitUp（1）

enter image description here

  • x轴：分支
  • y轴：时间

（1）https://github.com/git-up/GitUp

相关问题
最新问题