git 的合并策略是什么？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/14243397/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
What are git's merge strategies?
提问by K2xL
Possible Duplicate:
When would you use the different git merge strategies?
可能的重复：
你什么时候会使用不同的 git 合并策略？
When git merges files I'm working on, I see:
当 git 合并我正在处理的文件时，我看到：
Merge made by the 'recursive' strategy
What exactly is the recursive strategy? What other strategies are there (if any)? And what would be the benefit of using one over the other? Do different strategies have different performances? Or could two different strategies result in different merge results?
递归策略究竟是什么？还有哪些其他策略（如果有）？使用一个而不是另一个有什么好处？不同的策略有不同的表现吗？或者两种不同的策略会导致不同的合并结果吗？
采纳答案by dty
From git help merge:
来自git help merge：
The merge mechanism (git-merge and git-pull commands) allows the
backend merge strategies to be chosen with -s option. Some strategies
can also take their own options, which can be passed by giving
-X<option> arguments to git-merge and/or git-pull.
resolve
This can only resolve two heads (i.e. the current branch and
another branch you pulled from) using a 3-way merge algorithm. It
tries to carefully detect criss-cross merge ambiguities and is
considered generally safe and fast.
recursive
This can only resolve two heads using a 3-way merge algorithm. When
there is more than one common ancestor that can be used for 3-way
merge, it creates a merged tree of the common ancestors and uses
that as the reference tree for the 3-way merge. This has been
reported to result in fewer merge conflicts without causing
mis-merges by tests done on actual merge commits taken from Linux
2.6 kernel development history. Additionally this can detect and
handle merges involving renames. This is the default merge strategy
when pulling or merging one branch.
The recursive strategy can take the following options:
ours
This option forces conflicting hunks to be auto-resolved
cleanly by favoring our version. Changes from the other tree
that do not conflict with our side are reflected to the merge
result.
This should not be confused with the ours merge strategy, which
does not even look at what the other tree contains at all. It
discards everything the other tree did, declaring our history
contains all that happened in it.
theirs
This is opposite of ours.
subtree[=path]
This option is a more advanced form of subtree strategy, where
the strategy makes a guess on how two trees must be shifted to
match with each other when merging. Instead, the specified path
is prefixed (or stripped from the beginning) to make the shape
of two trees to match.
octopus
This resolves cases with more than two heads, but refuses to do a
complex merge that needs manual resolution. It is primarily meant
to be used for bundling topic branch heads together. This is the
default merge strategy when pulling or merging more than one
branch.
ours
This resolves any number of heads, but the resulting tree of the
merge is always that of the current branch head, effectively
ignoring all changes from all other branches. It is meant to be
used to supersede old development history of side branches. Note
that this is different from the -Xours option to the recursive
merge strategy.
subtree
This is a modified recursive strategy. When merging trees A and B,
if B corresponds to a subtree of A, B is first adjusted to match
the tree structure of A, instead of reading the trees at the same
level. This adjustment is also done to the common ancestor tree.
