How to Undo Almost Anything in Git: A Developer’s Guide to reset, revert, and amend
Every developer knows the feeling: you’ve just made a commit, pushed a change, or staged a file, only to realize you’ve made a mistake. In the fast-paced world of software development, errors are inevitable. Fortunately, Git provides a powerful set of tools for undoing your actions. Understanding how and when to use these commands can save you from major headaches and help you maintain a clean, coherent project history.
This guide will walk you through the most common scenarios where you might need to reverse a change, explaining the best command for each situation.
Scenario 1: You Just Committed, But Made a Mistake
This is perhaps the most common “oops” moment. You just ran git commit, but you either forgot to add a file or made a typo in the commit message. As long as you have not yet pushed this commit to a remote repository, the fix is simple and clean.
The command you need is git commit --amend.
This powerful command lets you modify your most recent commit. Instead of creating a brand-new commit, it essentially replaces the previous one with an updated version.
To fix the commit message:
Simply run the command by itself.
git commit --amend
This will open your default text editor, allowing you to edit the message of the last commit. Save and close the editor, and your commit message will be updated.
To add forgotten files to the last commit:
If you forgot to stage a file, you can easily add it to the previous commit.
# First, stage the file you forgot
git add forgotten_file.js
# Now, run the amend command
git commit --amend --no-edit
The --no-edit flag amends the commit with your newly staged file without prompting you to change the commit message. Your last commit now includes the file you previously missed.
A crucial word of caution: You should never amend a commit that has already been pushed to a shared repository. Amending rewrites commit history. If others have already pulled the original commit, this will create major conflicts and confusion for your team.
Scenario 2: Cleaning Up Your Working Directory and Staging Area
Sometimes the mistake happens before you even commit. You might have staged the wrong file or made experimental changes to a file that you now want to discard completely.
Unstaging a File
If you’ve used git add on a file but decided you don’t want to include it in the next commit, you can easily “unstage” it.
To move a file out of the staging area and back into your working directory, use git reset HEAD <file>.
# This unstages the file but keeps your changes
git reset HEAD specific_file.html
The file is no longer staged, but any modifications you made to it are still safe in your working directory.
Discarding All Local Changes to a File
What if you’ve made a mess of a file and just want to revert it to the version in your last commit? You want to throw away all your current, uncommitted changes.
The command for this is git checkout -- <file>. (Newer versions of Git also offer the more intuitive git restore <file>).
# Warning: This will permanently delete your changes to this file!
git checkout -- broken_file.css
This is a destructive operation. When you run this command, you will lose all the modifications you made to that file since your last commit. Git does not save these changes anywhere, so be absolutely certain you want to discard them before proceeding.
Scenario 3: Undoing a Commit That’s Already Public
This is the most sensitive scenario. You’ve made a commit, pushed it to the central repository, and now your teammates may have already pulled it. You cannot use git commit --amend or git reset here, as rewriting public history is a major breach of Git etiquette.
The safe and correct way to undo a public change is with git revert.
Unlike reset or amend, which alter existing history, git revert creates a new commit that is the exact inverse of a previous commit. If the old commit added a line of code, the new “revert commit” will remove that line.
This approach has two major benefits:
- It does not rewrite history, which makes it safe for shared branches.
- It clearly documents the reversal. Anyone looking at the project history can see that a specific commit was made and then later reverted.
To use it, find the hash of the commit you want to undo and run:
# This will create a new commit that undoes the changes from the specified commit
git revert <commit-hash>
Git will prompt you to create a commit message for this new revert commit. It’s good practice to leave the default message, which typically says “Revert ‘[original commit message]'”.
Quick Reference: Which ‘Undo’ Command Should You Use?
- To fix your very last commit (private): Use
git commit --amend. - To unstage a file before committing: Use
git reset HEAD <file>. - To discard all local changes in a file: Use
git checkout -- <file>. Use with extreme caution. - To safely undo a public, pushed commit: Use
git revert <commit-hash>. This is the gold standard for collaborative projects.
Mastering these “undo” commands is a key step toward becoming proficient with Git. By choosing the right tool for the job, you can correct mistakes gracefully without disrupting your workflow or causing problems for your team.
Source: https://linuxhandbook.com/courses/git-for-devops/undo-in-git/
