我在一个新项目上使用git，该项目有两个并行的但目前仍处于试验阶段的开发分支：

• master：导入现有的代码库以及一些我通常确定的mod
• exp1：实验部门1
• exp2：实验部门2

exp1并exp2代表两种截然不同的架构方法。直到我步入正轨，我才知道哪一个（如果有的话）会工作。当我在一个分支中取得进展时，有时我会进行一些编辑，而这些编辑在另一分支中将非常有用，并且希望将这些合并。

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

我考虑过的方法：

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

2. 手动将公用文件复制到temp目录中，然后git checkout移动到另一个分支，然后从temp目录中进行更多手动复制到工作树中。

3. 上面的变化。exp现在放弃分支，并使用另外两个本地存储库进行实验。这使得手动复制文件更加简单。

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

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

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

在Red Hat Magazine中，还有另一种不错的方法，如果您想将不同的更改拆分到单个文件中（在该页面中搜索“ split”），它们可以使用git add --patch或可能git add --interactive只添加部分块。

拆分更改后，您现在可以选择所需的内容。

我遇到了与您上面提到的完全相同的问题。但是我在解释答案时发现了这一点。

摘要：

• 从您要合并的分支中签出路径，

  $ git checkout source_branch -- <paths>...
  

  提示：它也可以--在链接文章中不显示的情况下工作。

• 或有选择地合并大块

  $ git checkout -p source_branch -- <paths>...
  

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

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

• 最后提交

  $ git commit -m "'Merge' these changes"
  

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

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

branchX您要合并到当前分支的分支在哪里？

该--no-commit选项将暂存由Git合并的文件，而不实际提交它们。这将使您有机会修改所需的合并文件，然后自己提交。

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

1）您想要一个真正的合并。

在这种情况下，您将接受合并文件，就像Git自动合并它们然后提交它们一样。

2）有些文件您不想合并。

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

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

git checkout HEAD file1

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

3）如果要在branchX中使用版本（而不是真正的合并）。

跑：

git checkout branchX file1

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

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. 救
3. git commit

如果您不想合并，file1并且希望将版本保留在当前分支中

跑

git checkout HEAD file1

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

跑

git checkout branchX file2

如果要file3自动合并，请不要执行任何操作。

Git现在已经将其合并。

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

最后，不要忘了git commit。

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

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

这是替代方法：

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

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

还有另一种方法：

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.

尽管其中一些答案相当不错，但我觉得没有一个人能够真正回答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

这将为您提供每个文件所需的文件内差异。而已。没什么。在版本之间进行完全不同的文件更改很有用-就我而言，将应用程序从Rails 2更改为Rails 3。

编辑：这将合并文件，但会进行智能合并。我无法弄清楚如何使用此方法来获取文件中的差异信息（也许仍然会存在极大差异。除非您使用此-s recursive -X ignore-all-space选项，否则讨厌的小东西（如空格）会重新合并进来）

1800 INFORMATION的答案是完全正确的。但是，作为一个git noob，“使用git cherry-pick”还不足以让我在互联网上不加更多挖掘的情况下解决这个问题，因此，我想我会发布更详细的指南，以防其他人陷入困境。类似的船。

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

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

   $ git branch mybranch <base branch>

2. 切换到它。

   $ git checkout mybranch

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

   $ git remote add repos-w-changes <git url>

4. 从他们的分支下拉所有。

   $ git pull repos-w-changes branch-i-want

5. 查看提交日志以查看所需的更改：

   $ git log

6. 切换回您想要将更改放入的分支。

   $ git checkout originalbranch

7. Cherry用哈希值一个接一个地选择提交。

   $ git cherry-pick -x hash-of-commit

帽子提示：http : //www.sourcemage.org/Git_Guide

这是如何用in 分支替换branch 中的Myclass.java文件的方法。即使不存在，它也将起作用。masterMyclass.javafeature1Myclass.javamaster

git checkout master
git checkout feature1 Myclass.java

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

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

第一步：区分分支

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以获得更多选项。

第三步：没有第三步

显然，您想提交更改，但是谁说您在进行提交之前没有其他相关的调整。

通过这种方法，即使更“简单”的合并会带来很多您不希望的更改，也可以使历史记录仅跟踪来自另一个分支的几个文件，而不会造成太大的麻烦。

首先，您将采取非同寻常的步骤，即预先声明要提交的内容是合并，而git根本不对工作目录中的文件做任何事情：

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

