How to Check If a Git Branch Is Synced with Another Branch

Introduction

In this lab, you will learn how to check if a Git branch is synchronized with another branch. This is a fundamental skill for managing your project's history and ensuring branches are up-to-date.

You will explore three different methods to achieve this: using git log to compare commit histories, employing git diff to identify differences between branches, and finally, verifying the relationship between branches using git merge-base. By the end of this lab, you will be equipped with practical techniques to confidently determine the synchronization status of your Git branches.

Skills Graph

Use git log to Compare Commits

In this step, we will learn how to use the git log command to compare different commits in your project's history. This is like looking at different snapshots of your time machine and seeing how things have changed between them.

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

cd ~/project/my-time-machine

Now, let's create a new file and make a commit. This will give us another point in history to compare with our first commit.

echo "This is the second message." > second_message.txt
git add second_message.txt
git commit -m "Add a second message file"

You should see output similar to this after the commit:

[master a1b2c3d] Add a second message file
 1 file changed, 1 insertion(+)
 create mode 100644 second_message.txt

Now we have two commits in our history. Let's view the log again:

git log

You will see two commit entries, with the newest one at the top. Each commit has a unique identifier (the long string of characters).

To compare two specific commits, we can use git log with the range syntax commit1..commit2. This shows the commits that are reachable from commit2 but not from commit1.

Let's find the commit IDs for our two commits. You can get the short IDs from the git log --oneline output. For example, if your first commit ID was a1b2c3d and your second was e4f5g6h, you would use those IDs.

git log --oneline

Example output:

e4f5g6h (HEAD -> master) Add a second message file
a1b2c3d Send a message to the future

Now, let's compare the state of the project between the first commit (a1b2c3d) and the second commit (e4f5g6h). Replace the example IDs with your actual commit IDs:

git log a1b2c3d..e4f5g6h

This command will show you the commits that were made after the commit with ID a1b2c3d up to and including the commit with ID e4f5g6h. In this case, it should show you the second commit.

Understanding how to compare commits using git log is crucial for navigating your project's history. It allows you to see the sequence of changes and understand the evolution of your codebase.

Run git diff branch1 branch2

In the previous step, we used git log to see which commits were present in different parts of our history. Now, let's use the git diff command to see the actual changes between two different points in time or between different branches. This is like comparing two versions of your time machine and seeing exactly what parts were added, removed, or modified.

First, ensure you are in your project directory:

cd ~/project/my-time-machine

We currently only have one branch, master. To demonstrate comparing branches, let's create a new branch called feature-branch. Think of a branch as an alternate timeline where you can work on new features or experiments without affecting the main timeline (master).

git branch feature-branch

Now, let's switch to our new branch:

git checkout feature-branch

You should see output indicating you've switched branches:

Switched to branch 'feature-branch'

On this new branch, let's make a change to our message.txt file:

echo "Adding a line on the feature branch." >> message.txt

This command appends a new line to the message.txt file.

Now, let's commit this change on the feature-branch:

git add message.txt
git commit -m "Add a line to message.txt on feature branch"

You should see output similar to this after the commit:

[feature-branch a1b2c3d] Add a line to message.txt on feature branch
 1 file changed, 1 insertion(+)

Now we have two branches (master and feature-branch) with different commit histories. The master branch has the first two commits, and the feature-branch has those two commits plus the new commit we just made.

Let's use git diff to see the differences between the master branch and the feature-branch.

git diff master feature-branch

The output will show you the exact lines that are different between the two branches:

diff --git a/message.txt b/message.txt
index a1b2c3d..e4f5g6h 100644
--- a/message.txt
+++ b/message.txt
@@ -1 +1,2 @@
 Hello, Future Me
+Adding a line on the feature branch.

This output shows that the message.txt file is different. The line starting with + indicates a line that was added on the feature-branch compared to the master branch.

Using git diff is incredibly powerful for understanding exactly what changes have been made between different versions of your project or between different branches. It helps you review changes before merging them and pinpoint where specific modifications occurred.

Press q to exit the diff view and return to the command line.

Verify with git merge-base

In this step, we will explore the git merge-base command. This command is useful for finding the best common ancestor between two commits. Think of it as finding the point in time where two different timelines (branches) diverged.

First, ensure you are in your project directory:

cd ~/project/my-time-machine

We have two branches, master and feature-branch. The feature-branch was created from master, and then a new commit was added to feature-branch. The common ancestor of these two branches is the commit on master just before the feature-branch was created.

Let's use git merge-base to find the common ancestor of master and feature-branch:

git merge-base master feature-branch

The output of this command will be the commit ID of the common ancestor. This should be the commit ID of the second commit we made on the master branch before creating the feature-branch.

Example output:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9

(The actual commit ID will be different in your case).

To verify that this is indeed the common ancestor, you can use git log --oneline to see the history of both branches and visually confirm the commit ID.

git log --oneline --graph --all

This command will show you a graphical representation of your commit history across all branches. You can trace back from the tips of master and feature-branch to find where their histories converge. The commit ID identified by git merge-base should be that convergence point.

Understanding the common ancestor is important in Git, especially when you are preparing to merge branches. Git uses the common ancestor to figure out the changes that need to be combined.

Summary

In this lab, we learned how to check if a Git branch is synced with another branch using various Git commands. We started by using git log to compare commits between branches, understanding how to view commit history and identify differences using the range syntax. This allowed us to see which commits exist in one branch but not the other.

Next, we explored the git diff command to examine the actual content differences between branches, seeing line-by-line changes. Finally, we used git merge-base to find the common ancestor commit of two branches, which helps determine if one branch is fully included in the other. These steps provide a comprehensive approach to verifying branch synchronization in Git.