How to Check If a File Has Conflicts in Git

Introduction

In this lab, you will learn how to identify and understand merge conflicts in Git. We will simulate a conflict scenario by making conflicting changes to the same file in different branches and then attempting to merge them.

You will use the git status command to detect the presence of conflicts and then examine the conflicted file to see the conflict markers that Git inserts. Finally, you will verify that files without conflicts are not marked as such.

Skills Graph

Run git status to Detect Conflicts

In this step, we will learn how to use the git status command to detect conflicts in your Git repository. Conflicts happen when two different changes are made to the same part of a file, and Git doesn't know which change to keep.

First, let's make sure we are in our project directory. Open your terminal and navigate to the my-time-machine directory:

cd ~/project/my-time-machine

Now, let's simulate a conflict. Imagine you and a collaborator both made changes to the message.txt file at the same time, but in different branches. For this lab, we will manually create a scenario that results in a conflict.

First, let's create a new branch and make a change.

git branch feature/greeting
git checkout feature/greeting
echo "Hope you are doing well!" >> message.txt
git add message.txt
git commit -m "Add a greeting"

Now, let's switch back to the master branch and make a different change to the same file.

git checkout master
echo "This is an important message." >> message.txt
git add message.txt
git commit -m "Add an important message"

We now have two different changes to message.txt in two different branches. When we try to merge these branches, Git will detect a conflict.

Let's try to merge the feature/greeting branch into master:

git merge feature/greeting

You should see output indicating a conflict:

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

This output tells us that there is a merge conflict in the message.txt file. Git was unable to automatically merge the changes because they overlapped.

Now, let's run git status to see how Git reports the conflict:

git status

The output will look something like this:

On branch master
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to resolve merge conflicts)
        both modified:   message.txt

no changes added to commit (use "git add" and/or "git commit -a)")

The git status output clearly shows that we are "On branch master" and have "unmerged paths". It also lists message.txt under "Unmerged paths" and indicates that it was "both modified". This is how git status helps you identify files that have merge conflicts.

Understanding how to use git status to detect conflicts is the first step in resolving them. In the next steps, we will learn how to examine the conflicted file and resolve the conflict.

Check File for Conflict Markers

In the previous step, we saw that git status reported a conflict in message.txt. Now, let's examine the file itself to see how Git marks the conflicting sections.

Make sure you are still in the ~/project/my-time-machine directory.

We can use the cat command to view the contents of the file:

cat message.txt

The output will look something like this:

Hello, Future Me
<<<<<<< HEAD
This is an important message.
=======
Hope you are doing well!
>>>>>>> feature/greeting

Notice the special markers that Git has added to the file:

• <<<<<<< HEAD: This marks the beginning of the changes in the current branch (which is HEAD, pointing to master in this case).
• =======: This is a separator between the changes from the two branches.
• >>>>>>> feature/greeting: This marks the end of the changes from the branch you were merging from (feature/greeting).

These markers show you exactly where the conflict occurred and what the different versions of the conflicting lines are. The lines between <<<<<<< HEAD and ======= are the changes from your current branch (master), and the lines between ======= and >>>>>>> feature/greeting are the changes from the branch you were merging (feature/greeting).

Your task now is to manually edit this file and decide which changes to keep. You need to remove the conflict markers and the lines you don't want to keep, leaving only the final desired content.

For example, if you wanted to keep both messages, you would edit the file to look like this:

Hello, Future Me
This is an important message.
Hope you are doing well!

Or, if you only wanted to keep the message from the master branch, you would edit the file to look like this:

Hello, Future Me
This is an important message.

Use the nano editor to open and edit the message.txt file:

nano message.txt

Edit the file to resolve the conflict by removing the conflict markers and choosing the content you want to keep. For this lab, let's keep both messages.

After editing, the file content should be:

Hello, Future Me
This is an important message.
Hope you are doing well!

Press Ctrl + X to exit nano, then press Y to save the changes, and finally press Enter to confirm the filename.

By manually editing the file and removing the conflict markers, you are telling Git how to combine the conflicting changes. This is a crucial step in resolving merge conflicts.

Test Non-Conflicted Files

In the previous steps, we identified and examined a file with a merge conflict (message.txt). However, during a merge, there might also be files that were changed in both branches but without conflicts. Git automatically merges these files.

In this step, we will create a new file in one of the branches and see how Git handles it during the merge process. This will help us understand that conflicts only occur when changes overlap in the same file.

Make sure you are still in the ~/project/my-time-machine directory and on the master branch (where the merge conflict occurred).

Let's create a new file called notes.txt in the master branch:

echo "Important notes for the project." > notes.txt
git add notes.txt
git commit -m "Add project notes"

Now, let's switch back to the feature/greeting branch:

git checkout feature/greeting

In this branch, the notes.txt file does not exist yet. Let's create a different file here, for example, todo.txt:

echo "Things to do: finish the lab." > todo.txt
git add todo.txt
git commit -m "Add a todo list"

Now, let's switch back to the master branch and attempt the merge again. Even though we have already resolved the conflict in message.txt, the merge process needs to be completed.

git checkout master
git merge feature/greeting

This time, since we have already resolved the conflict in message.txt and added it to the staging area (though we didn't explicitly show that step after editing, Git often stages the file after manual conflict resolution), Git should be able to complete the merge. You might see output indicating that the merge is complete.

Let's check the status again:

git status

The output should now show that you are "On branch master" and that the working tree is clean, meaning there are no pending changes or unmerged paths.

On branch master
nothing to commit, working tree clean

Now, let's check if the files from both branches are present in the master branch:

ls

You should see both message.txt, notes.txt (from the master branch), and todo.txt (from the feature/greeting branch) listed.

message.txt  notes.txt  todo.txt

This demonstrates that Git successfully merged the changes from feature/greeting, including the new todo.txt file, without any conflicts because todo.txt did not exist in the master branch. Conflicts only arise when the same file has overlapping changes in the branches being merged.

Understanding how Git handles both conflicted and non-conflicted files during a merge is essential for managing your project's history effectively.

Summary

In this lab, we learned how to detect conflicts in Git using the git status command. We simulated a conflict by making different changes to the same file in separate branches and then attempting to merge them. The git status output clearly indicated the presence of unmerged paths and the specific file with the conflict.

We also explored how to identify conflict markers within the conflicted file itself, which Git inserts to highlight the conflicting sections. Finally, we confirmed that files without conflicts are not marked with these special characters, reinforcing our understanding of how Git flags merge issues.