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

发布于 2024-09-08 17:14:09 字数 324 浏览 11 评论 0原文

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

git merge origin/branchB

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

git checkout branchB
git pull
git checkout branchA

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

原文

I work on a project that has 2 branches, A and B. I typically work on branch A, and merge stuff from branch B. For the merging, I would typically do:

git merge origin/branchB

However, I would also like to keep a local copy of branch B, as I may occasionally check out the branch without first merging with my branch A. For this, I would do:

git checkout branchB
git pull
git checkout branchA

Is there a way to do the above in one command, and without having to switch branch back and forth? Should I be using git update-ref for that? How?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

我最亲爱的 2024-09-15 17:14:09

简短的答案

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

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

这个别名的作用如下：

git checkout HEAD：这会将你的工作副本放入分离头中状态。如果您想在签出 master 的同时更新它，这会很有用。我认为有必要这样做，因为否则 master 的分支引用将不会移动，但我不记得这是否真的是我的想法。
git fetchupstreammaster:master：这会将您的本地master快进到与upstream/master相同的位置。
git checkout - 签出您之前签出的分支（这就是 - 在本例中的作用）。

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

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

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

在 refspec 的前面添加一个 +：

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

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

git fetch . <sourceBranch>:<destinationBranch>

文档

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

<参考规范>
参数的格式是可选的加上 +，后跟源引用，然后冒号 :，后跟目标引用。
获取与匹配的远程引用，如果不是空字符串，则获取本地引用匹配使用 快进。如果使用可选的加号 +，则即使不会导致快进更新，也会更新本地引用。

另请参阅

Git 签出和合并，无需触及工作树
< a href="https://stackoverflow.com/questions/3408532/merging-without-change-the-working-directory">合并而不更改工作目录

The Short Answer

As long as you're doing a fast-forward merge, then you can simply use

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

Examples:

# 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

While Amber's answer will also work in fast-forward cases, using git fetch in this way instead is a little safer than just force-moving the branch reference, since git fetch will automatically prevent accidental non-fast-forwards as long as you don't use + in the refspec.

The Long Answer

You cannot merge a branch B into branch A without checking out A first if it would result in a non-fast-forward merge. This is because a working copy is needed to resolve any potential conflicts.

However, in the case of fast-forward merges, this is possible, because such merges can never result in conflicts, by definition. To do this without checking out a branch first, you can use git fetch with a refspec.

Here's an example of updating master (disallowing non-fast-forward changes) if you have another branch feature checked out:

git fetch upstream master:master

This use-case is so common, that you'll probably want to make an alias for it in your git configuration file, like this one:

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

What this alias does is the following:

git checkout HEAD: this puts your working copy into a detached-head state. This is useful if you want to update master while you happen to have it checked-out. I think it was necessary to do with because otherwise the branch reference for master won't move, but I don't remember if that's really right off-the-top of my head.
git fetch upstream master:master: this fast-forwards your local master to the same place as upstream/master.
git checkout - checks out your previously checked-out branch (that's what the - does in this case).

The syntax of `git fetch` for (non-)fast-forward merges

If you want the fetch command to fail if the update is non-fast-forward, then you simply use a refspec of the form

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

If you want to allow non-fast-forward updates, then you add a + to the front of the refspec:

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

Note that you can pass your local repo as the "remote" parameter using .:

git fetch . <sourceBranch>:<destinationBranch>

The Documentation

From the git fetch documentation that explains this syntax (emphasis mine):

<refspec>
The format of a <refspec> parameter is an optional plus +, followed by the source ref <src>, followed by a colon :, followed by the destination ref <dst>.
The remote ref that matches <src> is fetched, and if <dst> is not empty string, the local ref that matches it is fast-forwarded using <src>. If the optional plus + is used, the local ref is updated even if it does not result in a fast-forward update.

我碰巧有一个脚本正好用于此目的：在不接触工作树的情况下进行快进合并（除非您合并到 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如果有人发现该脚本有任何问题，请发表评论！这是一项写完就忘记的工作，但我很乐意改进它。

As Amber said, fast-forward merges are the only case in which you could conceivably do this. Any other merge conceivably needs to go through the whole three-way merge, applying patches, resolving conflicts deal - and that means there need to be files around.

I happen to have a script around I use for exactly this: doing fast-forward merges without touching the work tree (unless you're merging into HEAD). It's a little long, because it's at least a bit robust - it checks to make sure that the merge would be a fast-forward, then performs it without checking out the branch, but producing the same results as if you had - you see the diff --stat summary of changes, and the entry in the reflog is exactly like a fast forward merge, instead of the "reset" one you get if you use branch -f. If you name it git-merge-ff and drop it in your bin directory, you can call it as a git command: 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

P.S. If anyone sees any issues with that script, please comment! It was a write-and-forget job, but I'd be happy to improve it.

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

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（20）

简短的答案

长答案

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

文档

另请参阅

The Short Answer

The Long Answer

The syntax of git fetch for (non-)fast-forward merges

The Documentation

See Also

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

用法：

To setup, add to .bashrc or .zshrc, etc:

Usage:

关于作者

相关话题

热门标签

推荐作者

Gabu-gabumon

qq_CgiN62

荔枝明

赏烟花じ飞满天

独守阴晴ぅ圆缺

¤→小豸慧

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

The syntax of `git fetch` for (non-)fast-forward merges

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

To setup, add to `.bashrc` or `.zshrc`, etc: