Merge strategies

Git Merge Strategies: Managing Merge Behaviors

Git provides different merge strategies that allow you to control how changes from different branches are combined. You can select the appropriate merge strategy depending on the structure of the branches and how you want to integrate changes.

1. Default Merge Strategy: Recursive

The default strategy used by Git when merging branches is the recursive strategy. This strategy works well for most scenarios, especially when branches have a common ancestor.

How It Works:

• Git attempts to merge the changes made on both branches by comparing their common ancestor.
• If there are no conflicts, it creates a merge commit that represents the combined changes.
• If there are conflicts, Git will stop and ask you to resolve them manually.

Example:

git merge branch-name

2. No Fast-Forward (--no-ff) Merge

By default, Git uses fast-forward merging when there are no divergent commits between the current branch and the branch being merged. In a fast-forward merge, Git simply moves the pointer of the current branch to the latest commit of the branch being merged.

However, sometimes you may want to force a merge commit, even when a fast-forward merge is possible. This is where the --no-ff (no fast-forward) the option comes in.

Why Use --no-ff:

• It helps preserve the branching history in the commit log, making it clear that a feature or bug fix was worked on in its own branch.
• The merge commit serves as a clear point where the branches were integrated.

Example:

git merge --no-ff branch-name

3. Squash Merge (--squash)

A squash merge combines all the commits from the branch being merged into a single commit before applying them to the current branch. This can be helpful when you want to keep the commit history clean by collapsing a series of small, incremental commits into one final commit.

Why Use --squash:

• You want to combine multiple small commits (like fixing typos or doing trial-and-error work) into a single, cohesive commit that represents the entire feature or fix.
• It is commonly used in pull requests to ensure a cleaner history.

Example:

git merge --squash branch-name

After running this command, you’ll need to commit the changes:

git commit

4. Ours Merge Strategy (--strategy=ours)

The ours strategy is useful when you want to merge a branch into your current branch but keep your current branch’s changes and discard the changes from the other branch.

Why Use --strategy=ours:

• You want to ignore changes from the branch being merged but still record the merge as a commit.
• This strategy is useful when merging a branch that’s no longer necessary, but you still want to log that it was merged.

Example:

git merge --strategy=ours branch-name

5. Theirs Merge Strategy (--strategy=theirs)

The theirs strategy is essentially the opposite of ours. It discards the current branch's changes and keeps the changes from the branch being merged.

Why Use --strategy=theirs:

• You want to keep the changes from the branch you're merging and discard your current branch's changes.
• This is particularly useful in a feature reset, where you want to adopt all changes from another branch and overwrite your branch’s content.

Example:

git merge --strategy=theirs branch-name

6. Octopus Merge Strategy (--strategy=octopus)

The octopus merge strategy is used to merge more than two branches at once. This strategy works well when you want to combine several branches into one.

Why Use --strategy=octopus:

• You need to merge multiple branches simultaneously.
• This strategy is commonly used when dealing with complex projects with many parallel developments.

Example:

git merge --strategy=octopus branch1 branch2 branch3

7. Subtree Merge Strategy (--strategy=subtree)

The subtree strategy is used when merging two projects or subdirectories that have their own separate histories.

Why Use --strategy=subtree:

• You want to merge one repository into another without losing the history of the subproject.
• This is commonly used for integrating submodules or merging separate repositories into a monorepo.

Example:

git merge --strategy=subtree branch-name

8. Summary of Merge Strategies

Strategy	Description	When to Use
Recursive	Default strategy, handles most cases automatically.	Use for normal merging of two branches.
--no-ff	Forces a merge commit even if a fast-forward merge is possible.	Preserve history with explicit merge commits.
--squash	Combines all changes into a single commit before merging.	Clean up commit history (e.g., for pull requests).
--ours	Keep your branch’s changes, discard the merged branch’s changes.	Ignore changes from the merged branch.
--theirs	Keep the merged branch’s changes, discard your changes.	Adopt changes from the merged branch.
--octopus	Merge multiple branches at once.	Use when merging multiple branches simultaneously.
--subtree	Merge two separate projects or subdirectories into one.	Combine projects or submodules into one repo.

9. Conclusion

Git's merge strategies give you flexibility in how you handle integrations between branches. By understanding when and how to use each strategy, you can better manage your project's development and maintain a clean and organized history.

🔹 Need more help with a merge scenario? Let me know! 😊