Resources     Blog  

  1. Home
  2. Git Tutorials
  3. The Difference Between Git Reset, Git Checkout, and Git Revert

The Difference Between Git Reset, Git Checkout, and Git Revert

The Git toolbox is full of useful commands. That being said, three of the most useful commands available for you to use are the git reset, git checkout, and git revert commands. These commands can be somewhat similar and you may not understand them fully. That being said, let’s take a look at these Git command differences together.

What Do These Git Commands Accomplish?

Not only are these three commands arguably three of the most useful ones within your Git toolbox,  but all three of these commands also allow you to undo some kind of change in your repository. On top of that, the git reset and git checkout commands can also be used to manipulate either commits or individual files.

Commits: Basically, the “commit” command is used to save all of your changes to the local repository. It is important to remember though that using the “git commit” command only saves a new commit object in the local Git repository. Exchanging commits has to be performed manually and explicitly (with the “git fetch”, “git pull“, and “git push” commands).

Git Command Differences

Since all three of these Git commands are very similar, it might be a little confusing at times regarding which command to use in any given development scenario. There is already a pretty steep learning curve when it comes to understanding how to use Git properly. So anything that can be broken down to help the overall aspect of the tool is always valuable to have at your fingertips.

In this article, I will give you some useful information on the git reset, git checkout, and git revert commands. Learning the little Git command differences will definitely help you along the way when it comes to properly using the relevant command at the relevant time.

Remember, Git is a vast system, and can be difficult to learn. Articles like this are a great way to learn the different parts of how it all works. If used correctly, Git can be a very useful tool to have in your back pocket.

Git command differences

I will also give you some reference points and talk a little about what each command does. This should at least help you differentiate the Git command differences when using them, as well as help you use them appropriately.

After reading this you should have a little more confidence navigating your repository and using the three commands correctly.

Git Reset, Revert, Checkout Reference Points

To better understand the Git command differences between these three, it will help if you think about each command in terms of their effect on the three-state management mechanisms of a Git repository. Those three state management mechanisms include:

  • The working directory
  • The staged snapshot
  • The commit history

The above components are oftentimes referred to as “the three trees” of Git.

The examples below sum up some of the most common use cases for all three of these commands. You could bookmark this page and keep these references handy. At some point, you will need to use at least some of them if you work with Git often.

Having access to the top 20 Git commands and examples will also be very useful as well. Learn the Git command differences and examples not only between these three, but between all the Git commands. This will put you on the road to becoming an expert Git user.

Git Command Differences References and Examples

Below you will find some references and examples for each of the three git commands we are talking about together in this article. You can view the command, scope, and a common use examples. This should help you even more when it comes to understanding the Git command differences between the three.

Below these examples, we go into the differences in a little more depth.

Git Reset

  • Command: git reset
  • Scope: Commit-level
  • Common Use Example: When you need to discard commits in a private branch or throw away uncommitted changes.


  • Command: git reset
  • Scope: File-level
  • Common Use Example: When you need to unstage a file.


  • Command: git checkout
  • Scope: Commit-level
  • Common Use Example: When you want to switch between branches or inspect old snapshots.

Git Checkout

  • Command: git checkout
  • Scope: File-level
  • Common Use Example: When you want to discard changes in the working directory.

Git Revert

  • Command: git revert
  • Scope: Commit-level
  • Common Use Example: When you want to undo commits in a public branch.


  • Command: git revert
  • Scope: File-level
  • Common Use Example: This is not applicable here.

Git Reset, Revert, Checkout Differences

The reference points above give you a good idea of when to use these three commands and at what level. Let’s take a look at the differences in a more defined layout.

git reset: This command is somewhat complicated. It actually does a couple of different things depending on how it is invoked. The command modifies the index (the so-called “staging area”). It can also change which commit a branch head is currently pointing at. This command may alter existing history (by changing the commit that a branch references).

git revert: This command can be considered an ‘undo’ type command. However, it is not a traditional undo operation. Instead of removing the commit from the project history, it figures out how to invert the changes introduced by the commit and appends a new commit with the resulting inverse content. This prevents Git from losing history, which is important for the integrity of your revision history and for reliable collaboration.

git checkout: This command operates on three distinct entities: files, commits, and branches. In addition to the definition of “checkout,” the phrase “checking out” is commonly used to imply the act of executing the git checkout command. The git checkout command allows you to navigate between the branches that are created by git branch. Checking out a branch updates the files in the working directory to match the version stored in that branch, and it tells Git to record all new commits on that branch.

Between the command scopes and examples above, as well as the more detailed paragraphs regarding the commands, you should be in a much better position when it comes to understanding how it all works.

Summing It All Up

These three commands, while different, should give you all the tools you need to undo any changes in your Git repository. The git reset, git revert, and git checkout commands can be confusing at times, especially because they are similar, while at the same time being very different.

However, now you have more of an idea about how they all work when it comes to the working directory, staged snapshot, and commit history of your Git project. Understanding Git command differences is one of the biggest aspects of learning how to use the Git system properly, and when to use the commands.

Remember, as stated above, Git will take some time to learn and understand. Hopefully, this rundown of git reset, git checkout, and git revert gives you a better understanding of how the commands work, when to use them, and above all, the differences between them.

When you learn proper Git command differences, you will put yourself in a much better spot when it comes to understanding how much the tool can actually do.

Author: Jeremy Holcombe

Growing up in Hawaii, Jeremy started his freelance writing career doing resumes, business plans, article writing, and everything in between. He now specializes in online marketing and content writing and is part of the Content Marketing Team at GreenGeeks.

Was this article helpful?

Related Articles

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.