Difference between Checking out/revering/resetting

Introduction

The Git reset, Git checkout, and Git revert commands are the most helpful tools in your daily Git workflow. The first two commands can be used to manipulate either the commits or the content in the specific files, and all commands allow you to undo some type of change in your repository.

Because they are so similar, it can be difficult to know which command to execute in a given development environment. The most popular use for Git reset, Git checkout, and Git revert command are contrasted in this article.

To better understand the differences between these three commands, let's look at the three-state management mechanisms of a Git repository. Those three state management mechanisms include:

• The local working directory
• The snapshot of the staged environment
• The commit history of the local repository

The following section summarizes the examples of the most common use cases for all three of these commands.

Use of Git Checkout

This Git checkout command checks out the content from the repository and inserts it into your working directory. It may have other effects depending on how the command was invoked. For example, you can switch/change the current branch you are working on using the Git checkout command. The thing to note here is that this command does not change the history of commits in your Git repository.

The Git checkout command operates upon three different entities which are branches, files, and commits.

Example of Git Checkout

Let's see how you can use the checkout command when you want to discard the changes in your working directory. Let's create an example Git repository with an empty index.cpp file.

We have a single commit and there is nothing written in the index.cpp file. Now, let's add some code to the file. If you make this change, you must add the file to the staging area and commit it. These updates are now in your workspace. To check them, you can use the Git status command:

Now, we have a change Hello World! which is untracked in our working repository and we need to revert this change. The command used to checkout the file is:

Git checkout is used to discard the unstaged changes in the working repository.

When we write the Git checkout command and see the status of our Git repository and also the index.cpp file, we can see that our changes are being discarded from the working directory and we are back again to the empty file that we had before.

We can see our file is now empty and does not have any code in it.

We can also use the checkout command to switch between the branches, let's say we have two branches in our local repository, master and dummy and we are currently on a master branch.

To checkout to a dummy branch, we can use the command:

Now, we can see a branch has been switched and now we are on a dummy branch.

Explanation of the Output

The output of the command git checkout file name> shows that our changes are being removed from the working directory and we have returned to the empty file as we had earlier. You can also see that using the checkout command, we can also switch between the branches.

Use of Git Revert

Revert is the Git phrase for undoing some changes in our local repository. The revert process is carried out using the Git revert command. This command works in a undo style. It will make a new change having the opposite effect, by undoing the given commit.

This method does not remove any data.

Additionally, we can assert that Git revert adds new modifications that are exactly the reverse of the commits that have already been performed. We can run the below command to revert the changes:

Git offers a convenient mechanism to roll back commits, which is typically used when things don't go as planned or if you want to make extra modifications to the pushed commit. This is especially helpful when tracking down a bug and learning that a single change is what caused it. You can use the Git revert command to perform all of this automatically rather than manually repairing it and producing a new snapshot/commit.

In Git, the revert command generates a new commit that undoes the modifications made in the target commit (the commit which we want to revert).

By entering the commit id of the commit you want to undo, it can be used to roll back any commit.

where commit id is a special identifier assigned to each commit at that time that is produced automatically. An encrypted number created with the Secure Hash Algorithm is a commit ID (also known as SHA). To view the history of commits for a specific repository, use the Git log command.

Let's look at the random example of some logs to see how to use the Git log command to retrieve the commit id:

The output of the above command will return the list of commits in the history of your Git repository as shown below:

The alphanumeric character at the beginning of these sentences stands in for the commit id for a certain commit.

The above Git revert command is used to revert and roll back a specific commit by its commit id. You can also use HEAD for the last commit in history to revert the last commit specifically:

The way the Git revert command operates by producing a new commit that includes the modifications made as a result of going back in time. This is due to the fact that rolling back truly undoes the committed change. You need to recommit your changes to push those reverted changes to the remote repository.

When you run the Git revert command, Git automatically opens a text editor to modify and apply your changes. Here, you will find the details of the commit you are trying to revert to, and you can give your new commit message for an existing commit here, and then you can save and close a file.

Once the commit message has been processed, you will see a message containing the new commit id.

This action creates a new commit based on the commit specified in the revert command. This new commit is shown in the logs of Git, showing that a new commit was issued for rolling back the changes of the last commit. It shows the complete history of commits instead of pretending it never happened. The Git log will have all the history of commits. So, if you want to remove the commits from the history and do not want to show the commit created for reverting the changes, then the revert command is not a good choice for you, but if you want to maintain the history of committed changes, then revert is the suitable command for you instead of the reset command.

You can also edit the commit message directly and the command used to revert a specific commit while editing the commit message is:

Let's summarize some of the commands using the revert method in Git:

1. Command used to revert or undo the operation and changes done in Git:

2. Command used to revert and roll back a particular commit with its commit id:
   It works by creating a new commit that is the exact opposite of the work done in the given commit.
3. To revert back a particular commit along with editing the commit message, you can use the:

4. Command used to revert the latest commit:

This command creates a new commit that undoes the changes from a previous commit. This command adds a new history to the project on top of the existing commit history and it does not modify the existing commit history.

Example of Git Revert

In our dummy branch, we have created a few more files and the current history of the branch looks like this:

Now, we can undo the commit of adding the index3.cpp file.

Now, the current commit history after reverting the commit looks like this for the dummy branch:

Explanation of the Output

From the above output, we can see that the Git revert command removes the commit that we have asked but it adds one more commit which shows that the revert operation has been done on that specific commit (which we reverted).

Use of Git Reset

The term reset refers to undoing the changes. The Git reset command is used to roll back the changes. The Git reset command has three main options available for resetting the commit and the changes in our local repository. These options are:

• Soft
• Mixed
• Hard

In Git terms, Git reset is a tool that resets the current reference state to a new specified state.

Git enables us to reset a certain commit when we need to. We can go back to a certain commit. Any parameter that is provided by the reset command may be used in conjunction with the Git reset command to reset it. It will use the command's default action (mixed option is the default) and reset the specified commit. The syntax for resetting the commit is given below:

Here, the different options can be

• soft
• mixed
• Hard

This command is a little more complicated than the other two commands we saw above as it changes which commit a branch head is currently referring/pointing at and this command may alter the existing commit history by changing the commit that a branch references.

Example of Git Reset

Let's see the examples of using the Git reset command. Suppose you are on a master branch, and currently, you have the changes of the index.cpp file in the staging area, now you can use the Git reset command to remove files from your staging environment and push your changes back to your working directory.

The command used for unstaging the changes of a file is:

Now, we can again check the status:

Now, we are back to the working directory where the changes are, but the file is now unstaged. Now there are also some commits that we don’t want to commit and we want to remove them from our local repository. To see how to remove the commit from our local repository, let’s first stage and commit the changes and then remove that commit.

We have 2 commits now, with the latest updated index.cpp file commits which we are going to remove. The command used to reset the commit is:

Here, HEAD~1 means that we are going to remove the topmost commit or the latest commit that we have done.

Explanation of the Output

As we saw in the output above, the Git reset command removes the commit as well as unstages the file, but our changes will still be stored in the local repository if we are using the default option of mixed resetting.

We can see from the below images that the file has been unstaged and the commit is no longer seen in the logs:

We also saw in the above example that we can reset a file in Git using the git reset HEAD <name_of_file> command, which will bring the file back to the local repository, where our changes are present but the file will be unstaged now.

Difference between Git Revert, Checkout, Reset