How to Check If a Git Commit Was Amended

Introduction

In this lab, you will learn how to determine if a Git commit has been amended. We will explore the git reflog command to view the history of reference updates, which can reveal amend operations.

You will also learn how to use git log to compare commits and understand the differences between amended and non-amended commits, gaining practical skills in examining your repository's history.

Skills Graph

Check git reflog for Amend Entries

In this step, we will explore the git reflog command and how it helps us see the history of our repository, including actions like amending commits.

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 use the git reflog command to see the history of our repository. The reflog (reference log) records updates to the tips of branches and other references in the repository. This is different from git log, which shows the commit history.

Type the following command:

git reflog

You should see output similar to this:

a1b2c3d (HEAD -> master) HEAD@{0}: commit: Send a message to the future
a1b2c3d (HEAD -> master) HEAD@{1}: initial commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Let's break down this output:

• Each line represents an action that updated a reference (like HEAD).
• HEAD@{0} is the most recent action, HEAD@{1} is the action before that, and so on.
• The first part of each line (a1b2c3d, e4f5g6h) is the commit hash. Notice how the commit hash changes after an "amend" operation.
• The text after the commit hash describes the action, such as commit, initial commit (amend), or commit (initial).

The git reflog is a powerful tool for recovering lost commits or understanding the sequence of operations that led to the current state of your repository. It shows you where your HEAD has been, even if those commits are no longer part of a branch's history (for example, after an amend or rebase).

In the example output, you can see an entry like initial commit (amend). This indicates that the initial commit was amended. Amending a commit replaces the last commit with a new commit that includes the changes you've staged. While git log will only show the final, amended commit, git reflog shows both the original initial commit and the amended one.

Understanding git reflog is crucial for navigating your project's history, especially when you use commands that rewrite history, like git commit --amend.

Use git log to Compare Commits

In this step, we will use the git log command to view the commit history and understand how it differs from git reflog, especially after using git commit --amend.

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

Now, let's view the commit history using git log:

git log --oneline

The --oneline option provides a concise view of the commit history, showing each commit on a single line.

You should see output similar to this:

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

Compare this output to the output from git reflog in the previous step. Notice that git log only shows one commit, which is the final, amended commit. It does not show the original initial commit that was replaced by the amend operation.

This is a key difference between git log and git reflog. git log shows the history of commits reachable from the current branch tip, while git reflog shows the history of where HEAD and other references have pointed.

Think of git log as the official published history of your project, while git reflog is your personal diary of everything you've done in the repository.

You can also use git log to compare different commits. While we only have one commit in our history right now, in a real project with multiple commits, you could use commands like git log commit1..commit2 to see the commits between two specific points in history, or git diff commit1 commit2 to see the exact changes introduced between two commits.

For now, just understanding that git log shows the commit history and git reflog shows the history of reference updates is important.

Test Non-Amended Commits

In this step, we will create a new commit without using the --amend flag and observe how it appears in both git log and git reflog. This will help solidify your understanding of how these commands track history differently.

First, let's add some more content to our message.txt file. We'll append a new line:

echo "Hello again, Future Me!" >> message.txt

The >> operator appends the text to the existing file, rather than overwriting it.

Now, let's check the status to see the changes:

git status

You should see output indicating that message.txt has been modified:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   message.txt

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

Next, we need to stage the changes:

git add message.txt

And now, let's create a new commit without amending the previous one:

git commit -m "Add another message"

You should see output confirming the new commit:

[master 1a2b3c4] Add another message
 1 file changed, 1 insertion(+)

Now, let's check the git log again:

git log --oneline

This time, you should see two commits:

1a2b3c4 (HEAD -> master) Add another message
a1b2c3d Send a message to the future

Both commits are visible in the git log because the second commit was added on top of the first one, extending the branch's history.

Finally, let's check the git reflog:

git reflog

You should see output similar to this:

1a2b3c4 (HEAD -> master) HEAD@{0}: commit: Add another message
1a2b3c4 (HEAD -> master) HEAD@{1}: commit (amend): Send a message to the future
e4f5g6h HEAD@{2}: commit (initial): Send a message to the future

Notice that git reflog shows all the actions: the initial commit, the amended initial commit, and the new commit we just created. Each action that moved HEAD is recorded.

This step demonstrates that when you create a new commit without --amend, both git log and git reflog will show the new commit, but git reflog will still retain the history of the amended commit, which git log does not.

Summary

In this lab, we learned how to check if a Git commit was amended. We explored the git reflog command, which provides a history of updates to references like HEAD, allowing us to see actions such as amending commits. By examining the reflog output, we can identify entries indicating an amend operation and observe how the commit hash changes after such an action.

We also learned that git reflog is a valuable tool for understanding the sequence of operations in a repository, even for commits that are no longer directly accessible through git log. This helps in recovering lost work or diagnosing repository history issues.