合并、更新和拉取 Git 分支，无需使用签出

Question

我工作的项目有 2 个分支 A 和 B。我通常在分支 A 上工作，并合并分支 B 中的内容。对于合并，我通常会这样做：

git merge origin/branchB

但是，我还想保留分支的本地副本B，因为我有时可能会在不先与分支 A 合并的情况下检查分支。为此，我会这样做：

git checkout branchB
git pull
git checkout branchA

有没有一种方法可以在一个命令中执行上述操作，而无需来回切换分支？我应该使用 git update-ref 吗？如何？

Answer 1

简短的答案

只要您正在进行快进合并，那么您可以简单地使用

git fetch <remote> <sourceBranch>:<destinationBranch>

示例：

# Merge local branch foo into local branch master,
# without having to checkout master first.
# Here `.` means to use the local repository as the "remote":
git fetch . foo:master

# Merge remote branch origin/foo into local branch foo,
# without having to checkout foo first:
git fetch origin foo:foo

虽然 Amber 的答案 也适用于快进情况，以这种方式使用 git fetch 比仅仅强制移动分支引用更安全，因为 git fetch<只要您不在引用规范中使用 +，/code> 就会自动防止意外的非快进。

长答案

如果不先检查 A，则无法将分支 B 合并到分支 A，否则会导致非快进合并。这是因为需要工作副本来解决任何潜在的冲突。

但是，在快进合并的情况下，这是可能的，因为根据定义，此类合并永远不会导致冲突。要在不先签出分支的情况下执行此操作，您可以将 git fetch 与 refspec 结合使用。

如果您签出另一个分支 feature，则以下是更新 master（不允许非快进更改）的示例：

git fetch upstream master:master

此用例非常常见，因此您将可能想在你的 git 配置文件中为其创建一个别名，如下所示：

[alias]
    sync = !sh -c 'git checkout --quiet HEAD; git fetch upstream master:master; git checkout --quiet -'

这个别名的作用如下：

1. git checkout HEAD：这会将你的工作副本放入分离头中状态。如果您想在签出 master 的同时更新它，这会非常有用。我认为有必要这样做，因为否则 master 的分支引用将不会移动，但我不记得这是否真的是我的想法。

2. git fetchupstreammaster:master：这会将您的本地master快进到与upstream/master相同的位置。

3. git checkout - 签出您之前签出的分支（这就是 - 在本例中的作用）。

用于（非）快进合并的 git fetch 语法

如果您希望 fetch 命令在更新为非快进时失败，那么您只需使用 如果您想允许非快进更新

git fetch <remote> <remoteBranch>:<localBranch>

，则可以在 refspec 的前面添加一个 +：

git fetch <remote> +<remoteBranch>:<localBranch>

请注意，您可以将本地存储库作为“远程”参数传递使用 .：

git fetch . <sourceBranch>:<destinationBranch>

文档

来自 git fetch 文档的 解释这个语法（强调我的）：

<参考规范>

参数的格式是可选的加上 +，后跟源引用 ，然后冒号 :，后跟目标引用 。

获取与 匹配的远程引用，如果 不是空字符串，则获取本地引用匹配使用 快进。如果使用可选的加号 +，则即使不会导致快进更新，也会更新本地引用。

另请参阅

1. Git 签出和合并，无需触及工作树

2. < a href="https://stackoverflow.com/questions/3408532/merging-without-change-the-working-directory">合并而不更改工作目录

Answer 2

不，没有。签出目标分支是必要的，以便您可以解决冲突等问题（如果 Git 无法自动合并它们）。

但是，如果合并是快进的，则不需要检查目标分支，因为您实际上不需要合并任何内容 - 您所要做的就是更新分支以指向新头参考号您可以使用 gitbranch -f 来完成此操作：

git branch -f branch-b branch-a

将更新branch-b以指向branch-a的头部。

-f选项代表--force，这意味着branch-b将被覆盖。

警告：更安全的选择是使用git fetch，它只允许快进。

这个方法可以像这样使用：

git branch -f branch-b branch-b@{Upstream}

或更短地

git branch -f branch-b branch-b@{U}

