如何有选择地合并或选择 Git 中另一个分支的更改？

Question

我正在一个新项目上使用 Git，该项目有两个并行的（但目前是实验性的）开发分支：

• master：导入现有代码库以及我通常确信的一些修改
• exp1：实验分支#1
• exp2：实验分支#2

exp1 和 exp2 代表两种截然不同的架构方法。 在我进一步了解之前，我无法知道哪一个（如果有的话）会起作用。 当我在一个分支中取得进展时，有时我会进行一些在另一分支中有用的编辑，并且想合并这些内容。

将选择性更改从一个开发分支合并到另一个开发分支，同时保留其他所有内容的最佳方法是什么？

我考虑过的方法：

1. git merge --no-commit 然后手动取消暂存大量我不想在分支之间共享的编辑。

2. 手动将常用文件复制到临时目录中，然后通过 git checkout 移动到另一个分支，然后从临时目录中手动复制到工作树中。

3. 上述内容的变体。 暂时放弃 exp 分支并使用两个额外的本地存储库进行实验。 这使得手动复制文件变得更加简单。

所有这三种方法似乎都很乏味且容易出错。 我希望有更好的方法； 类似于过滤器路径参数，可以使 git-merge 更具选择性。

Answer 1

tl;dr

git checkout source_branch -- path/to/file
# resolve conflicts if any
git commit -am '...'

---

我遇到了与您上面提到的完全相同的问题。 但我发现 这更清楚地解释了答案。

摘要：

• 检查要合并的分支的路径，

   $ git checkout source_branch -- <路径>... 
  
    提示：它也可以在没有“--”的情况下工作，如链接帖子中所示。 
    

• 或有选择地合并块

   $ git checkout -p source_branch -- <路径>... 
    

或者，使用重置，然后使用选项添加-p，

    $ git reset <paths>...
    $ git add -p <paths>...

• 最后提交

   $ git commit -m "'合并'这些更改" 
    

Answer 2

您可以使用 cherry-pick 命令从一个分支获取单独的提交。

如果您想要的更改不在单独的提交中，则使用此处显示的方法将提交拆分为单独的提交提交。 粗略地说，您使用 git rebase -i 来编辑原始提交，然后使用 git reset HEAD^ 选择性地恢复更改，然后使用 git commit 来编辑> 将该位作为历史记录中的新提交提交。

红帽杂志中还有另一种不错的方法，他们使用 git add --patch 或可能的 git add --interactive 来允许如果您想将不同的更改拆分为单个文件（在该页面中搜索“拆分”），您可以仅添加大块的一部分。

拆分更改后，您现在可以只选择您想要的更改。

Answer 3

要有选择地将文件从一个分支合并到另一个分支，请运行

git merge --no-ff --no-commit branchX

其中 branchX 是要合并到当前分支的分支。

--no-commit 选项将暂存已被 Git 合并的文件，而不实际提交它们。 这将使您有机会根据需要修改合并的文件，然后自行提交它们。

根据您想要合并文件的方式，有四种情况：

1) 您想要真正的合并。

在这种情况下，您可以按照 Git 自动合并文件的方式接受合并的文件，然后提交它们。

2) 有一些文件您不想合并。

例如，您希望保留当前分支中的版本并忽略要合并的分支中的版本。

要选择当前分支中的版本，请运行：

git checkout HEAD file1

这将检索当前分支中 file1 的版本，并覆盖 Git 自动合并的 file1 。

3）如果你想要branchX中的版本（而不是真正的合并）。

运行：

git checkout branchX file1

这将检索 branchX 中 file1 的版本，并覆盖 Git 自动合并的 file1。

4) 最后一种情况是如果您只想选择 file1 中的特定合并。

在这种情况下，您可以直接编辑修改后的 file1，将其更新为您想要的 file1 版本，然后提交。

如果 Git 无法自动合并文件，它会将该文件报告为“未合并”并生成一个副本，您需要在其中手动解决冲突。

---

为了进一步解释，假设您要将 branchX 合并到当前分支：

git merge --no-ff --no-commit branchX

