How to Undo All Changes in Git?

In Git, there are times when you may need to discard all changes and restore your repository to a clean state. Whether you’ve made local changes you no longer need or want to revert back to a previous commit, Git provides flexible options for undoing changes at various stages.

This blog post explains how to undo changes in Git, step by step, covering scenarios like unstaged changes, staged changes, and committed changes.

1. Undo Unstaged Changes

Unstaged changes are modifications made to your files that have not yet been added to the staging area. You can undo these changes using the following commands:

Discard Changes in a Single File

To discard changes in a specific file:

git checkout -- <file>

Example:

git checkout -- index.html

Discard Changes in All Files

To discard all unstaged changes in the working directory:

git checkout -- .

Note: This command restores files to their state at the last commit, and the changes cannot be recovered.

---

2. Undo Staged Changes

Staged changes are files that have been added to the staging area but not yet committed. To unstage these files without losing the modifications:

Unstage a Single File

To remove a file from the staging area:

git restore --staged <file>

Example:

git restore --staged index.html

Unstage All Files

To unstage all files:

git restore --staged .

This moves the files back to the unstaged state while preserving their changes in the working directory.

---

3. Undo All Changes in the Working Directory and Staging Area

To discard all changes, both staged and unstaged, and restore the repository to its last committed state:

git reset --hard

Example:

git reset --hard

This command removes all uncommitted changes, including staged ones, and resets the working directory and staging area to match the last commit.

Warning: Use this command with caution as it erases all changes that haven’t been committed.

---

4. Undo a Commit

If you’ve already committed changes but want to undo them, there are a few options depending on whether the commit has been pushed to a remote repository.

Undo the Last Commit (Soft Reset)

To undo the last commit while keeping changes in the staging area:

git reset --soft HEAD~1

This removes the commit but retains the changes, so you can modify or recommit them.

Undo the Last Commit (Mixed Reset)

To undo the last commit and move the changes to the working directory:

git reset HEAD~1

Undo the Last Commit (Hard Reset)

To completely remove the last commit and all associated changes:

git reset --hard HEAD~1

Note: If the commit has been pushed to the remote repository, you’ll need to handle it carefully to avoid disrupting others. In such cases, consider using git revert.

---

5. Revert Changes to a Specific File

To undo changes to a specific file and restore it to the state of the last commit:

git restore <file>

Example:

git restore index.html

---

6. Clean Untracked Files

If you want to remove untracked files (files not under version control):

Remove All Untracked Files

git clean -f

Remove Untracked Files and Directories

git clean -fd

Perform a Dry Run Before Cleaning

To see what will be removed without deleting anything:

git clean -n

---

Summary of Commands

Action	Command	Effect
Discard unstaged changes in a file	git checkout -- <file>	Restores file to the last commit.
Discard all unstaged changes	git checkout -- .	Resets all files to the last commit.
Unstage a file	git restore --staged <file>	Removes a file from the staging area.
Unstage all files	git restore --staged .	Moves all files back to the working directory.
Discard all changes (hard reset)	git reset --hard	Resets working directory and staging area.
Undo the last commit (soft reset)	git reset --soft HEAD~1	Keeps changes staged but removes the commit.
Undo the last commit (mixed reset)	git reset HEAD~1	Moves changes to the working directory.
Remove untracked files	git clean -f	Deletes untracked files.
Remove untracked files and directories	git clean -fd	Deletes untracked files and directories.

---

Best Practices

1. Double-Check Before Resetting: Commands like git reset --hard and git clean -f are irreversible.
2. Commit Frequently: Regular commits minimize data loss in case of mistakes.
3. Use git status: Before undoing changes, use git status to understand the current state of your repository.
4. Dry Run for Cleaning: Always perform a dry run (git clean -n) to avoid accidental deletions.

---

Conclusion

Undoing changes in Git is a common yet critical operation for developers. Understanding when and how to use commands like git restore, git reset, and git clean ensures you can manage your repository confidently.

By mastering these techniques, you can keep your projects organized and recover gracefully from mistakes.