How to Resolve Merge Conflicts in Git?

Merge conflicts are a common occurrence when working with Git, especially in collaborative environments where multiple people are working on the same codebase. While the term “merge conflict” may sound daunting, it’s a natural part of the version control process. This blog post will walk you through understanding, preventing, and resolving merge conflicts in Git.

What Is a Merge Conflict in Git?

A merge conflict occurs when Git is unable to automatically reconcile differences between branches during a merge. This typically happens when:

• Two branches have modified the same line in a file.
• One branch deletes a file that another branch modifies.
• Different branches have made changes in overlapping sections of a file.

Git tries to handle merges automatically, but when changes directly conflict, Git pauses and requires you to review and manually resolve the conflicts.

---

How to Identify a Merge Conflict

Merge conflicts often appear when you attempt to merge branches, rebase, or pull changes from a remote repository. Here’s a typical scenario:

git merge branch-name

If Git detects a conflict, you’ll see a message similar to:

Auto-merging filename.txt
CONFLICT (content): Merge conflict in filename.txt
Automatic merge failed; fix conflicts and then commit the result.

Git will also list files with conflicts when you run git status, displaying them as “unmerged”:

# Unmerged paths:
#   (use "git add <file>..." to mark resolution)
#
#       both modified:   filename.txt

This status indicates that the file needs manual resolution.

---

Steps to Resolve Merge Conflicts

Resolving a merge conflict requires you to manually review the conflicting files, choose which changes to keep, and update the file. Here’s a step-by-step guide.

Step 1: Open the Conflicting File

Open the file with conflicts in your preferred text editor. In the file, Git will insert conflict markers to help you see where the conflict is:

<<<<<<< HEAD
This is the content from your current branch.
=======
This is the content from the branch being merged.
>>>>>>> branch-name

Each conflict marker signifies:

• HEAD: Changes in the branch you’re merging into (usually the current branch).
• branch-name: Changes in the branch you’re merging from.
• The area between ======= and >>>>>>> shows the changes from the branch being merged.

Step 2: Decide How to Resolve the Conflict

There are generally three approaches to resolving conflicts:

1. Accept Current Change (keep the content in your branch).
2. Accept Incoming Change (keep the content in the merged branch).
3. Combine Both Changes (merge the changes manually if both are valid).

Edit the file to resolve the conflict by removing the conflict markers (<<<<<<<, =======, >>>>>>>) and leaving only the final content you want.

Example Resolution:
Suppose you want to keep both changes. You’d modify the section to look like this:

This is the content from your current branch.
This is the content from the branch being merged.

Step 3: Mark the Conflict as Resolved

After editing and saving the file, use git add to mark the file as resolved:

git add filename.txt

You can confirm that the conflict has been resolved by running:

git status

The file should no longer appear as “unmerged.”

Step 4: Commit the Merge

After resolving all conflicts, complete the merge by committing the changes:

git commit

If you used git merge, Git will automatically populate the commit message with details about the merge.

---

How to Avoid Merge Conflicts

While conflicts can’t always be avoided, certain practices can minimize them:

1. Pull Frequently: Regularly pull changes from the main branch or other collaborating branches to keep your branch up-to-date.
2. Communicate with Your Team: Let your team know which files you’re working on. Collaboration tools or stand-up meetings can help coordinate work.
3. Make Smaller Commits: Small, focused changes make conflicts easier to resolve when they occur.
4. Avoid Long-Lived Branches: Long-lived branches often diverge significantly from the main branch, increasing the likelihood of conflicts.
5. Use Feature Branches: Isolate work on new features in separate branches and merge them back into the main branch once completed.

---

Tools for Resolving Conflicts

Many tools can assist with visualizing and resolving merge conflicts:

• Git GUIs (e.g., GitKraken, SourceTree): Offer visual conflict resolution interfaces.
• IDE Integrations (e.g., Visual Studio Code, IntelliJ IDEA): Many popular IDEs highlight conflicts directly within the editor and provide a user-friendly interface to resolve them.
• Git Mergetool: Git’s built-in mergetool command lets you configure external merge tools (like vimdiff, meld, or kdiff3) for a graphical merge experience:

   git mergetool

---

Example: Resolving a Conflict Step-by-Step

Let’s go through a practical example to illustrate the process.

Scenario

Suppose we have two branches, main and feature, and both have modified the same line in hello.txt.

1. Attempt the Merge:

   git checkout main
   git merge feature

Git detects a conflict and outputs:

   CONFLICT (content): Merge conflict in hello.txt

2. Open the File: The file hello.txt might look like this:

   <<<<<<< HEAD
   Hello from the main branch!
   =======
   Hello from the feature branch!
   >>>>>>> feature

3. Resolve the Conflict: Decide which version to keep, or combine them. Here, we’ll combine them:

   Hello from the main branch!
   Hello from the feature branch!

4. Mark as Resolved and Commit: Add the file and complete the merge:

   git add hello.txt
   git commit

Your conflict is now resolved, and the main branch includes both versions of the greeting.

---

Final Thoughts

Merge conflicts can be intimidating at first, but they’re a natural part of collaborative development. Understanding how to identify, resolve, and even prevent conflicts will make your workflow smoother and your team’s collaboration more efficient. By following the steps and best practices in this guide, you’ll be well-prepared to handle merge conflicts with confidence.