请记住，正如在Git:查找提交来自哪个分支中所描述的，您不能轻易地确定提交的分支(分支可以重命名、移动、删除……)，即使git branch --contains <commit>是一个开始。

• 你可以从一个提交到另一个提交，直到git branch --contains <commit>没有列出feature分支和develop分支，
• 比较提交SHA1到/refs/heads/develop

如果两个提交id匹配，就可以继续了(这意味着feature分支的起源是develop的HEAD)。

我对您的整体问题有一个解决方案(确定feature是否来自develop的尖端)，但使用您概述的方法它不起作用。

您可以使用git branch --contains来列出从develop顶端开始的所有分支，然后使用grep来确保feature在其中。

git branch --contains develop | grep "^ *feature$"

如果它是其中之一，它将把" feature"打印到标准输出，并且返回代码为0。否则，它将不打印任何东西，并有一个返回代码1。

假设远程存储库有一个开发分支的副本(您最初的描述在本地存储库中描述了它，但听起来它也存在于远程存储库中)，您应该能够实现我认为您想要的结果，但是方法与您预想的有点不同。

Git的历史是基于DAG的提交。分支(和一般的“引用”)只是在不断增长的提交DAG中指向特定提交的临时标签。因此，分支之间的关系可以随时间变化，但提交之间的关系不会。

    ---o---1                foo
\
2---3---o      bar
\
4
\
5---6  baz

看起来baz是基于bar的(旧版本)?但是如果我们删除bar呢?

    ---o---1                foo
\
2---3
\
4
\
5---6  baz

现在看起来baz是基于foo的。但是baz的祖先并没有改变。我们只是删除了一个标签(以及由此产生的悬空提交)。如果我们在4添加一个新标签呢?

    ---o---1                foo
\
2---3
\
4        quux
\
5---6  baz

现在看起来baz是基于quux的。尽管如此，祖先并没有改变，只是标签变了。

然而，如果我们问“提交6是提交3的后代吗?”(假设3和6是完整的SHA-1提交名称)，那么无论是否存在bar和quux标签，答案都是“yes”。

因此，您可以问这样的问题:“被推送的提交是否是开发分支的当前尖端的后代?”，但你不能可靠地问“推送的提交的父分支是什么?”。

一个似乎接近你想要的最可靠的问题是:

对于所有被推送的提交的祖先(不包括开发的当前尖端及其祖先)，它们以开发的当前尖端为父:

• 是否至少存在一个这样的提交?
• 所有这样的提交都是单亲提交吗?

可以实现为:

pushedrev=...
basename=develop
if ! baserev="$(git rev-parse --verify refs/heads/"$basename" 2>/dev/null)"; then
echo "'$basename' is missing, call for help!"
exit 1
fi
parents_of_children_of_base="$(
git rev-list --pretty=tformat:%P "$pushedrev" --not "$baserev" |
grep -F "$baserev"
)"
case ",$parents_of_children_of_base" in
,)     echo "must descend from tip of '$basename'"
exit 1 ;;
,*\ *) echo "must not merge tip of '$basename' (rebase instead)"
exit 1 ;;
,*)    exit 0 ;;
esac

这将涵盖您想要限制的一些内容，但可能不是所有内容。

作为参考，这里是一个扩展的例子历史:

    A                                   master
\
\                    o-----J
\                  /       \
\                | o---K---L
\               |/
C--------------D              develop
\             |\
F---G---H    | F'--G'--H'
|    |\
|    | o---o---o---N
\   \      \       \
\   \      o---o---P
\   \
R---S

上面的代码可以用来拒绝# eyz0和S，同时接受H'， J， K，或N，但它也会接受L和P(它们涉及合并，但它们不合并开发的尖端)。

要拒绝L和P，您可以更改问题并询问

对于所有推送提交的祖先(不包括开发及其祖先的当前提示):

• 有双亲的提交吗?
• 如果不是，至少有一个这样的提交有开发的当前提示它的(唯一)父?

pushedrev=...
basename=develop
if ! baserev="$(git rev-parse --verify refs/heads/"$basename" 2>/dev/null)"; then
echo "'$basename' is missing, call for help!"
exit 1
fi
parents_of_commits_beyond_base="$(
git rev-list --pretty=tformat:%P "$pushedrev" --not "$baserev" |
grep -v '^commit '
)"
case "$parents_of_commits_beyond_base" in
*\ *)          echo "must not push merge commits (rebase instead)"
exit 1 ;;
*"$baserev"*)  exit 0 ;;
*)             echo "must descend from tip of '$basename'"
exit 1 ;;
esac

一个rephrasal

