How to Reset or Revert a File to a Specific Revision in Git
Sometimes you need to revert a specific file to a previous version without affecting other files in your Git repository. Whether you've made unwanted changes, introduced bugs, or simply want to restore an earlier version of a file, Git provides several methods to accomplish this task safely and efficiently.
Prerequisites
Before following this tutorial, you should have:
- Git installed on your system
- A Git repository with commit history
- Basic understanding of Git concepts like commits, branches, and file states
- Knowledge of how to view commit history and file differences
Understanding File Restoration in Git
Git tracks every change to your files through commits, creating a complete history that you can navigate. When you want to restore a file to a specific revision, you have several options depending on your needs:
- Restore to working directory: Replace the current file with a previous version
- Restore to staging area: Prepare a previous version for commit
- Extract file content: Get the content without changing your current file
Method 1: Using git checkout (Traditional Method)
The git checkout
command can restore files from specific commits.
Restore File from Specific Commit
To restore a file to a specific commit:
git checkout <commit-hash> -- <file-path>
Example:
git checkout 3a7b9f2 -- src/main.js
This command:
- Retrieves the version of
src/main.js
from commit3a7b9f2
- Places it in your working directory
- Stages the file for commit
Restore File from Specific Branch
You can also restore a file from another branch:
git checkout main -- config/settings.json
Restore Multiple Files
To restore multiple files from the same commit:
git checkout 3a7b9f2 -- file1.txt file2.js src/component.vue
Method 2: Using git restore (Modern Method)
Git 2.23 introduced git restore
as a more intuitive alternative to git checkout
for file operations.
Restore File to Working Directory
git restore --source=<commit-hash> <file-path>
Example:
git restore --source=3a7b9f2 src/main.js
Restore and Stage File
To restore a file and immediately stage it:
git restore --source=3a7b9f2 --staged --worktree src/main.js
Restore from Different Branch
git restore --source=main src/main.js
Method 3: Using git show (Extract Content)
The git show
command lets you extract file content without modifying your current files.
View File Content from Specific Commit
git show <commit-hash>:<file-path>
Example:
git show 3a7b9f2:src/main.js
Save Content to File
git show 3a7b9f2:src/main.js > src/main.js.backup
git show 3a7b9f2:src/main.js > src/main.js
This approach gives you more control and allows you to:
- First save a backup of the current version
- Then replace the file with the previous version
Finding the Right Commit
Before restoring a file, you need to identify which commit contains the version you want.
View File History
git log --oneline <file-path>
Example:
git log --oneline src/main.js
Output:
3a7b9f2 Fix bug in main function
8c4d1e9 Add error handling
f2a5b8c Initial implementation
View File Changes in Each Commit
git log -p <file-path>
This shows the actual changes made to the file in each commit.
Find When File Was Last Modified
git log -1 --pretty=format:"%H %s" <file-path>
Practical Examples
Example 1: Restore Configuration File
Suppose you modified a configuration file and want to restore it to the last working version:
# Find the commit with the working configuration
git log --oneline config/database.yml
# Restore the file from 2 commits ago
git restore --source=HEAD~2 config/database.yml
# Stage the restored file
git add config/database.yml
Example 2: Restore Deleted File
If a file was accidentally deleted and you want to restore it:
# Find the last commit that contained the file
git log --oneline --diff-filter=D -- deleted-file.txt
# Restore the file from the commit before it was deleted
git restore --source=HEAD~1 deleted-file.txt
Example 3: Restore File from Specific Tag
# Restore file from a tagged version
git restore --source=v1.2.0 src/important-feature.js
Example 4: Partial File Restoration
To restore only specific lines or sections, use interactive mode:
git checkout -p <commit-hash> -- <file-path>
This allows you to selectively apply changes from the specified commit.
Comparing File Versions
Before restoring, you might want to compare different versions:
Compare Current File with Previous Version
git diff <commit-hash> <file-path>
Compare Two Specific Versions
git diff <commit1-hash> <commit2-hash> <file-path>
View Side-by-Side Comparison
git difftool <commit-hash> <file-path>
Handling Common Scenarios
Scenario 1: Undo Recent Changes
To restore a file to its state in the last commit:
git restore <file-path>
# or
git checkout HEAD -- <file-path>
Scenario 2: Restore File from Stash
git stash show -p stash@{0} <file-path> > temp.patch
git apply temp.patch
rm temp.patch
Scenario 3: Restore Binary Files
For binary files, use the same commands but be aware that diff operations won't show meaningful content:
git restore --source=3a7b9f2 assets/logo.png
Safety Considerations
Create Backups
Before restoring important files, create backups:
cp important-file.js important-file.js.backup
git restore --source=3a7b9f2 important-file.js
Check File Status
After restoration, verify the changes:
git status
git diff --staged
Commit Restored Files
Don't forget to commit the restored files:
git add restored-file.js
git commit -m "Restore file to working version from commit 3a7b9f2"
Troubleshooting
File Not Found in Commit
If Git says the file doesn't exist in the specified commit:
# Check if file exists in that commit
git ls-tree <commit-hash> <file-path>
# List all files in the commit
git ls-tree -r <commit-hash>
Path Conflicts
If you have path conflicts, use full paths:
git restore --source=3a7b9f2 ./src/components/Header.vue
Binary File Issues
For binary files, ensure you're using the correct commit hash and file path:
git show --name-only <commit-hash>
Best Practices
- Always backup important files before restoration
- Verify commit history to ensure you're restoring the right version
- Test restored files before committing changes
- Use descriptive commit messages when committing restored files
- Consider creating a branch for testing restored files
- Document the reason for file restoration in commit messages
By learning these file restoration techniques, you can confidently recover previous versions of files, undo unwanted changes, and maintain better control over your project's file history.
Found an issue?