Git Reflog

This page delves into the intricacies of the git reflog command, shedding light on Git's mechanism of reference logs, commonly known as "reflogs." Git utilizes these logs to track updates to branch tips, and the reflog command proves invaluable for those well-versed in its usage. Before employing reflog, a thorough understanding of its subcommands and intended functionalities is crucial. This article comprehensively explores git reflog, emphasizing its significance in version control. Developers benefit from its utility in navigating changes, as reflogs meticulously document modifications to branch and reference tips, offering valuable insights for efficient Git operations and facilitating effective version control workflows.

Basic Usage

The most basic use case of reflog is invoking the git reflog command. The overall command for the same is:

This command is equivalent to writing:

Please refer to the image provided below to see the output for the above commands.

Reflog References

When we use the git reflog command, it shows us the HEAD reference (by default). The HEAD pointer is the reference to the currently active branch.

Now to get the entire reference log, we can use the command:

Now, if we want to the reflog of the current branch then we can pass the name of the branch along with the git reflog command. The overall command for the same is:

We can similarly, get the stash information using the command:

Timed Reflogs

There may be a very large codebase and hence a direct git reflog command can provide a very huge output that will not be easy to operate. So, we can pass some timed reflogs to get the result in a certain period.

For example, if we want to check for the reflog over a week then we can use the command:

The other types of time qualifiers are:

1. 1. minute.ago
2. 1. hour.ago
3. 1. day.ago
4. yesterday
5. 1. week.ago
6. 1. month.ago
7. 1. year.ago
8. date for example 2022-11-12.09:00:00

Subcommands & Configuration Options

We have some arguments that are also used with the git reflog command. The arguments are known as subcommands. Let us look at some of the subcommands and configuration options of the git reflog command:

1. show: When we want to execute the command: git log -g --abbrev-commit --pretty=oneline, we can use its abbreviated from i.e. git reflog show command. For example, the command: git reflog master@{0} and the command: git reflog show master@{0} are the same.
2. expire: If we want to clean the old unapproachable reflog entries, we can use the expire subcommand. But a problem with this command is that there is a potential risk of data loss in using this command. The default expiry date of the git reflog is 90 days.
3. delete: If we want to delete the passed reference log entries then we can use the subcommand delete. The overall command for the same is: git reflog delete. We can also use the git reflog expire command for the same but this command has more risk.
4. -all: The -all flag is used to process the reference logs of all the references.

Please refer to the official documentation to learn more about these flags and to learn more such flags here.

Recovering Lost Commits

We do not need to recover a lost commit in Git because a git commit is never lost. So even if the history is rewritten during the history operations the git commit is not lost. The git reflog command stores the reflogs in the .gitlogsrefsheads file.

We can always use the git reset command to reset the commit before rebasing.

Git Reflog vs. git log

We have discussed a lot about the git reflog command.

Let us now briefly discuss the git log command. The git log command is one of the most commonly used Git commands or a utility tool that displays all the history of the current git repository. The git log command shows us snapshots of the commits or the record of all the commits of the git repository. Now, what is a commitment? Well, a commit is a snapshot of the project's current version(s). So, we track these commits and can revert to a certain commit if we want. Git tracks the changes in a project and saves a certain state that is known as commit.

The git log command displays the following information about the repository:

• Secure Hash Algorithm (SHA) value: It is 40-character checksum data that is generated using the SHA algorithm. It is also known as commit has which is always a unique number.
• author data: It is metadata that shows the name of the author and the email address of the author.
• commit date: The git log command also shows us the timestamp of the commit.
• commit title and message of each commit of the project.

In simpler terms, we can say that the git log command is used for listing and filtering the history of the project. The git log command also helps us to search for particular commits. This command only works on the committed history of the project.

Now usually when we run the git log command, we get stuck on the screen. So, if we want to get back to the Git bash then we need to press q (which means quit) to exit from the frozen screen. Now if we want to navigate on the frozen screen then we can use the following keys:

• k: It is used to move up on the screen.
• j: It is used to move down the screen.
• space bar: It is used to scroll down by a full page and to scroll up by a page.

The git log command can be compared with the git status command. The git status command is used to check the status of the repository. The git status command shows us a large view status of the git repository. We can always use the git status and git log commands to get details of the previous commits.

To learn more about the git log command, please refer to the article: Git log.

Let us see how the git log command is different from the git reflog command. The git log command stores the public record of the commit history of a repository, on the other hand, the git reflog command stores the private history specific to the branches. Whenever we perform the git push, fetch, or pull operation then the git log details are duplicated as the repository is also duplicated. On the other hand, when we perform these operations, the reblogs are never duplicated as it is private.