So you want to know how to undo the most recent local commits in git? As programmers, sometimes we make mistakes. The good news is that Git makes it easy to retract these recent commits and get you back to your previous version of your codebase quickly.

This guide will walk you through the process of undoing your last few commits safely and effectively.

In case you are like most programmers and blindly copy and paste things from the internet without ever reading them, here are all the commands to use in order. These commands will work whether you are using Windows, macOS, or Linux.

1
2
3
4
:: use this command to find the hash of the commit you need
> git log --oneline 
:: use this command to revert this commit
> git revert [hash] --no-edit

Why Undo Recent Commits?

There are several reasons why you might need to undo recent commits:

  • Correcting Mistakes: Fix errors in your code or commit messages.
  • Reorganizing Commits: Reorder, squash, or split commits for better clarity.
  • Removing Sensitive Information: Eliminate accidental commits of sensitive data.
  • Improving Commit History: Maintain a clean and meaningful project history.

Undo Local Commit

Now, let’s go over to our PowerShell / Terminal / GitBash / wherever you are running your commands.

The first thing we are going to run is:

The first thing we are going to run is:

1
> git status

This will show us there are no commits yet but we have an untracked file called ‘hello-world.js’.

We then run:

1
git add hello-world.js

This will track the files and get them ready for a commit.

Finally, we commit our changes and write a high-quality message so we can find out commit later. To do so, we run:

1
git commit -m "finished hello world enterprise level application"

committing our changes

Check Git Log For Hash Number

Uh-oh! We realized our application is complete trash and don’t want a digital history of the terrible code we wrote! How do we undo this most recent commit?

Easy, all we have to do is find the hash from the commit we want to revert to and revert it.

To start, let’s run the command:

1
> git log --oneline

run ‘git log –oneline’ command

Revert Our Commit

As you can see from the above command line, we are given a list of commits we have made. Since we only made one commit, there is only one:

1
241f323 (HEAD -> master) finished hello world enterprise level application

The hash we are looking for is ‘241f323’. If you had multiple commits, you would need to search for the commit you want to revert. This is why messages are important!

Now let’s revert the changes by running the command:

1
> git revert 241f323 --no-edit

The ‘–no-edit’ portion of the command is simply used to remove the necessity to write a message. Don’t worry, this change will be obvious without your message. As we will see below.

run ‘git revert [hash]–no-edit’ command

That’s it! You should have successfully reverted your changes. If you look back at your code editor, the code you wrote should be gone.

after reverting changes

Adding A Revert Commit

Now, this little trick doesn’t exactly ‘undo’ your changes. Rather, it creates an additional commit that removes all the changes you made in the identified commit. If we run that ‘git log –oneline’ command again, it will show us there are now two commits, not zero!

One is our original commit, and the second is our ‘reverted’ commit that removed those changes.

1
2
1e0ad5d(HEAD -> master) Revert "finished hello world enterprise level application"
241f323 finished hello world enterprise level application

While you may just want to forget about that dumb mistake you made, there is a reason Git does this. If you ever want to revert back and see those original changes you made, you easily can with ‘git checkout’!

Summary: Undoing Local Commits In Git

The git reset command is powerful and versatile, allowing you to undo commits while preserving or discarding changes in your working directory.

Using git reset

The `git reset` command is powerful and versatile, allowing you to undo commits while preserving or discarding changes in your working directory.

Undo the Most Recent Commit

To undo the most recent commit while keeping the changes in your working directory, use:

1
git reset --soft HEAD~1

--soft : Keeps your changes staged (in the index).

To undo the most recent commit and discard the changes in your working directory, use:

1
git reset --hard HEAD~1

--hard : Discards all changes, both staged and unstaged.

Undo Multiple Recent Commits

If you need to undo multiple recent commits, specify the number of commits:

1
git reset --soft HEAD~3

This example undoes the last three commits, keeping the changes staged.

Using git revert

The `git revert` command is a safer alternative, especially when working with a shared repository, as it creates a new commit that undoes the changes from the specified commit.

Revert the Most Recent Commit

To revert the most recent commit, use:

1
git revert HEAD

This creates a new commit that undoes the changes of the last commit.

Revert Multiple Recent Commits

To revert multiple commits, specify a range:

1
git revert HEAD~3..HEAD

This reverts the last three commits, creating new commits that undo the changes.

Using git commit –amend

If you only need to modify the most recent commit message or make minor changes to the commit, use:

1
git commit --amend

This opens your default text editor, allowing you to modify the commit message. If you want to add or remove files from the commit, stage the changes before running the `–amend` command.

Example 1: To undo the Most Recent Commit and Keep Changes

1
git reset --soft HEAD~1

This command undoes the most recent commit, keeping the changes staged.

Example 2: To undo the Most Recent Commit and Discard Changes

1
git reset --hard HEAD~1

This command undoes the most recent commit and discards all changes.

Example 3: Revert the Most Recent Commit

1
git revert HEAD

This command creates a new commit that undoes the changes of the most recent commit.

Example 4: Amend the Most Recent Commit Message

1
git commit --amend

This command allows you to edit the most recent commit message.

Frequently Asked Questions

Can I undo multiple local commits at once?

Yes, you can undo multiple local commits at once using the `git reset` command with a specific commit hash. Simply specify the commit hash of the commit you want to reset to, and Git will move the HEAD pointer to that commit, effectively undoing multiple commits at once.

Will undoing local commits affect my remote repository?

Undoing local commits does not have an immediate impact on your remote repository. The changes are only reflected in your local repository until you push the changes to the remote repository.

It is essential to communicate with your team members and ensure that any undone commits are properly managed and synced with the remote repository.

How can I undo a commit but keep the changes as uncommitted changes in my working directory?

To undo a commit but keep the changes in your working directory, you can use the `git reset –soft` command. This command will undo the commit but leave the changes in your working directory, allowing you to make further modifications or revisions before committing the changes again.

Conclusion

In conclusion, effectively managing local commits in Git workflows is essential for maintaining a clean commit history, tracking changes, and collaborating with team members. Undoing local commits when necessary can help developers address errors, changes in requirements, or any unforeseen issues that may arise during the development process.

By practicing the methods outlined in this blog post and familiarizing yourself with how to undo local commits in Git, you can streamline your development workflow and ensure a smooth and efficient coding experience. Remember to always test undoing local commits in a safe environment before applying them to real projects to avoid any unintended consequences.

Happy coding!