强制更新分支，而不检查它（假设它们在变基后是否有分歧）

Answer 3

正如 Amber 所说，快进合并是唯一可以做到这一点的情况。可以想象，任何其他合并都需要经历整个三向合并、应用补丁、解决冲突交易——这意味着需要有文件。

我碰巧有一个脚本正好用于此目的：在不接触工作树的情况下进行快进合并（除非您合并到 HEAD 中）。它有点长，因为它至少有点健壮 - 它检查以确保合并将快进，然后在不检查分支的情况下执行它，但产生与您相同的结果 - 你看到diff --stat 更改摘要，并且引用日志中的条目与快进合并完全相同，而不是使用 branch -f。如果将其命名为 git-merge-ff 并将其放入 bin 目录中，则可以将其作为 git 命令调用：git merge-ff。

#!/bin/bash

_usage() {
    echo "Usage: git merge-ff <branch> <committish-to-merge>" 1>&2
    exit 1
}

_merge_ff() {
    branch="$1"
    commit="$2"

    branch_orig_hash="$(git show-ref -s --verify refs/heads/$branch 2> /dev/null)"
    if [ $? -ne 0 ]; then
        echo "Error: unknown branch $branch" 1>&2
        _usage
    fi

    commit_orig_hash="$(git rev-parse --verify $commit 2> /dev/null)"
    if [ $? -ne 0 ]; then
        echo "Error: unknown revision $commit" 1>&2
        _usage
    fi

    if [ "$(git symbolic-ref HEAD)" = "refs/heads/$branch" ]; then
        git merge $quiet --ff-only "$commit"
    else
        if [ "$(git merge-base $branch_orig_hash $commit_orig_hash)" != "$branch_orig_hash" ]; then
            echo "Error: merging $commit into $branch would not be a fast-forward" 1>&2
            exit 1
        fi
        echo "Updating ${branch_orig_hash:0:7}..${commit_orig_hash:0:7}"
        if git update-ref -m "merge $commit: Fast forward" "refs/heads/$branch" "$commit_orig_hash" "$branch_orig_hash"; then
            if [ -z $quiet ]; then
                echo "Fast forward"
                git diff --stat "$branch@{1}" "$branch"
            fi
        else
            echo "Error: fast forward using update-ref failed" 1>&2
        fi
    fi
}

while getopts "q" opt; do
    case $opt in
        q ) quiet="-q";;
        * ) ;;
    esac
done
shift $((OPTIND-1))

case $# in
    2 ) _merge_ff "$1" "$2";;
    * ) _usage
esac

PS如果有人发现该脚本有任何问题，请发表评论！这是一项写完就忘记的工作，但我很乐意改进它。

Answer 4

仅当合并是快进时才可以执行此操作。如果不是，那么 git 需要签出文件，以便合并它们！

仅用于快进：

git fetch <branch that would be pulled for branchB>
git update-ref -m "merge <commit>: Fast forward" refs/heads/<branch> <commit>

其中 是获取的提交，即您想要快进的提交。这基本上就像使用 gitbranch -f 移动分支一样，只不过它还会将其记录在引用日志中，就像您实际进行了合并一样。

请，请，请不要对非快进的内容执行此操作，否则您只是将分支重置为其他提交。 （要进行检查，请查看 git merge-base是否给出了分支的 SHA1。）

Answer 5

在您的情况下，您可以使用

git fetch origin branchB:branchB

which 执行您想要的操作（假设合并是快进的）。如果分支由于需要非快进合并而无法更新，则此操作会安全失败并显示一条消息。

这种形式的获取也有一些更有用的选项：

git fetch <remote> <sourceBranch>:<destinationBranch>

请注意，可以是本地存储库，可以是一个跟踪分支。因此，您可以更新本地分支，即使它尚未签出，无需访问网络。

目前，我的上游服务器访问是通过缓慢的 VPN 进行的，因此我定期连接，git fetch 来更新所有遥控器，然后断开连接。然后，如果远程主控发生了变化，我可以

git fetch . remotes/origin/master:master

安全地将本地主控更新为最新，即使我当前签出了其他一些分支。无需网络访问。