然后运行 ​​git status 命令来查看修改文件的状态。

例如：

git status

# On branch master
# Changes to be committed:
#
#       modified:   file1
#       modified:   file2
#       modified:   file3
# Unmerged paths:
#   (use "git add/rm <file>..." as appropriate to mark resolution)
#
#       both modified:      file4
#

其中 file1、file2 和 file3 是 git 已成功自动合并的文件。

这意味着所有这三个文件的 master 和 branchX 中的更改已合并在一起，没有任何冲突。

您可以通过运行 git diff --cached 来检查合并是如何完成的；

git diff --cached file1
git diff --cached file2
git diff --cached file3

如果你发现某些合并不合需要，那么你可以

1. 直接编辑文件
2. save
3. git commit

如果你不想合并 file1 并希望保留当前分支中的版本

运行

git checkout HEAD file1

如果您不想合并 file2 而只想合并 branchX 中的版本

Run

git checkout branchX file2

如果您希望自动合并 file3，则不要做任何事情。

此时 Git 已经将其合并了。

上面的

file4 是 Git 合并失败的结果。 这意味着同一行上的两个分支都发生了变化。 这是您需要手动解决冲突的地方。 您可以通过直接编辑文件或运行您想要 file4 成为的分支中的版本的 checkout 命令来放弃合并完成的内容。

最后，不要忘记git commit。

Answer 4

我不喜欢上述方法。 使用cherry-pick 非常适合挑选单个更改，但如果您想引入除了一些不好的更改之外的所有更改，那就很痛苦了。 这是我的方法。

没有可以传递给 git merge 的 --interactive 参数。

这是另一种选择：

您在分支“功能”中进行了一些更改，并且您希望以一种不马虎的方式将其中一些但不是全部更改到“主”（即您不想挑选并提交每个更改）

git checkout feature
git checkout -b temp
git rebase -i master

# Above will drop you in an editor and pick the changes you want ala:
pick 7266df7 First change
pick 1b3f7df Another change
pick 5bbf56f Last change

# Rebase b44c147..5bbf56f onto b44c147
#
# Commands:
# pick = use commit
# edit = use commit, but stop for amending
# squash = use commit, but meld into previous commit
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#

git checkout master
git pull . temp
git branch -d temp

因此，只需将其包装在 shell 脚本中，将 master 更改为 $to 并将 feature 更改为 $from 即可：

#!/bin/bash
# git-interactive-merge
from=$1
to=$2
git checkout $from
git checkout -b ${from}_tmp
git rebase -i $to
# Above will drop you in an editor and pick the changes you want
git checkout $to
git pull . ${from}_tmp
git branch -d ${from}_tmp

Answer 5

还有另一种方法：

git checkout -p

它是 git checkout 和 git add -p 之间的混合，可能正是您正在寻找的东西：

   -p, --patch
       Interactively select hunks in the difference between the <tree-ish>
       (or the index, if unspecified) and the working tree. The chosen
       hunks are then applied in reverse to the working tree (and if a
       <tree-ish> was specified, the index).

       This means that you can use git checkout -p to selectively discard
       edits from your current working tree. See the “Interactive Mode”
       section of git-add(1) to learn how to operate the --patch mode.

Answer 6

虽然其中一些答案非常好，但我觉得没有一个真正回答了OP的原始约束：从特定分支中选择特定文件。 这个解决方案可以做到这一点，但如果有很多文件，它可能会很乏味。

假设您有 master、exp1 和 exp2 分支。 您想要将每个实验分支中的一个文件合并到 master 中。 我会做这样的事情：

git checkout master
git checkout exp1 path/to/file_a
git checkout exp2 path/to/file_b

# Save these files as a stash
git stash

# Merge stash with master
git merge stash

这将为您提供您想要的每个文件的文件内差异。 而已。 一点也没有少。 在版本之间进行完全不同的文件更改非常有用 - 就我而言，从 Ruby on Rails 2 到 Ruby on Rails 3。

这将合并文件，但它会进行智能合并。 我无法弄清楚如何使用此方法来获取文件内差异信息（也许对于极端差异仍然如此。除非您使用 -s recursive -X ，否则像空格这样烦人的小东西会被合并回来忽略所有空格选项）

