Undoing Mistakes: restore, reset, revert — Doing It Right and the Dangers

Git restore: The Undo Button for Files

• Git restore — undo uncommitted changes
• Works like an 'undo' button in an editor
• Safe — doesn't alter commit history
• Returns files to their last saved state

Imagine you've accidentally saved a file with errors and want to revert everything. Git restore acts like a magic undo button — it returns files to their last committed state. Unlike other undo commands, restore only works with uncommitted changes and is completely safe for your project's history. It's the first tool you should reach for when you need to quickly fix accidental edits without risking your change history.

Undoing Changes in the Working Directory

• git restore file.txt — return file to last commit
• Undoes all changes in working directory
• Safe — changes can be restored via editor
• Always check git status before restoring

Let's say you've spent half an hour editing a configuration file but realized you're going down the wrong path. Instead of manually reverting each change, execute git restore config.yml. The file will instantly return to its last committed state. It's like closing the file without saving, but with the guarantee that you're returning to a working version.

# Demonstrating file restoration
$ echo "Mistaken changes" > main.py
$ git status
$ git restore main.py
$ cat main.py
$ git status

Removing a File from the Index

• git restore --staged file.txt — remove file from the index
• Preserves changes in the working directory
• Warning: without --staged, changes will be lost
• Always check git status before executing

A common mistake is accidentally adding an unwanted file to the index. For example, you might have run 'git add .' and included a temporary settings file. The command 'git restore' with the --staged flag and the filename 'settings.tmp' will safely remove it from the index while preserving all changes in your working directory. Without the --staged flag, you would lose your work, so always check the status with 'git status' before running restore. Now you know how to undo changes before committing. But what if the mistake is already in the commit history? That's where git reset comes in.

# Accidentally added a file to the index
$ git add config.tmp
$ git status

# Remove from index while preserving changes
$ git restore --staged config.tmp
$ git status

# Verify the file remains in the working directory
$ ls -la config.tmp