JIYIK CN >

This article discusses the differences between the git reset, , git revertand git checkoutcommands. These are some of the most useful Git utilities that allow us to undo certain changes in our repository.

It’s easy to get confused with these commands, but by the end of this article, you’ll feel confident using the above commands to use and navigate your repositories.

Differences between Git Reset, Git Revert, and Git Checkout commands

It's easier to understand these commands if we're clear about how each command affects the three main components of a Git repository.

1. Working Directory
2. Staging snapshots
3. We can also refer to the above components as three trees.

Git checkout

What does it mean to check out?

This operation repositions the HEAD pointer to the specified commit.

The figure above shows a series of commits in a Git repository. The HEAD and master branch pointers are currently at commit d.

git checkoutWe can move our HEAD ref to any commit using the command.

For example, to move our HEAD ref to commit b, we would run:

$ git checkout -b

We can use git checkoutthe command at both commit and file level. Checking out at file level will update the contents of the file with the contents of the specified commit.

Git revert

When reverting, we take a specific commit and create a new commit to reverse the effect of the specified commit. git revert commitIt only works at the commit level and does not have file-level functionality.

Git reset

When resetting, we make a specific commit, reset the three trees, and update the repository to match the state of the repository at the specified commit. We can reset in three different modes corresponding to the three trees.

We usually use git resetand git checkoutto undo local or private changes. They both modify the history of the repository and may cause conflicts when pushed to a remote public or shared repository.

Git Reset vs. Git Revert vs. Git Checkout

The following table gives some common use cases for these three commands.

Submit Level Operations

We pass arguments to the git resetand git checkoutcommands to invoke different levels of operations. If we fail to include the file argument, the command will operate on the commit as a whole.

Reset Submissions

Resetting on commit level will move the HEAD ref to the specified commit. We can use this command to remove commits from a branch.

Here is an example.

$ git reset HEAD~3

The command above will move the tip of our branch back three commits. We can call them dangling or orphaned commits.

We have discarded these three commits. It is best to use this command to undo commits that we have not yet published to the remote shared repository.

We can also use the git reset command to change the staging snapshot and the working directory by passing one of the following flags.

1. --soft - Do not change staged changes or the working directory.
2. --mixed - does not affect the working directory, but changes the staged snapshot to match the specified commit.
3. --hard - Change the working directory and staged snapshot to match the specified commit.

Check out old commits

We can git checkoutcheck the state of the repository at a specific commit using the command. We can also switch between branches by using the branch name.

Here is an example.

$ git checkout feature

The command above will switch to the feature branch. It will not move the branch around.

We can also checkout an arbitrary commit by passing a commit hash or ref instead of a branch name. Here is an example.

$ git checkout HEAD~1

The above command will check the parent of our current commit. Passing HEAD~2 will check the grandparent.

The above command will switch us to detached HEAD mode, since our current HE****AD has no branch references.

All changes and commits done in detached HEAD mode will be inaccessible once you switch to another branch. Always create a new branch when you want to commit changes in detached HEAD state.

Restore a shared submission

When we revert a commit, we create a new commit that reverses the effect of the specified commit. In this way, we avoid rewriting the commit history of the shared repository.

For example, if we wanted to revert the most recent commit, we would run:

$ git revert HEAD

File-level operations

git checkoutThe and git resetcommands accept a file path as an optional argument. The effects of these commands are limited to a single file.

Reset Files

We can update the staged snapshot of a file to match the version at a specified commit as follows.

$ git reset HEAD~1 README.md

The command above will get the version of the README.md file in the parent commit of the current commit and add it to the index of the next commit. We can run git reset HEAD README.mdto unstage the README.md file.

Git Checkout Files

Passing a file path to git checkoutthe command updates the working directory instead of staging a snapshot. This does not move the HEAD pointer between branches.

Here is an example.

$ git checkout HEAD~1 README.md

This will take the version of the README.md file from the parent commit of our current commit and update only the README.md file in our working directory. It simply means that we have reverted to the version of the file in the old commit.

Unlike the command , which undoes the changes introduced by a specified commit git revert, this discards all subsequent changes. We can use this to discard unstaged changes to a single file, as shown below.

$ git checkout HEAD README.md

In summary, we can easily distinguish between git reset , git revert , and git checkout commands by understanding the impact of each command on the commit history, staging snapshot, and working directory.