Restoring Files to Previous Revisions with Git

Git is a powerful version control system that tracks changes to your files over time. Sometimes you might need to revert a file to a previous state – perhaps you made an unwanted change or need to revisit a specific version. This tutorial will guide you through the process of restoring files to previous revisions in Git.

Understanding Git Revisions

In Git, every change to your files is recorded as a "revision" or "commit." Each commit has a unique identifier, known as a SHA-1 hash. You can view the commit history of your project using the git log command. This command displays the commit hash, author, date, and commit message for each revision.

Restoring a File to a Specific Revision

The primary way to restore a file to a previous revision is using the git checkout command. The syntax is as follows:

git checkout <commit-hash> -- <file-name>

<commit-hash>: The unique identifier of the commit containing the desired version of the file.
--: A separator that tells Git that the following arguments are file paths, not branch names. This is crucial for preventing ambiguity.
<file-name>: The path to the file you want to restore.

Example:

Let’s say you want to revert my_file.txt to the version found in commit a1b2c3d4. You would run:

git checkout a1b2c3d4 -- my_file.txt

This command will overwrite the current version of my_file.txt with the version from the specified commit.

Restoring Multiple Files

You can restore multiple files at once by listing them after the -- separator:

git checkout a1b2c3d4 -- file1.txt file2.txt file3.txt

Going Back One Revision

You can easily revert to the previous commit using the ~1 notation. This is shorthand for "one commit before the current commit".

git checkout HEAD~1 -- my_file.txt

You can use other numbers as well. HEAD~2 would revert to the commit two revisions before the current one.

Using `git restore` (Git 2.23 and later)

Git 2.23 introduced the git restore command, which is designed specifically for restoring files in your working directory. It aims to be a more intuitive alternative to git checkout for this purpose.

The syntax is as follows:

git restore --source=<commit-hash> <file-name>

--source=<commit-hash>: Specifies the commit from which to restore the file.
<file-name>: The path to the file you want to restore.

Example:

To restore my_file.txt to the version in commit a1b2c3d4:

git restore --source=a1b2c3d4 my_file.txt

Like git checkout, you can also restore multiple files at once:

git restore --source=a1b2c3d4 file1.txt file2.txt

You can use the ~1 notation to go back one revision as well:

git restore --source=a1b2c3d4~1 my_file.txt

Important Note: While git restore is intended to be the preferred method for restoring files, it was initially marked as experimental. If you are using an older version of Git, it might not be available or fully functional.

Viewing Changes Before Restoring

Before restoring a file, it’s often helpful to see the differences between the current version and the version you’re about to restore. You can use the git diff command for this:

git diff <commit-hash> <file-name>

This will display a patch showing the changes made between the specified commit and the current version of the file.

Best Practices

Commit Frequently: Regular commits create a clear history and make it easier to revert to specific revisions.
Review Changes: Use git diff to review the changes before restoring a file, ensuring you’re reverting to the correct version.
Stash or Commit Local Changes: If you have uncommitted changes in your working directory, stash them or commit them before restoring a file. Restoring a file will overwrite local changes, so you don’t want to lose your work.
Choose the Right Command: git checkout is a versatile command, but git restore (in newer Git versions) is specifically designed for restoring files and can be more intuitive.