Recovering Deleted Files in Git

Git is a powerful version control system, and a common scenario is accidentally deleting a file. Fortunately, Git provides several ways to recover these deleted files, even after commits have been made. This tutorial will guide you through the process of finding the commit that removed a file and restoring it to your working copy.

Understanding Git’s Approach to Deletion

Git doesn’t truly "delete" files in the way a traditional file system does. Instead, it records the removal of the file in the commit history. This means the file’s contents are still accessible in previous commits, allowing for recovery.

Finding the Commit That Deleted the File

The first step is to identify the commit that removed the file. Git provides the git rev-list command for this purpose. This command lists commits that modified a specific file.

git rev-list -n 1 HEAD -- <file_path>

git rev-list: The command for listing commit IDs.
-n 1: Limits the output to the most recent commit.
HEAD: Refers to the latest commit on the current branch.
-- <file_path>: Specifies the file to trace. Replace <file_path> with the actual path to the deleted file (e.g., src/main.py).

This command will output the commit hash (a long hexadecimal string) of the commit where the file was last present. The next commit after this one is the one that deleted it.

Restoring the Deleted File

Once you have the commit hash of the commit before the deletion, you can restore the file using git checkout.

git checkout <deleting_commit>^ -- <file_path>

<deleting_commit>: Replace this with the actual commit hash you obtained in the previous step.
^: This symbol (caret) instructs Git to use the parent commit of the specified commit. In other words, it gives you the commit before the deletion.
-- <file_path>: Specifies the file to restore.

This command will restore the deleted file to your working directory. It’s important to note that this command doesn’t create a new commit; it modifies your working directory to reflect the state of the file at that earlier commit. After restoring the file, you may need to stage and commit the changes:

git add <file_path>
git commit -m "Restored deleted file <file_path>"

Alternative for Zsh users: If you are using the Zsh shell and have extended globbing enabled, the caret symbol might not work as expected. In this case, you can use the tilde (~) symbol to refer to the parent commit:

git checkout <deleting_commit>~1 -- <file_path>

Restoring a File From HEAD (If Recently Deleted)

If you deleted the file and haven’t yet made any new commits since, you can often restore it using:

git checkout HEAD -- <file_path>

This command restores the file from the most recent commit (HEAD) if it existed there.

Using `git log` to Identify Deletions

You can also use git log to find commits where files were deleted:

git log --diff-filter=D --summary

--diff-filter=D: Filters the log to show only commits that include deletions.
--summary: Displays a concise summary of the changes in each commit.

This command will list commits that removed files, along with a summary of the changes. From there, you can identify the commit that deleted the file you’re interested in and use git checkout to restore it as described previously.

Restoring Multiple Deleted Files

While the commands above restore one file at a time, you can restore all deleted files in a folder using:

git ls-files -d | xargs git checkout --

This command lists all deleted files and pipes the output to git checkout, effectively restoring them all.

Important Considerations

Unstaged Changes: Be aware of any unstaged changes in your working directory before restoring files. Restoring an older version of a file will overwrite any local modifications.
Commit History: Restoring a file doesn’t change the commit history. The deletion will still be visible in the log.
Binary Files: Restoring binary files (e.g., images, PDFs) works the same way as restoring text files.