XQA
Back to Git & Dev Tools
2026-01-125 min read

git reflog (Git & Dev Tools)

Learn git reflog (Git & Dev Tools) step by step with clear examples and exercises.

Why This Matters

In the dynamic world of software development, it is essential to have tools that help manage code effectively and efficiently. Git reflog is one such tool that allows developers to recover lost commits, debug issues, and track changes within their Git repository. Understanding Git reflog can save you valuable time and effort, whether you're working on a personal project or collaborating with a team.

Prerequisites

To fully grasp the concepts in this guide, it is recommended that you have a basic understanding of Git commands such as git add, git commit, git push, and git pull. Familiarity with branching and merging in Git is also beneficial but not strictly necessary.

Basic Git Commands

  • git init: Initialize a new Git repository in the current directory.
  • git add : Stage a file for commit.
  • git commit -m "": Commit staged changes with a specified message.
  • git push origin : Push local branches to the remote repository.
  • git pull origin : Pull changes from the remote repository into your local branch.

Core Concept

Understanding Git Reflog

Git reflog is a built-in Git command that maintains a log of all changes made to your local Git repository, including deleted branches, commits, and even individual file modifications. This log helps you track the history of your repository and recover lost commits or branch states.

The Anatomy of a Git Reflog Entry

Each entry in the Git reflog consists of several pieces of information:

  1. Author: The person who made the commit.
  2. Date: The date and time when the commit was made.
  3. Refname: The name of the branch or tag that the commit belongs to.
  4. Sequence: A unique identifier for each commit within a single branch.
  5. Message: The commit message associated with the entry.
  6. Subject: A shortened version of the commit message.
  7. Object Name: The unique identifier of the commit object in Git's internal storage format.

Accessing Git Reflog

To access the Git reflog, use the git reflog command. This will display a list of all commits made to your current branch, along with their corresponding information.

$ git reflog

Worked Example

Let's walk through a practical example to demonstrate how Git reflog can help you recover lost commits.

  1. Create a new repository and initialize it as a Git repository:
$ mkdir my-repo && cd my-repo
$ git init
  1. Make some changes, add them to the staging area, and commit them:
$ echo "Initial commit" > readme.md
$ git add readme.md
$ git commit -m "Add initial commit"
  1. Now, let's simulate a lost commit by resetting the branch to an earlier state:
$ git checkout HEAD~1
$ git commit --amend --no-edit

In this example, we moved back to the previous commit and made a new commit without changing the commit message. As a result, our initial commit is now lost.

  1. To recover the lost commit using Git reflog, first find its unique identifier:
$ git reflog
  1. Once you've identified the lost commit, use its object name to create a new branch and check it out:
$ git checkout <commit-object-name>^
  1. Now, you can merge the recovered branch back into your main branch:
$ git checkout master
$ git merge <recovered-branch>

Common Mistakes

1. Not Understanding Git Reflog's Scope

Git reflog only maintains a log of changes made to your local repository, not remote repositories. If you accidentally push and delete commits from the remote repository, Git reflog won't be able to help you recover them.

2. Misinterpreting Reflog Entries

Reflog entries can be confusing because they list multiple commits for each branch. Remember that each sequence number within a single branch represents a unique commit.

3. Not Using Interactive Rebase with Caution

When using interactive rebasing, be careful not to squash or delete commits you might need later. Git reflog can help you recover lost commits in such cases, but it's better to avoid these situations altogether.

4. Ignoring Git Reflog's Default Expiration Time

By default, Git reflog keeps track of commits for about 30 days. If you frequently work with large projects or make many commits daily, consider extending the default expiration time to prevent losing valuable commit history.

Practice Questions

  1. How can you recover a commit that was accidentally deleted using Git reflog?
  2. What information does each entry in the Git reflog contain?
  3. If you have multiple branches in your repository, how do you access the Git reflog for a specific branch?
  4. You've made some changes and committed them but forgot to push them to the remote repository. How can you recover these commits if they get lost or overwritten?
  5. What is the difference between Git reflog and Git history?
  6. How can you extend the default expiration time of Git reflog entries?
  7. Can you use Git reflog to recover deleted files from your repository? If not, what other tools can be used for this purpose?

FAQ

Q: Can I use Git reflog to recover deleted files from my repository?

A: No, Git reflog only maintains a log of commits, not individual file modifications. To recover deleted files, you can use the git fsck command or third-party tools like git-fuzzy.

Q: How long does Git reflog keep track of changes in my repository?

A: By default, Git reflog keeps track of commits for about 30 days. However, you can configure this behavior by adjusting the reflog.expire and reflog.expireunreachable options in your Git configuration file (.git/config).

Q: Can I use Git reflog to recover commits from a remote repository?

A: No, Git reflog only maintains a log of changes made to your local repository. To recover lost commits from a remote repository, you'll need to contact the repository owner or use alternative methods like merging in a backup copy of the repository.

Q: How can I extend the default expiration time of Git reflog entries?

A: You can extend the default expiration time by adjusting the reflog.expire and reflog.expireunreachable options in your Git configuration file (.git/config). For example, to set both options to keep commits for 90 days, add the following lines:

[reflog]
expire = now - 90 days
expireunreachable = now - 90 days
git reflog (Git & Dev Tools) | Git & Dev Tools | XQA Learn