Git Merge Tutorial: A Comprehensive Guide with Examples

Types of Merges in Git

Understanding Git merge types will help you choose the right strategy for your scenario. Here are the three common approaches to merging. 

Fast-forward merge

When the base branch has no new commits since the feature branch was created, Git uses a fast-forward approach. 

If your new feature branch is updated while the main branch remains unchanged, the merge commit moves the main's head pointer to the feature branch. 

No additional merge commit is created, which keeps the commit history clean and linear.

Three-way merge

If both the base and feature branches have new commits, Git will find their common ancestor and create a new merge commit. This commit combines the histories of both branches, preserving the individual history of the feature branch and the main branch.

In the below example, “E” and “G” are new commits to the main branch after the feature branch was created. 

      C---D---F (feature-branch)
     /         
A---B---E---G (main) 

A new merge commit, “M” is created, preserving the history of both main and feature branches. 

       C---D---F
      /         \
 A---B---E---G---M (main)

Squash merge

Squash merge combines all changes of a feature branch into a single commit and merges it into the target branch. It doesn't preserve the individual commit history of the feature branch. 

git merge --squash feature_branch_name

A squash merge is especially helpful for avoiding clutter from multiple small commits while still retaining the final state of the feature in the target branch.

Merging Multiple Branches

When working on large projects, you might need to merge multiple branches—either one at a time or all at once. The approach you choose depends on your workflow and the complexity of the changes. In this section, I’ll explore both methods and when to use them effectively.

Merging more than one branch sequentially

To merge branches one by one, use the merge command sequentially for each feature branch. 

Step 1: Switch to the target branch into which you want to merge the changes.

git checkout target_branch_name

Step 2: Merge the first feature branch, as shown below.

git merge feature_branch_1

Step 3: Merge the second feature branch as shown.

git merge feature_branch_2

Repeat this process until all other branches are merged.

Merging more than one branch in parallel

Follow these steps to merge multiple feature branches at once.

Step 1: Switch to the target branch into which you want to merge the changes.

git checkout target_branch_name

Step 2: Execute the following command with multiple feature branches 

git merge feature_branch_1 feature_branch_2 feature_branch_3

When Git merges multiple branches in parallel, conflicts may occur. If that happens, Git will prompt you to resolve them manually.

Handling conflicts with multiple merges

Merging multiple branches isn't always straightforward—especially when one branch depends on another. 

For example, merging feature_x into main before feature_y can introduce conflicts. Similarly, if different branches modify the same files, parallel merges can lead to conflicts that need careful resolution.

Follow these steps to resolve merge conflicts:

• Step 1: Execute git status to view what files cause conflicts.
• Step 2: Open the conflicting files and correct them.
• Step 3: Add the changes to the stage and commit.

Understanding merge commit history 

For complex conflicts, you might need more information than what git status provides. In such cases, you can use commands like git log or git show to dig deep into the history.

• git log: shows the entire commit history, including merge commits. This helps identify a specific merge where the issue occurs. 
• git show: If you find a suspicious merge commit from the above command, use git show to inspect it. This command provides a detailed view of the commit, showing what was changed during the merge. It also outputs a unique identifier for the parent branch before a specific merge happens.
• git diff: You can take the unique identifiers of the parent and merged branches from the previous commands and use git diff to compare the changes between these two states.

Git Merging Best practices

Merging can sometimes be messy, especially when multiple developers are working on the same codebase. 

While we've covered how to resolve conflicts when they arise, the best approach is to prevent them before they happen. In this section, we’ll go over practical tips to keep your merges smooth and your Git history clean.

Keep branches small and focused

Large branches increase the risk of overlapping edits, leading to more conflicts. To minimize this, work on a single feature per branch and keep branches small and focused.

Frequently pull and merge

Pull the latest changes from the remote repository to keep your base branch updated before merging. Regularly pull updates from the main branch into your feature branch to keep them in sync. These prevent large and complex conflicts later.

Use Git’s built-in merge tools

Instead of manually editing files, you can use git built-in tools to resolve conflicts in a visual UI. When you run git mergetool, three choices open up:

• LOCAL - Main branch version. Choosing this keeps the conflicting file’s content from the main branch and ignores the changes from the feature branch. 
• REMOTE - The feature branch version. Selecting this applies the feature branch’s content to the conflicting file.
• BASE - This will combine the changes of both branches conflicting files and merge them. 

Merge in order

When merging multiple branches, the order matters—especially if one feature depends on another. If feature_x relies on feature_y, merging feature_x first can introduce conflicts. To avoid this, always merge branches in the order of their dependencies to keep the process smooth and minimize conflicts.

Squash merging 

As mentioned before, squash merging consolidates all commits from a feature branch into a single commit, keeping the commit history clean and reducing potential merge conflicts.

An alternative approach is rebasing, which applies the feature branch changes directly on top of the base branch. This creates a linear history and avoids unnecessary merge commits. However, both methods rewrite history and do not preserve individual commits from the feature branch.

Conclusion

In this Git merge tutorial, we’ve covered everything from the basics of merging to best practices for avoiding conflicts. Understanding how to use git merge effectively helps teams collaborate seamlessly, keeping workflows smooth and code history clean.

If you’re looking to deepen your Git skills, check out this intermediate Git course to master more advanced workflows and techniques!