这个问题的另一种表达方式是“驻留在当前分支之外的分支上的最近提交是什么?是哪个分支?”

一个解决方案

您可以使用一点命令行魔法找到它

git show-branch \
| sed "s/].*//" \
| grep "\*" \
| grep -v "$(git rev-parse --abbrev-ref HEAD)" \
| head -n1 \
| sed "s/^.*\[//"

与# EYZ0:

git show-branch -a \
| grep '\*' \
| grep -v `git rev-parse --abbrev-ref HEAD` \
| head -n1 \
| sed 's/[^\[]*//' \
| awk 'match($0, /\[[a-zA-Z0-9\/.-]+\]/) { print substr( $0, RSTART+1, RLENGTH-2 )}'

下面是它的工作原理:

1. 显示所有提交的文本历史，包括远程分支。
2. 当前提交的祖先由星号表示。过滤掉其他的东西。
3. 忽略当前分支中的所有提交。
4. 第一个结果将是最近的祖先分支。忽略其他结果。
5. 分支名称显示在[括号中]。忽略括号以外的所有内容。
6. 有时分支名称将包含~#或^#，以指示在被引用的提交和分支提示之间有多少次提交。我们不在乎。忽略它们。

还有结果

运行上面的代码

 A---B---D <-master
\
\
C---E---I <-develop
\
\
F---G---H <-topic

如果你从H运行它会给你develop如果你从I运行它会给你master。

# EYZ0。

Joe Chrysler的命令行魔法可以简化。下面是Joe的逻辑——为了简洁起见，我在两个版本中都引入了一个名为cur_branch的参数来代替命令替换`git rev-parse --abbrev-ref HEAD`;可以像这样初始化:

cur_branch=$(git rev-parse --abbrev-ref HEAD)

然后，这是Joe的管道:

git show-branch -a           |
grep '\*'                  | # we want only lines that contain an asterisk
grep -v "$cur_branch"      | # but also don't contain the current branch
head -n1                   | # and only the first such line
sed 's/.*\[\(.*\)\].*/\1/' | # really, just the part of the line between []
sed 's/[\^~].*//'            # and with any relative refs (^, ~n) removed

我们可以在一个相对简单的awk命令中完成与所有这五个单独的命令过滤器相同的事情:

git show-branch -a |
awk -F'[]^~[]' '/\*/ && !/'"$cur_branch"'/ {print $2;exit}'

具体情况是这样的:

-F'[]^~[]'