Answer 6

另一种无可否认的相当粗暴的方法是重新创建分支：

git fetch remote
git branch -f localbranch remote/remotebranch

这会丢弃本地过时的分支并重新创建同名的分支，因此请小心使用......

Answer 7

您可以克隆存储库并在新存储库中进行合并。在同一文件系统上，这将硬链接而不是复制大部分数据。通过将结果拉入原始存储库来完成。

Answer 8

输入git-forward-merge：

无需签出目的地，git-forward-merge 将源合并到目标分支。

https://github.com/schuyler1d/git-forward-merge

仅适用于自动合并，如果存在冲突则需要使用常规合并。

Answer 9

对于许多 GitFlow 用户来说，最有用的命令是：

git fetch origin master:master --update-head-ok
git fetch origin dev:dev --update-head-ok

--update-head-ok 标志允许在 dev 或 master 分支上使用相同的命令。

.gitconfig 中的一个方便的别名：

[alias]
    f=!git fetch origin master:master --update-head-ok && git fetch origin dev:dev --update-head-ok

Answer 10

我在这个问题中遗漏了一些东西，如果您无意处理它，为什么需要签出本地 branchB ？在您的示例中，您只想更新本地 branchB，同时保留在 branchA 上？

我最初假设您这样做是为了 fetch origin/branchB，您已经可以使用 git fetch 来做到这一点，所以这个答案实际上是基于这。在您需要处理之前，无需拉取 branchB，并且当您需要从 origin/branchB 合并时，您始终可以获取 origin >。

如果您想跟踪branchB 在某个时间点的位置，您可以从最新获取的origin/branchB 创建一个标签或另一个分支。

因此，您需要从 origin/branchB 合并：

git fetch
git merge origin/branchB

然后下次您需要在 branchB 上工作时：

git checkout branchB
git pull

此时您将获得更新的本地副本。虽然有一些方法可以在不检查的情况下完成此操作，但这种方法很少有用，并且在某些情况下可能不安全。现有的答案涵盖了这一点。

详细答案：

git pull 执行获取+合并。它与下面的两个命令大致相同，其中 通常是 origin （默认），远程跟踪分支以 开头。 / 后跟远程分支名称：

git fetch [<remote>]
git merge @{u}

@{u} 表示法是为当前分支配置的远程跟踪分支。如果 branchB 跟踪 origin/branchB，则来自 branchB 的 @{u} 与输入 origin 相同/branchB （有关更多信息，请参阅 git rev-parse --help）。

由于您已经与 origin/branchB 合并，因此缺少的只是 git fetch （可以从任何分支运行）来更新该远程跟踪分支。

但请注意，如果在拉入本地 branchB 时创建了任何合并，您应该在从 branchB 拉取后将 branchB 合并到 branchA 中。 code>branchB （并最终将更改推送回 orign/branchB，但只要它们快进，它们就会保持不变）。

请记住，本地 branchB 在您切换到它并执行实际拉取之前不会更新，但是只要没有本地提交添加到该分支，它就会保持快进状态远程分支。

Answer 11

对于许多情况（例如合并），您可以只使用远程分支，而无需更新本地跟踪分支。在转发日志中添加一条消息听起来有些过分，而且会阻止它变得更快。为了更容易恢复，请将以下内容添加到您的 git 配置中，

[core]
    logallrefupdates=true

然后键入

git reflog show mybranch

以查看分支的最近历史记录

Answer 12

我为每天在项目中遇到的类似用例编写了一个 shell 函数。这基本上是让本地分支与公共分支保持同步的捷径，例如在打开 PR 之前进行开发等。

即使您不想使用checkout，也要发布此内容，以防其他人不介意该限制。

glmh（“git pull并合并到这里”）会自动checkoutbranchB，pull最新的，重新< code>签出branchA，并合并branchB。

没有解决保留branchA本地副本的需要，但可以通过在签出branchB之前添加一个步骤来轻松修改以实现此目的。
就像...

git branch ${branchA}-no-branchB ${branchA}

对于简单的快进合并，这会跳到提交消息提示。

