How to Merge Two Branches in Git?

In Git, merging two branches is a common task that integrates changes from one branch into another. This process is critical for collaborative software development, as it combines work from different branches while preserving each branch’s history and changes.

This post will walk you through how to merge two branches in Git, addressing different scenarios and best practices to ensure a smooth merging experience.

Why Merge Branches in Git?

1. Integrate Features: Bring together work from multiple branches, such as feature branches into the main branch.
2. Collaborate with Team Members: Combine code from team members working in separate branches.
3. Manage Codebase Quality: Ensure that changes are integrated and tested before being merged into production-ready branches.

---

Prerequisites

1. Basic Git Knowledge: Familiarity with basic Git commands and Git branching is helpful.
2. Git Installed: Ensure Git is installed on your machine. Download Git here.
3. Repository Set Up: Have a Git repository with at least two branches to merge.

---

Types of Git Merges

Git provides two main methods of merging branches:

1. Fast-Forward Merge: When the target branch has no additional commits beyond the current branch, Git applies a fast-forward merge, simply moving the branch pointer to the latest commit.
2. Three-Way Merge: When both branches have diverged, Git creates a new “merge commit” to reconcile changes from both branches.

---

Step-by-Step Guide to Merging Two Branches in Git

Let’s walk through merging two branches, assuming we have a feature branch that we want to merge into the main branch.

Step 1: Check Out the Target Branch

First, switch to the branch you want to merge into, which is typically the main branch:

git checkout main

Step 2: Pull the Latest Changes (if working with a remote repository)

If you are collaborating on a remote repository, pull the latest changes to ensure you’re working with the latest code:

git pull origin main

Step 3: Merge the Source Branch into the Target Branch

To merge the feature branch into main, run:

git merge feature

If there are no conflicts, Git will complete the merge, and you’ll see a message indicating a successful merge.

---

Handling Merge Conflicts

Merge conflicts occur when Git can’t automatically reconcile changes between branches. If conflicts arise during the merge, Git will display a list of files with conflicts and mark them in the code.

Step 1: Identify Conflicts

Git will list the conflicted files in your terminal after you run the merge command. You can also check which files have conflicts by using:

git status

Step 2: Resolve Conflicts Manually

Open each conflicted file in a text editor, and look for conflict markers (<<<<<<, ======, >>>>>>). Manually edit the code to resolve the conflicts by choosing which lines to keep or combining both changes as needed.

Step 3: Stage Resolved Files

Once conflicts are resolved, stage the changes:

git add <filename>

Step 4: Complete the Merge with a Commit

After resolving and staging all conflicts, finalize the merge with a commit:

git commit

Git will prompt you to enter a message for the merge commit if you haven’t set one. Save and close the commit message to complete the merge.

---

Optional: Pushing the Merged Branch to a Remote Repository

If you’re working with a remote repository and want to share the merged branch with collaborators, push it to the remote repository:

git push origin main

Replace main with the branch name if you’re merging into a different branch.

---

Alternative: Using Rebase to Incorporate Changes

In some workflows, you might use rebase instead of merge to keep a linear history. With rebase, you apply the commits from one branch on top of another, creating a cleaner commit history.

Example of Rebasing feature onto main:

git checkout feature
git rebase main

After rebasing, switch to the main branch and merge the feature branch as usual.

---

Best Practices for Merging Branches

1. Merge Frequently: Regularly merge changes to avoid complex conflicts and reduce the risk of large, unmanageable merges.
2. Use Feature Branches: Keep each new feature in a separate branch and merge it into the main branch only after it’s complete and tested.
3. Pull Before Merging: Always pull the latest changes from the target branch before merging to avoid conflicts.
4. Communicate with Your Team: Make sure all collaborators know when you’re merging branches, especially if it’s the main branch.

---

Conclusion

Merging branches in Git is a straightforward yet powerful process that allows teams to integrate code collaboratively and efficiently.

By following these steps and best practices, you’ll be able to merge branches confidently, whether you’re using a simple fast-forward merge or handling conflicts with a three-way merge.

Git’s merging capabilities offer flexibility in managing project history, ensuring your codebase remains organized and your development workflow runs smoothly.