Answer 7

1800 条信息答案是完全正确的。 不过，作为 Git 的新手，“使用 gitcherry-pick”不足以让我在没有在互联网上进行更多挖掘的情况下弄清楚这一点，所以我想我应该发布一个更详细的指南，以防其他人在类似的船上。

我的用例是希望有选择地将更改从其他人的 GitHub 分支拉到我自己的分支中。 如果您已经有一个进行了更改的本地分支，则只需执行步骤 2 和 5-7。

1. 使用您想要引入的更改创建（如果未创建）本地分支。

   $ gitbranch mybranch <基本分支>

2. 切换到它。

   $ git checkout mybranch

3. 从其他人的帐户中提取您想要的更改。 如果您还没有添加，您需要将它们添加为遥控器。

   $ git remote add repos-w-changes

4. 从其分支中拉取所有内容。

   $ git pull repos-w-changes 分支-i-want

5. 查看提交日志以查看您想要哪些更改：

   $ git 日志

6. 切换回要将更改拉入的分支。

   $ git checkoutoriginalbranch

7. 用哈希值逐一挑选您的提交。

   $ gitcherry-pick -x 提交哈希

帽子提示：http://www.sourcemage.org/Git_Guide（存档副本）

Answer 8

以下是如何将 master 分支中的 Myclass.java 文件替换为 feature1 分支中的 Myclass.java 文件。 即使 Myclass.java 在 master 上不存在，它也会工作。

git checkout master
git checkout feature1 Myclass.java

请注意，这将覆盖（而不是合并）并忽略主分支中的本地更改。

Answer 9

简单的方法是实际合并两个分支中的特定文件，而不仅仅是用另一个分支中的文件替换特定文件。

第一步：比较分支

git diff branch_b > my_patch_file.patch

创建当前分支和 branch_b 之间差异的补丁文件。

第二步：在与模式匹配的文件上应用补丁

git apply -p1 --include=pattern/matching/the/path/to/file/or/folder my_patch_file.patch

有关选项的有用注释

您可以在包含模式中使用 * 作为通配符。

斜杠不需要转义。

另外，您可以使用 --exclude 代替，并将其应用于除与模式匹配的文件之外的所有内容，或者使用 -R 反转补丁。

-p1 选项是 *Unix patch 命令的延续，补丁文件的内容在每个文件名前面加上 a/ 或b/ （或更多，取决于补丁文件的生成方式），您需要将其剥离，以便它可以找出真正的文件到需要应用补丁的文件的路径。

查看 git-apply 的 man 页面了解更多选项。

第三步：没有第三步

显然您想要提交更改，但是谁敢说您在提交之前不需要做一些其他相关的调整。

Answer 10

以下是如何让历史记录以最少的麻烦跟踪来自另一个分支的几个文件，即使更“简单”的合并会带来更多您不想要的更改。

首先，您将采取不寻常的步骤，提前声明您将要提交的是合并，而 Git 不会对工作目录中的文件执行任何操作：

git merge --no-ff --no-commit -s ours branchname1

...其中“branchname”是您声明的任何内容合并自。 如果您立即提交，它将不会进行任何更改，但它仍然会显示来自另一个分支的血统。 如果需要，您还可以向命令行添加更多分支、标签等。 但此时，没有要提交的更改，因此接下来从其他修订版中获取文件。

git checkout branchname1 -- file1 file2 etc.

如果您要从多个其他分支合并，请根据需要重复。

git checkout branchname2 -- file3 file4 etc.

现在，来自另一个分支的文件位于索引中，准备提交并具有历史记录。

git commit

您将在该提交消息中进行大量解释。

但请注意，如果不清楚的话，这是一件混乱的事情。 这不符合“分支”的精神，而樱桃挑选是一种更诚实的方式来完成您在这里要做的事情。 如果您想对上次未引入的同一分支上的其他文件进行另一次“合并”，它将阻止您并显示“已经是最新的”消息。 这是我们应该有分支时却没有分支的一种症状，因为“来自”分支应该是多个不同的分支。