对于非快进合并，这会将您的分支置于冲突解决状态（您可能需要干预）。

要进行设置，请添加到 .bashrc 或 .zshrc 等：

glmh() {
    branchB=$1
    [ $# -eq 0 ] && { branchB="develop" }
    branchA="$(git branch | grep '*' | sed 's/* //g')"
    git checkout ${branchB} && git pull
    git checkout ${branchA} && git merge ${branchB} 
}

用法：

# No argument given, will assume "develop"
> glmh

# Pass an argument to pull and merge a specific branch
> glmh your-other-branch

注意：这不够足够强大，无法将分支名称之外的参数移交给git merge

Answer 13

只是为了拉出 master 而不检查 master 我使用

git fetch origin master:master

Answer 14

git worktree add [-f] [--detach] [--checkout] [--lock] [-b <new-branch>] <path> [<commit-ish>]

您可以尝试 git worktree 让两个分支打开另一方面，这听起来可能就是您想要的，但与我在这里看到的其他一些答案非常不同。

通过这种方式，您可以在同一个 git 存储库中跟踪两个单独的分支，因此您只需获取一次即可在两个工作树中获取更新（而不是必须 git clone 两次并在每个分支上 git pull）

Worktree 将创建一个新的工作目录对于您的代码，您可以同时签出不同的分支，而不是就地交换分支。

当你想删除它时，你可以用

git worktree remove [-f] <worktree>

Answer 15

有效执行此操作的另一种方法是：

git fetch
git branch -d branchB
git branch -t branchB origin/branchB

因为它是小写的 -d，所以只有当数据仍然存在于某处时才会将其删除。它与 @kkoehne 的答案类似，只是它不强制。由于 -t 它将再次设置遥控器。

我的需求与 OP 略有不同，即在合并拉取请求后，从 develop （或 master）创建一个新功能分支。这可以在不强制的情况下通过一行完成，但它不会更新本地 develop 分支。只需检查一个新分支并使其基于 origin/develop 即可：

git checkout -b new-feature origin/develop

Answer 16

完全可以在没有 git checkout 的情况下进行任何合并，甚至是非快进合并。 @grego 的 worktree 回答是一个很好的提示。扩展一下：

cd local_repo
git worktree add _master_wt master
cd _master_wt
git pull origin master:master
git merge --no-ff -m "merging workbranch" my_work_branch
cd ..
git worktree remove _master_wt

您现在已将本地工作分支合并到本地 master 分支，而无需切换结账。

Answer 17

如果您想保留与要合并的分支之一相同的树（即不是真正的“合并”），您可以这样做。

# Check if you can fast-forward
if git merge-base --is-ancestor a b; then
    git update-ref refs/heads/a refs/heads/b
    exit
fi

# Else, create a "merge" commit
commit="$(git commit-tree -p a -p b -m "merge b into a" "$(git show -s --pretty=format:%T b)")"
# And update the branch to point to that commit
git update-ref refs/heads/a "$commit"

Answer 18

这实际上是我日常工作流程中非常重要的功能。应该记录在这里以供参考。

假设我正在 feat1 分支中工作，但我有一些东西应该提交到 feat2 中，它是当前 HEAD 后面的分支。我曾经执行以下步骤：首先签出 feat2，然后执行 git rebase feat。但这通常会导致我正在运行的开发服务器检测到更改并重新渲染到旧版本，如果您的工作树与当前分支差异太大，通常会崩溃。为了避免工作树发生巨大变化，在停留在分支 feat1 上时，我只需执行 git fetch;:，在上述情况下将是：

git fetch . HEAD:feat2

或

git fetch . feat1:feat2

之后 feat2 将指向与 feat1 相同的提交。然后，您可以安全地签出 feat2，而不会导致开发服务器崩溃。

Answer 19

我使用以下别名：

[alias]
sync = !git fetch && git fetch -u . $(git for-each-ref --format='%(push):%(refname)' refs/heads)

有关详细说明，请参阅 https://stackoverflow.com/a/76267753/9878263

Answer 20

您只需git pull originbranchB到您的branchA中，git就会为您完成任务。