How to Check If a Git Repository Has a Specific Commit Hash

Introduction

In this lab, you will learn how to check if a Git repository has a specific commit hash. We will explore the git rev-parse command to obtain the full hash from a short hash or other Git references, providing an unambiguous way to identify commits.

Following that, you will use the git show command to verify the existence and view the details of a commit using its hash. Finally, we will cover how to handle scenarios involving invalid or non-existent commit hashes.

Skills Graph

Run git rev-parse Commit

In this step, we'll learn how to use the git rev-parse command to get the full hash of a commit. This is useful when you need the exact identifier for a specific point in your project's history.

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 get the short hash of our latest commit using git log --oneline. This command shows a condensed view of your commit history.

git log --oneline

You should see output similar to this:

a1b2c3d (HEAD -> master) Send a message to the future

The a1b2c3d part is the short hash of your commit. While this is often enough for everyday use, sometimes you need the full, unique identifier.

This is where git rev-parse comes in. We can use it to get the full hash from the short hash. Replace a1b2c3d with the short hash you saw in your git log --oneline output:

git rev-parse a1b2c3d

You should see the full hash printed to the terminal, something like this:

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t

The git rev-parse command is a low-level command that is often used in scripting. It can parse various types of Git references (like branch names, tags, or short hashes) and output the corresponding object ID (the full hash).

Understanding how to get the full hash is important because it provides an unambiguous way to refer to a specific commit, regardless of whether branches or tags move.

Use git show to Verify Hash

In the previous step, we learned how to get the full hash of a commit using git rev-parse. Now, let's use the git show command to view the details of that specific commit using its hash.

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

The git show command is used to display information about various types of Git objects, including commits. When you provide a commit hash to git show, it will display the commit message, author, date, and the changes introduced by that commit.

Let's use the full hash we obtained in the previous step with git show. Replace a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t with the actual full hash of your commit:

git show a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t

You should see output similar to this, showing the details of your first commit:

commit a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t
Author: Jane Doe <[email protected]>
Date:   Mon Aug 7 10:00:00 2023 +0000

    Send a message to the future

diff --git a/message.txt b/message.txt
new file mode 100644
index 0000000..a1b2c3d
--- /dev/null
+++ b/message.txt
@@ -0,0 +1 @@
+Hello, Future Me

This output confirms that the hash you used corresponds to the commit where we added the message.txt file with the content "Hello, Future Me".

Using git show with a commit hash is a powerful way to inspect the history of your project. You can use it to see exactly what changes were made in any given commit, which is invaluable for debugging or understanding how a project evolved.

Remember, you can use either the full hash or a sufficiently long prefix of the hash (usually 7 characters is enough, but the full hash is always guaranteed to be unique) with git show.

Handle Invalid Hashes

In the previous steps, we successfully used a valid commit hash with git rev-parse and git show. But what happens if you provide an invalid or non-existent hash? Git is designed to give you feedback when it can't find the object you're looking for.

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

Let's try using git show with a hash that doesn't exist. We'll just type a random string of characters that looks like a hash:

git show deadbeef

You should see an error message similar to this:

fatal: bad object deadbeef

This message tells you that Git could not find an object (in this case, a commit) with the hash deadbeef. This is Git's way of letting you know that the reference you provided is not valid in this repository.

Similarly, if you try to use git rev-parse with an invalid hash, you will get an error:

git rev-parse invalidhash

The output will be similar:

fatal: ambiguous argument 'invalidhash': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

This error message is a bit more detailed, suggesting that Git couldn't interpret invalidhash as a known revision or file path.

Understanding these error messages is important. When you encounter a "bad object" or "unknown revision" error, it usually means that the commit hash, branch name, or tag you are trying to use does not exist in your current repository's history. Double-check the hash or reference you are using to make sure it's correct.

This step demonstrates that Git is strict about the references you provide. Using valid hashes is crucial for navigating and manipulating your project's history accurately.

Summary

In this lab, we learned how to check if a Git repository has a specific commit hash. We started by using the git rev-parse command to obtain the full hash of a commit from its short hash, understanding its role in parsing Git references and providing unambiguous object IDs.

Next, we explored the git show command to verify the existence and view the details of a commit using its hash. This process allows us to confirm that a specific commit is present in the repository's history.