How to Resolve Merge Conflicts in a Git Pull Request?

Merge conflicts are a common occurrence in collaborative projects using Git. They arise when multiple people work on the same codebase and make changes to the same lines of code, resulting in conflicts when trying to merge those changes. Handling these conflicts efficiently is crucial to maintaining a smooth workflow and ensuring that no code is accidentally overwritten.

In this blog, we’ll walk through how to resolve merge conflicts in a Git pull request (PR) to help you merge code changes with confidence.

---

What Is a Merge Conflict in Git?

A merge conflict happens when Git can’t automatically combine two changes. This often occurs in pull requests when multiple contributors modify the same lines of code, or when updates are made to a branch that conflicts with the branch you’re trying to merge.

Example Scenarios:

• Conflicting Code Edits: If two developers make changes to the same lines in a file, Git won’t know which change to keep.
• File Renaming or Deletion: If one branch renames or deletes a file that another branch modifies, Git can’t resolve it automatically.
• Structural Changes: Major structural changes, such as changing folder names or moving files, may lead to conflicts when merging.

By following the steps below, you can review and resolve merge conflicts to ensure all changes are accurately integrated into your main codebase.

---

Step-by-Step Guide to Resolving Merge Conflicts in a Pull Request

Step 1: Identify the Merge Conflict in the Pull Request

If you submit a pull request with conflicting code, GitHub (or your Git platform) will indicate that the branch has conflicts. You’ll see a message like “This branch has conflicts that must be resolved”.

On GitHub:

• Go to the Files Changed tab in your PR.
• Look for files with conflicts. GitHub will list them and allow you to view the conflicts directly in the browser.

Alternatively, if you’re working locally, running git merge or git pull will also show any conflicts.

Step 2: Fetch and Pull the Latest Changes

Before resolving conflicts, ensure that you have the latest version of the code. Run the following commands:

git fetch origin
git pull origin main  # or the target branch name

This will ensure that your branch is up to date with the target branch, and it will also reveal any conflicts that need to be resolved.

Step 3: Locate and Open the Conflicted Files

When Git detects a conflict, it marks the conflicting lines in the affected files. Open these files to see the conflict markers, which look like this:

<<<<<<< HEAD
// Your changes
=======
// Changes from the other branch
>>>>>>> other-branch

• HEAD represents the changes from your current branch.
• other-branch represents the conflicting branch’s changes.

Each conflict will be wrapped in these markers to help you locate and resolve the issues.

Step 4: Resolve the Conflicts

To resolve conflicts, you need to decide which changes to keep, modify, or combine. Here are some options:

• Keep Your Changes: If you want to keep your changes only, delete the lines between ======= and >>>>>>> other-branch, as well as the markers themselves.
• Accept Incoming Changes: If you want to keep the changes from the other branch, remove everything between <<<<<<< HEAD and =======, as well as the markers.
• Combine Changes: You can also manually combine the changes from both branches by editing the code between the markers as needed.

Example:
If two branches have slightly different versions of a paragraph in documentation, you could combine them as shown below.

// Resolved version that combines both changes
This paragraph includes both the updated information from both branches.

After editing, delete all conflict markers (<<<<<<<, =======, >>>>>>>) to clean up the file.

Step 5: Test the Code

After resolving conflicts, it’s essential to test your code to ensure that the conflict resolution didn’t introduce errors. Run tests or manually check the functionality if needed to confirm that everything works as expected.

Step 6: Stage and Commit the Resolved Files

Once you’re satisfied with your changes, add the resolved files to the staging area and commit them.

git add <conflicted-file>
git commit -m "Resolve merge conflicts"

This commits your changes and marks the conflict as resolved in your branch.

Step 7: Push the Changes to the Remote Repository

Push your resolved code back to the remote repository. This will update the pull request and, if everything is resolved correctly, the PR should be able to merge.

git push origin <your-branch-name>

Your pull request should now be free of conflicts, and GitHub will indicate that it’s ready to merge.

---

Alternative: Resolving Conflicts Directly on GitHub

If your Git platform supports it, you may be able to resolve conflicts directly in the browser.

On GitHub:

1. Go to the Files Changed tab in the PR.
2. Click Resolve conflicts next to any file with a conflict.
3. Use GitHub’s in-browser editor to edit the file, remove conflict markers, and make necessary changes.
4. Click Mark as resolved when done, and then Commit merge.

This option is convenient for minor conflicts, but more complex conflicts are often easier to resolve locally, where you can test the code.

---

Tips and Best Practices for Resolving Merge Conflicts

1. Communicate with Team Members: If you’re unsure how to handle certain conflicts, reach out to teammates who made the conflicting changes to understand their intent.
2. Use Descriptive Commit Messages: When committing resolved conflicts, include a meaningful commit message, such as "Resolved merge conflict in main.js by combining feature A with updated logic."
3. Keep Branches Updated: Regularly pull changes from the main branch to your feature branch to reduce the chances of large conflicts at the end.
4. Avoid Large Pull Requests: Smaller PRs with targeted changes reduce the likelihood of conflicts and make them easier to resolve when they do arise.
5. Use Git Tools for Complex Merges: Git provides tools like git mergetool that integrate with visual merge tools to make conflict resolution easier, especially with large or complex files.
6. Test Thoroughly After Resolving Conflicts: Especially if you combined changes, thorough testing helps catch errors introduced by manual conflict resolution.

---

Summary

Merge conflicts are a natural part of collaborative Git workflows. By following these steps—fetching the latest changes, understanding and editing conflicted files, testing, and committing resolved changes—you can efficiently resolve conflicts in your pull requests.

Knowing how to manage conflicts effectively keeps your codebase clean and ensures a smooth workflow for you and your team. With these best practices and step-by-step guidance, you’ll be well-prepared to handle merge conflicts and ensure that your changes are integrated seamlessly.