Answer 11

最简单的方法是将存储库设置为要合并的分支，然后运行

git checkout [branch with file] [path to file you would like to merge]

如果运行，

git status

您将看到文件已经暂存...

然后运行

git commit -m "Merge changes on '[branch]' to [file]"

​​Simple。

Answer 12

这是我合并选择性文件的工作流程。

# Make a new branch (this will be temporary)
git checkout -b newbranch

# Grab the changes
git merge --no-commit  featurebranch

# Unstage those changes
git reset HEAD
(You can now see the files from the merge are unstaged)

# Now you can chose which files are to be merged.
git add -p

# Remember to "git add" any new files you wish to keep
git commit

Answer 13

我发现 这篇文章包含最简单的答案。 只需执行以下操作：

git checkout <branch from which you want files> <file paths>

示例

将 .gitignore 文件从branchB 拉入当前分支：

git checkout branchB .gitignore

有关更多信息，请参阅帖子。

Answer 14

这并不完全是您正在寻找的内容，但它对我很有用：

git checkout -p <branch> -- <paths> ...

它是一些答案的混合。

Answer 15

我遇到了与您上面提到的完全相同的问题。 但我发现 这个 Git 博客 更清楚地解释了答案。

来自上面链接的命令：

# You are in the branch you want to merge to
git checkout <branch_you_want_to_merge_from> <file_paths...>

Answer 16

对我来说， git reset --softbranch 是有选择地从另一个分支中选择更改的最简单方法，因为该命令将所有差异更改放入我的工作树中，并且我可以轻松地选择或恢复我需要的那个。

这样，我就可以完全控制提交的文件。

Answer 17

我会做一个

git diff commit1..commit2 文件模式 | git-apply --index && git 提交

通过这种方式，您可以限制分支中文件模式的提交范围。

它是从 Re：如何仅拉取从一个分支到另一个分支的文件很少？

Answer 18

您可以使用read-tree读取给定的远程树或将其合并到当前索引中，例如：

git remote add foo [email protected]/foo.git
git fetch foo
git read-tree --prefix=my-folder/ -u foo/master:trunk/their-folder

要执行合并，请改用-m。

另请参阅：如何在 Git 中合并子目录？

Answer 19

我喜欢上一个“git-interactive-merge”答案，但还有一个更简单的答案。 让 Git 使用 Interactive 和 Onto 的变基组合为您完成此操作：

      A---C1---o---C2---o---o feature
     /
----o---o---o---o master

因此，您需要来自“feature”分支（分支点“A”）的 C1 和 C2，但目前不需要其他分支。

# git branch temp feature
# git checkout master
# git rebase -i --onto HEAD A temp

正如前面的答案，您将进入交互式编辑器，在其中选择 C1 和 C2 的“选择”行（如上所述）。 保存并退出，然后它将继续进行变基并为您提供分支“temp”以及 master + C1 + C2 处的 HEAD：

      A---C1---o---C2---o---o feature
     /
----o---o---o---o-master--C1---C2 [HEAD, temp]

然后您可以将 master 更新为 HEAD 并删除临时分支，然后就可以了：

# git branch -f master HEAD
# git branch -d temp

Answer 20

我编写了自己的名为“pmerge”的脚本来部分合并目录。 这是一项正在进行的工作，我仍在学习 Git 和 Bash 脚本。

此命令使用 git merge --no-commit ，然后取消应用与提供的路径不匹配的更改。

用法：git pmerge 分支路径
示例： git mergedevelop src/

我还没有对其进行广泛的测试。 工作目录应该没有任何未提交的更改和未跟踪的文件。

#!/bin/bash

E_BADARGS=65

