How to Resolve Git Conflicts?

Git conflicts are a common challenge in version control, especially in collaborative projects where multiple people are working on the same codebase. Conflicts occur when two or more people edit the same file in conflicting ways. Though resolving these conflicts can seem daunting, understanding how to identify and resolve them is an essential skill for any developer.

In this post, we’ll walk through what causes Git conflicts, how to identify them, and step-by-step instructions for resolving them effectively.

What Causes Git Conflicts?

Git conflicts typically occur when:

• Two or more developers edit the same lines in a file and attempt to merge these changes.
• A developer edits a file that has already been updated and committed by another team member.
• Merging or rebasing branches with different changes that aren’t easily auto-resolvable.

When a conflict happens, Git pauses the merge or rebase process to allow the developer to manually resolve the differences.

---

Types of Git Conflicts

Git conflicts can arise in different scenarios:

1. Merge Conflicts: Occur when you merge one branch into another and Git detects incompatible changes.
2. Rebase Conflicts: Arise during a rebase operation when commits are being reapplied over the latest commits from the base branch.
3. Cherry-pick Conflicts: Happen when picking individual commits from one branch and applying them to another, which may have overlapping changes.

---

How to Identify a Git Conflict

When a conflict occurs, Git will provide indicators, such as:

• Error Message: Git will display a message stating that conflicts need to be resolved before proceeding.
• Conflict Markers in Files: Files with conflicts contain conflict markers (<<<<<<<, =======, >>>>>>>) to indicate the sections that need resolution.
• Unmerged Files: When you run git status, Git will list files with conflicts as “Unmerged.”

---

Steps to Resolve Git Conflicts

Let’s walk through how to resolve a Git conflict step by step.

Step 1: Start with git status

To see the list of files with conflicts, run:

git status

Git will show you which files have conflicts and require resolution. For example, you might see:

both modified: src/app.js

This indicates that app.js has conflicts and needs to be reviewed.

Step 2: Open the Conflicted File

Open each conflicted file in a text editor. Git marks conflicts within the file using:

• <<<<<<< HEAD: The beginning of your branch’s changes.
• =======: Divider between conflicting changes.
• >>>>>>> other-branch: The end of the changes from the branch you’re merging.

For example:

function example() {
<<<<<<< HEAD
    console.log("Feature from your branch");
=======
    console.log("Feature from the other branch");
>>>>>>> other-branch
}

This code indicates that both branches have changes to the example function.

Step 3: Choose Which Changes to Keep

There are several ways to resolve conflicts:

1. Keep Your Changes: Delete the incoming changes, keeping only your version.
2. Keep Incoming Changes: Remove your changes and keep the incoming branch’s version.
3. Combine Changes: Edit the code to incorporate both sets of changes.

In the example above, if you want to keep both log statements, you could update the function like this:

function example() {
    console.log("Feature from your branch");
    console.log("Feature from the other branch");
}

After editing, delete the conflict markers (<<<<<<<, =======, >>>>>>>) so that only the resolved code remains.

Step 4: Mark Conflict as Resolved

After resolving conflicts in a file, mark it as resolved using:

git add <file>

Repeat this step for each conflicted file. Adding the files confirms that you’ve resolved the conflicts.

Step 5: Complete the Merge or Rebase

Once all conflicts are resolved and staged, you can complete the operation.

• For a Merge: Finalize with:

  git commit

Git automatically creates a merge commit once conflicts are resolved and staged.

• For a Rebase: Continue with:

  git rebase --continue

This command applies remaining commits in the rebase sequence after conflict resolution.

---

Common Commands for Resolving Git Conflicts

Here are some helpful Git commands for handling conflicts:

• Abort a Merge/Rebase: If you need to cancel the merge or rebase, use:

  git merge --abort      # Cancels a merge
  git rebase --abort     # Cancels a rebase

• View Conflict Markers: To list all conflicted files and identify markers, you can use:

  git diff --name-only --diff-filter=U

• List All Conflicted Files: Use git status to see a list of files that require resolution.

---

Best Practices for Avoiding and Managing Conflicts

1. Pull Frequently: Regularly pull the latest changes from the main branch to stay up-to-date and reduce the chance of conflicts.
2. Commit Often and with Small Changes: Smaller, focused commits reduce the risk of conflicts and make it easier to resolve them if they do occur.
3. Use Clear Commit Messages: Clear messages help others understand your changes, making conflict resolution easier.
4. Communicate with Your Team: If you anticipate conflicts or are working on shared files, communicate with your team to coordinate changes.
5. Test After Resolution: After resolving conflicts, always test your code to ensure functionality isn’t affected by the resolved changes.

---

Conclusion

Resolving Git conflicts is a critical skill for effective collaboration in version-controlled projects. By understanding the causes of conflicts, learning to recognize them, and following a structured approach to resolve them, you can navigate conflicts with confidence. While conflicts are a natural part of development, adopting best practices can help reduce their frequency and make them easier to handle when they arise.

With practice, resolving Git conflicts will become a straightforward part of your workflow, allowing you to work efficiently with teammates and keep your project’s history clean and manageable.