。。。其中“分支名称”是您声称要合并的内容。如果您要立即提交，则不会进行任何更改，但仍会显示来自另一个分支的祖先。您可以添加更多分支/标签/等。如果需要，也可以使用命令行。但是，此时没有要提交的更改，因此接下来从其他修订版获取文件。

git checkout branchname1 -- file1 file2 etc

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

git checkout branchname2 -- file3 file4 etc

现在，来自另一个分支的文件已包含在索引中，随时可以提交，并带有历史记录。

git commit

并且您将在该提交消息中进行很多说明。

但是请注意，以防万一，这是很麻烦的事情。这并不是出于“分支”的目的，而在这里摘樱桃是一种更诚实的方式来做您想做的事情。如果您想对上次未带过的同一分支上的其他文件进行另一次“合并”，则会显示“已经更新”消息，从而阻止您。这是我们不应该分支时的一种症状，在“ from”分支中应该有多个不同的分支。

我知道我来晚了一点，但这是我合并选择性文件的工作流程。

#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

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

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

如果你跑

git status

您将看到文件已经上演...

然后跑

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

简单。

我发现这篇文章包含最简单的答案。只做：

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

例：

$ #pulling .gitignore file from branchB into current branch
$ git checkout branchB .gitignore

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

奇怪的是，git仍然没有“开箱即用”的便捷工具。当仅通过当前版本分支的一些错误修正来更新某些旧版本分支（仍然有大量软件用户）时，我会大量使用它。在这种情况下，通常需要从主干中的文件中快速获取一些代码行，而忽略了许多其他更改（这些更改不应该在旧版本中使用）...当然还有交互式三向合并在这种情况下需要git checkout --patch <branch> <file path>使用，而不可用于此选择性合并目的。

您可以轻松做到：

只需将此行添加到[alias]全局.gitconfig或本地.git/config文件中的部分：

[alias]
    mergetool-file = "!sh -c 'git show $1:$2 > $2.theirs; git show $(git merge-base $1 $(git rev-parse HEAD)):$2 > $2.base; /C/BCompare3/BCompare.exe $2.theirs $2 $2.base $2; rm -f $2.theirs; rm -f $2.base;' -"

这意味着您使用了超越比较。如果需要，只需更改为您选择的软件即可。或者，如果不需要交互式选择性合并，则可以将其更改为三向自动合并：

[alias]
    mergetool-file = "!sh -c 'git show $1:$2 > $2.theirs; git show $(git merge-base $1 $(git rev-parse HEAD)):$2 > $2.base; git merge-file $2 $2.base $2.theirs; rm -f $2.theirs; rm -f $2.base;' -"

然后像这样使用：

git mergetool-file <source branch> <file path>

这将为您提供其他分支中任何文件的真正的选择性树方式合并机会。

它并不是您要找的东西，但对我很有用：

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

它是一些答案的混合。

我会做一个

git diff commit1..commit2文件模式| git-apply --index和＆git commit

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

被盗：http：//www.gelato.unsw.edu.au/archives/git/0701/37964.html

我遇到了与您上面提到的完全相同的问题。但是我在解释答案时发现这个git博客更加清晰。

来自以上链接的命令：

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

我喜欢上面的“ git-interactive-merge”答案，但有一个更简单。让git使用交互式和以下的rebase组合为您完成此操作：

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

因此，情况是您希望C1和C2来自“功能”分支（分支点“ A”），但目前尚无其他。

# 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并删除temp分支，您可以开始以下工作：

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

那git reset --soft branch呢 我很惊讶没有人提及它。

对我来说，这是从另一分支中选择性地选择更改的最简单方法，因为此命令将所有diff更改放入我的工作树中，因此我可以轻松地选择或还原所需的内容。这样，我可以完全控制提交的文件。

我知道这个问题很旧，还有很多其他答案，但是我写了自己的脚本“ pmerge”来部分合并目录。这项工作仍在进行中，我仍在学习git和bash脚本。

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

用法：git pmerge branch path
示例：git merge develop 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 w 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

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

git remote add foo git@example.com/foo.git
git fetch foo
git read-tree --prefix=my-folder/ -u foo/master:trunk/their-folder

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

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

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

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

如果您没有太多更改的文件，这将使您没有多余的提交。

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

2.重置为上一次所需的提交
$ git reset --hard HEAD~n，这n是您需要返回的提交数量

3.从原始分支检出每个文件
$ git checkout origin/original_branch filename.ext

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

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

以下步骤假定您有两个分支target-branch和source-branch，并且dir-to-merge要合并的目录位于中source-branch。还要假设您还有其他目录，例如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.

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

git difftoll <branch-1>..<branch-2>