将行分割为]， ^， ~和[字符的字段。

/\*/

找出包含星号的行

&& !/'"$cur_branch"'/

.．.但不是当前的分支名称

{ print $2;

当您找到这样的一行时，打印它的第二个字段(即字段分隔符第一次和第二次出现之间的部分)。对于简单的分支名称，这将是括号之间的内容;对于具有相对跳转的引用，它将只是没有修饰符的名称。因此，我们的字段分隔符集处理了两个sed命令的意图。

  exit }

然后立即退出。这意味着它只处理第一个匹配的行，所以我们不需要通过head -n 1管道输出。

Mark Reed的解决方案基本上是正确的。但是，请注意，提交行不仅应该包含星号，而且应该以星号开头!否则，包含星号的提交消息也包含在匹配的行中。所以它应该是:

# EYZ0

或者是更长的版本:

git show-branch -a           |
awk '^\*'                  | # we want only lines that contain an asterisk
awk -v "$current_branch"   | # but also don't contain the current branch
head -n1                   | # and only the first such line
sed 's/.*\[\(.*\)\].*/\1/' | # really, just the part of the line between []
sed 's/[\^~].*//'            # and with any relative refs (^, ~n) removed`

下面是Mark Reed的解决方案的PowerShell实现:

git show-branch -a | where-object { $_.Contains('*') -eq $true} | Where-object {$_.Contains($branchName) -ne $true } | select -first 1 | % {$_ -replace('.*\[(.*)\].*','$1')} | % { $_ -replace('[\^~].*','') }

使用Ant进行跨平台实现

    <exec executable="git" outputproperty="currentBranch">
<arg value="rev-parse" />
<arg value="--abbrev-ref" />
<arg value="HEAD" />
</exec>


<exec executable="git" outputproperty="showBranchOutput">
<arg value="show-branch" />
<arg value="-a" />
</exec>


<loadresource property="baseBranch">
<propertyresource name="showBranchOutput"/>
<filterchain>
<linecontains>
<contains value="*"/>
</linecontains>
<linecontains negate="true">
<contains value="${currentBranch}"/>
</linecontains>
<headfilter lines="1"/>
<tokenfilter>
<replaceregex pattern=".*\[(.*)\].*" replace="\1"/>
<replaceregex pattern="[\^~].*" replace=""/>
</tokenfilter>
</filterchain>
</loadresource>


<echo message="${currentBranch} ${baseBranch}" />

由于之前的答案在我们的存储库中都不起作用，我想分享我自己的方法，使用git log中的最新合并:

#!/bin/bash
git log --oneline --merges "$@" | grep into | sed 's/.* into //g' | uniq --count | head -n 10

把它放在一个名为git-last-merges的脚本中，该脚本也接受一个分支名称作为参数(而不是当前分支)以及其他git log参数。

从输出中，我们可以根据自己的分支约定和每个分支的合并数量手动检测父分支。

如果你经常在子分支上使用git rebase(合并通常是快进的，所以没有太多的合并提交)，这个答案就不能很好地工作，所以我写了一个脚本来计算所有分支与当前分支相比的前提交(正常和合并)和后提交(在父分支中不应该有任何后合并)。

#!/bin/bash
HEAD="`git rev-parse --abbrev-ref HEAD`"
echo "Comparing to $HEAD"
printf "%12s  %12s   %10s     %s\n" "Behind" "BehindMerge" "Ahead" "Branch"
git branch | grep -v '^*' | sed 's/^\* //g' | while read branch ; do
ahead_merge_count=`git log --oneline --merges $branch ^$HEAD | wc -l`
if [[ $ahead_merge_count != 0 ]] ; then
continue
fi
ahead_count=`git log --oneline --no-merges $branch ^$HEAD | wc -l`
behind_count=`git log --oneline --no-merges ^$branch $HEAD | wc -l`
behind_merge_count=`git log --oneline --merges ^$branch $HEAD | wc -l`
behind="-$behind_count"
behind_merge="-M$behind_merge_count"
ahead="+$ahead_count"
printf "%12s  %12s   %10s     %s\n" "$behind" "$behind_merge" "$ahead" "$branch"
done | sort -n

使用:

vbc=$(git rev-parse --abbrev-ref HEAD)
vbc_col=$(( $(git show-branch | grep '^[^\[]*\*' | head -1 | cut -d* -f1 | wc -c) - 1 ))
swimming_lane_start_row=$(( $(git show-branch | grep -n "^[\-]*$" | cut -d: -f1) + 1 ))
git show-branch | tail -n +$swimming_lane_start_row | grep -v "^[^\[]*\[$vbc" | grep "^.\{$vbc_col\}[^ ]" | head -n1 | sed 's/.*\[\(.*\)\].*/\1/' | sed 's/[\^~].*//'

它实现了与Mark Reed的回答相同的目的，但它使用了一种更安全的方法，在许多场景中都不会出错:

1. 父分支的最后一次提交是一个合并，使列显示-，而不是*
2. 提交消息包含一个分支名称
3. 提交消息包含*

这对我来说很有效:

git show-branch | grep '*' | grep -v "$(git rev-parse --abbrev-ref HEAD)" | head -n1 | sed 's/.*\[\(.*\)\].*/\1/' | sed 's/[\^~].*//'

礼貌的评论和回答从droidbot和@ jstanidiot。

现在任何人都想这样做——Atlassian的Sourcetree应用程序向你展示了你的分支如何相互关联的一个很好的可视化表示，即它们开始的位置和它们目前在提交顺序中的位置(例如，HEAD或4个提交后等)。

你也可以试试:

git log --graph --decorate

如果你使用Sourcetree，查看你的提交细节→父母。然后您将看到带下划线的提交数字(链接)。

Git父

您可以直接执行命令

git parent

如果您将乔·克莱斯勒的回答添加为Git别名，则可以找到分支的父分支。它将简化使用。

使用任何文本编辑器打开位于"~/.gitconfig"的gitconfig文件(适用于Linux)。对于Windows，“。gitconfig"路径通常位于C:\users\your-user\.gitconfig。

vim  ~/.gitconfig

在文件中添加如下alias命令:

[alias]
parent = "!git show-branch | grep '*' | grep -v \"$(git rev-parse --abbrev-ref HEAD)\" | head -n1 | sed 's/.*\\[\\(.*\\)\\].*/\\1/' | sed 's/[\\^~].*//' #"

保存并退出编辑器。

执行命令git parent。

就是这样!

我并不是说这是解决问题的好方法，但这似乎对我来说确实有效:

git branch --contains $(cat .git/ORIG_HEAD)

问题是，隐藏一个文件是窥探Git的内部工作，所以这并不一定是向前兼容(或向后兼容)。

另一个:

git rev-list master | grep "$(git rev-list HEAD)" | head -1

获得最后一个提交，它既是我的分支，也是master(或您想指定的任何分支)。

一个解决方案

解决方案基于git show-branch不太适合我(见下文)，所以我把它与基于git log结合起来，最后得到了这个:

git log --decorate --simplify-by-decoration --oneline \ # selects only commits with a branch or tag
| grep -v "(HEAD" \                               # removes current head (and branch)
| head -n1 \                                      # selects only the closest decoration
| sed 's/.* (\(.*\)) .*/\1/' \                    # filters out everything but decorations
| sed 's/\(.*\), .*/\1/' \                        # picks only the first decoration
| sed 's/origin\///'                              # strips "origin/" from the decoration

限制和注意事项

• 可以分离HEAD(许多CI工具这样做是为了确保它们在给定的分支中构建正确的提交)，但是起源分支和本地分支必须同时是相当于或“高于”和当前HEAD。
• 一定有没有标签在路上(我假设;我还没有测试在子分支和父分支之间使用标签提交的脚本)
• 脚本依赖于“头”总是由log命令变成列为第一装饰这一事实
• 脚本在#EYZ0和develop的结果(大部分)是<SHA> Initial commit

结果

 A---B---D---E---F <-origin/master, master
\      \
\      \
\      G---H---I <- origin/hotfix, hotfix
\
\
J---K---L <-origin/develop, develop
\
\
M---N---O <-origin/feature/a, feature/a
\   \
\   \
\   P---Q---R <-origin/feature/b, feature/b
\
\
S---T---U <-origin/feature/c, feature/c

尽管本地分支存在(例如，只有origin/topic存在，因为提交O是由它的SHA直接签出的)，脚本应该打印如下:

• 对于提交# eyz0， # eyz1， # eyz2(分支hotfix)→master
• 对于提交# eyz0， # eyz1， # eyz2(分支feature/a)→develop
• 对于提交# eyz0， # eyz1， # eyz2(分支feature/c)→develop
• 对于提交# eyz0， # eyz1， # eyz2(分支feature/b)→feature/a
• 对于提交J， K， L(分支develop)→<sha> Initial commit*
• 对于提交B， D， E， F(分支master)→<sha> Initial commit

* -或master如果develop的提交是在master的HEAD的顶部(~ master将是快速前进的开发)

为什么show-branch对我没用

在以下情况下，EYZ1解决方案对我来说并不可靠:

• 分离的头 -包括分离的头部情况意味着取代grep '\*' \为“grep”!——而这只是所有麻烦的开始
• 脚本在#EYZ0和develop的结果分别是develop和' '
• 分支在master分支(hotfix/分支)最终以develop作为父分支，因为它们最近的master分支父分支被标记为!而不是*是有原因的。

当我做了开发→release-v1.0.0→feature-foo这样的事情时，这对我不起作用。它会一直往回发展。请注意，其中涉及到一个基数调整，我不确定这是否加剧了我的问题……

下面给出了正确的提交哈希值:

git log --decorate \
| grep 'commit' \
| grep 'origin/' \
| head -n 2 \
| tail -n 1 \
| awk '{ print $2 }' \
| tr -d "\n"

这是我的PowerShell版本:

function Get-GHAParentBranch {
[CmdletBinding()]
param(
$Name = (git branch --show-current)
)
git show-branch |
Select-String '^[^\[]*\*' |
Select-String -NotMatch -Pattern "\[$([Regex]::Escape($Name)).*?\]" |
Select-Object -First 1 |
Foreach-Object {$PSItem -replace '^.+?\[(.+)\].+$','$1'}
}

git log -2 --pretty=format:'%d' --abbrev-commit | tail -n 1 | sed 's/\s(//g; s/,/\n/g';

(来源/母体名,母体名)

git log -2 --pretty=format:'%d' --abbrev-commit | tail -n 1 | sed 's/\s(//g; s/,/\n/g';

来源/母体名

git log -2 --pretty=format:'%d' --abbrev-commit | tail -n 1 | sed 's/(.*,//g; s/)//';

母体名

基于git show-branch -a加上一些过滤器的解决方案有一个缺点:Git可能会考虑存在时间较短的分支的分支名称。

如果你有一些你关心的潜在父母，你可以问自己类似的问题(可能也是OP想知道的):

从所有分支的特定子集，哪个是最近的父git分支?< / em >

HEAD
important/a
important/b
spam/a
spam/b

for b in $(git branch -a -l "important/*" | sed -E -e "s/\*//"); do
d1=$(git rev-list --first-parent ^${b} HEAD | wc -l);
d2=$(git rev-list --first-parent ^HEAD ${b} | wc -l);
echo "${b} ${d1} ${d2}";
done \
| sort -n -k2 -k3 \
| head -n1 \
| awk '{print $1}';