if [ $# -ne 2 ]
then
    echo "Usage: `basename $0` branch path"
    exit $E_BADARGS
fi

git merge $1 --no-commit
IFS=
\n'

# List of changes due to merge | replace nulls with newlines | strip lines to just filenames | ensure lines are unique
for f in $(git status --porcelain -z -uno | tr '\000' '\n' | sed -e 's/^[[:graph:]][[:space:]]\{1,\}//' | uniq); do
    [[ $f == $2* ]] && continue
    if git reset $f >/dev/null 2>&1; then
        # Reset failed... file was previously unversioned
        echo Deleting $f
        rm $f
    else
        echo Reverting $f
        git checkout -- $f >/dev/null 2>&1
    fi
done
unset IFS

Answer 21

按文件选择性合并/提交的简单方法：

git checkout dstBranch
git merge srcBranch

// Make changes, including resolving conflicts to single files
git add singleFile1 singleFile2
git commit -m "message specific to a few files"
git reset --hard # Blow away uncommitted changes

Answer 22

如果您没有太多已更改的文件，那么您将无需进行额外的提交。

1. 暂时复制分支
$ git checkout -b temp_branch

2. 重置为最后想要的提交
所需的提交次数

$ git reset --hard HEAD~n，其中 n 是返回3 。 从原始分支检出每个文件
$ git checkout origin/original_branch filename.ext

现在，如果需要，您可以提交并强制推送（以覆盖远程）。

Answer 23

如果您只需要合并特定目录并保持其他所有内容不变并保留历史记录，您可以尝试此操作...在 master 上创建一个新的 target-branch > 在进行实验之前。

以下步骤假设您有两个分支 target-branch 和 source-branch，以及要合并的目录 dir-to-merge位于源分支中。 另外，假设您不想更改目标中的其他目录并保留历史记录，例如 dir-to-retain 。 另外，假设 dir-to-merge 中存在合并冲突。

git checkout target-branch
git merge --no-ff --no-commit -X theirs source-branch
# the option "-X theirs", will pick theirs when there is a conflict. 
# the options "--no--ff --no-commit" prevent a commit after a merge, and give you an opportunity to fix other directories you want to retain, before you commit this merge.

# the above, would have messed up the other directories that you want to retain.
# so you need to reset them for every directory that you want to retain.
git reset HEAD dir-to-retain
# verify everything and commit.

Answer 24

当两个分支的当前提交之间只有几个文件发生更改时，我通过遍历不同的文件来手动合并更改。

git difftool..

另请参阅
https://sites.google.com/site/icusite/setup/git-差异工具

Answer 25

我找到了这个问题的解决方案，它非常漂亮并且可以解决这个问题。 简单化。 所以我只是把它留在这里给我自己& 其他想要使用此解决方案的人。

回答
假设我位于 branch1 中，其中包含单个文件 file1.txt
现在，我想要将 file1.txt 与 branch2 中的另一个文件 file2.txt 一起使用。
所以命令应该是，

git checkout --patch branch2 <path_of_file2.txt_in_context_of_branch2>

它会提示控制台提示您需要输入特定字符以反映当前分支（branch1）中的更改。 有时我用a来接受所有的帅哥。

我希望这个答案有帮助。
谢谢

Answer 26

这会将 @masukomi 的 diff/apply answer 改编为一个 - liner：

git diff HEAD...other_branch -- path/to/file | git apply

您位于 my_cool_branch 分支上。
您想要从 other_branch 获取某些内容。

你们都修改了path/to/file。
您想要这些更改，但又不想抹掉自己的更改。

这会比较path/to/file的更改方式（通过diff），然后暂存这些更改（通过apply），没有承诺。

====

存在一个更简单的场景。

您需要来自 other_branch 的 path/to/file 文件。
您的分支没有修改path/to/file。

在这种情况下，您只需获取该分支的文件快照即可：

git checkout other_branch -- path/to/file

这将进行一项更改，修改 path/to/file 以匹配 other_branch 中的内容。
没有创建提交。 您拥有的任何其他暂存更改仍将保持暂存状态。
您不切换分支（即使使用了checkout< /a>）。

通常，这会删除您自己对文件所做的更改，因此只有在我们知道不会丢失任何更改时才应该这样做。

Answer 27

我将集中精力解决我感兴趣的这个问题的子集：我有两个分支，我想将一个文件从一个分支伪合并到另一个分支。

（我说“伪合并”是因为我不需要或想要合并提交；我只想以我认为合适的方式组合文件两个版本的贡献。）

我的方法基于https://stackoverflow.com/a/39916536/341994 中采用的方法。 不幸的是，这个问题被作为重复项关闭（在我看来，这是错误的：它不是这个问题的重复项，并且回答并关闭为重复项是错误的，这就是回答者在那里所做的）。 但这个答案有一些问题，所以我对这个方法进行了现代化和清理。 我使用 restore，而不是 checkout 和 reset，而且我也懒得提交任何不需要的内容。

好吧，假设我有三个文件：

$ ls
a   b   f

但我只想从 otherbranch 伪合并其中一个，a。 让我们看一下它们，看看情况会是什么样子。 这是我的版本：

$ cat a
line one
line two
line three
line four
line five

这是其他分支的版本：

$ git show otherbranch:a
line one
line two edited
line three
line four
line five
line six

现在这里的技巧是我们将使用索引作为便笺簿（毕竟，这就是它的用途）。 因此，我们首先（第 1 步）确保我们的版本已复制到索引中：

$ git add a

现在（第 2 步）我们可以使用 restore 从 otherbranch 获取版本（现在，restore 比 checkout 更好，因为它让我们可以更清楚地交谈）：

$ git restore --source otherbranch a

乍一看，这看起来很糟糕。 我们现在已经用 otherbranch 的版本完全覆盖了 a，如您所见：

$ cat a
line one
line two edited
line three
line four
line five
line six

但不用担心！ 之前版本的 a 仍在索引中，如您所见：

$ git diff a
diff --git a/a b/a
index abf51fa..333614b 100644
--- a/a
+++ b/a
@@ -1,6 +1,7 @@
 line one
-line two
+line two edited
 line three
 line four
 line five
+line six

很好，现在我们已准备好进行关键操作（步骤 3）。 我们对文件从工作树到索引进行交互式补丁 添加。

我们可以说 git add -p a 来启动交互式补丁过程，在这种情况下，我们一次会得到一个块。 但在这种情况下，只有一个大块，无论如何我都想编辑它，所以我说：

$ git add --e a

结果是我们在编辑器中打开了一个差异补丁文件！ 它看起来像这样：

 line one
-line two
+line two edited
 line three
 line four
 line five
+line six

通过仔细编辑，我们现在可以决定我们想要接受哪些部分以及我们不接受哪些部分。 让我们接受“第六行”，但不接受“第二行已编辑”。 因此，我们进行编辑，如下所示：

 line one
 line two
 line three
 line four
 line five
+line six

我们关闭编辑器，并将补丁应用于 a 的索引版本。 但我们还没有完全完成！ a 的 otherbranch 版本仍然位于工作树中：

$ cat a
line one
line two edited
line three
line four
line five
line six

我们喜欢的版本在索引中，还记得吗？ 为了得到它，（第 4 步）我们只需简单明了地调用 git Restore （同样，这是现代方式；restore 比 reset 更好）并且可以应用于单个文件）：

$ git restore a

现在我们的a是正确的，我们都完成了：

$ cat a
line one
line two
line three
line four
line five
line six

我们可以在这一点上提交，但我们不必这样做； 我们已经完成了我们计划完成的任务。

Answer 28

我想要的：以交互方式从分支（有几个混乱的提交）中挑选大块到新分支中的干净提交中。

如果该 diff 中有任何二进制文件，则 git diff + git apply 将不起作用。

我的做法：

# New branch from a clean starting point, e.g. master
git checkout new-clean-branch origin/master

# Get all changes from the messy branch
# (quote the star so your shell doesn't expand it)
git checkout messy-branch -- '*'

# Unstage ("un-add") everything
git restore --staged .

# Interactively add hunks to be staged for commit
git add -p

Answer 29

如果您是 Gitkraken 用户这里有一个小指南

总之：

1. 移动到您想要进行更改的分支。 （例如develop）
2. 右键单击有新更改的分支并选择“cherrypick commit”选项（例如feature-ABC）。
3. 最后接受并检查是否有冲突。