How to Recover Deleted Files from GitHub?

Accidentally deleting files in a GitHub repository can be a source of frustration, especially if the files are important for your project. Fortunately, GitHub’s integration with Git makes it possible to recover deleted files, even if they were deleted long ago.

Whether you’ve deleted a file through the GitHub web interface or through the command line, this blog will guide you through the process of recovering deleted files from GitHub using Git.

Why Does GitHub Retain Deleted Files?

GitHub relies on Git, a version control system, which keeps track of changes to your repository over time. This includes the history of all commits, including those where files were added, modified, or deleted. Even if you delete a file from the latest commit, Git preserves the history of all changes, allowing you to recover files from previous commits.

This powerful feature ensures that even if files are deleted, they can be restored from earlier versions of the repository.

Steps to Recover Deleted Files from GitHub

Step 1: Check the Git Commit History

Git records every change made to the repository, including file deletions. If you accidentally deleted a file, the first step is to check the commit history to find the commit before the deletion.

1. Open Your Local Repository:
   Open your terminal or Git Bash and navigate to your local repository. cd path/to/your/repository
2. View the Commit History:
   Use the git log command to see the commit history of your repository: git log --oneline --graph This will show you a list of commits, including their hashes (commit IDs), in a simplified, one-line format. Example: * abc1234 (HEAD -> main) Add new feature * def5678 Fix bug in feature X * ghi9012 (origin/main) Delete file.txt In this example, the commit ghi9012 deleted file.txt. You want to find the commit before this one (e.g., def5678).

Step 2: Check the Deleted File in a Previous Commit

Once you identify the commit where the file was deleted, the next step is to locate the file in the previous commit.

1. Use Git Checkout to View the Deleted File:
   You can use the git checkout command to restore the file from a previous commit without modifying your current working directory. You will specify the commit hash and the file you want to recover. git checkout <commit-hash>^ -- <path/to/deleted/file> In this command:
   • <commit-hash> is the hash of the commit where the file was deleted (e.g., ghi9012).
   • The ^ symbol refers to the parent commit, which is the commit before the deletion.
   • <path/to/deleted/file> is the path to the file you want to recover (e.g., file.txt).
   Example: git checkout def5678^ -- file.txt This command checks out the version of file.txt from the commit before the deletion and restores it to your working directory.
2. Verify the File:
   After running the command, the file will be restored to your local repository. You can check if the file has been recovered by listing the files: ls

Step 3: Add and Commit the Recovered File

Once you’ve recovered the deleted file, you’ll need to stage it and commit it to the repository.

1. Stage the Recovered File: git add <path/to/deleted/file> Example: git add file.txt
2. Commit the Changes: git commit -m "Recover deleted file.txt" This commits the recovered file to your local repository.
3. Push the Changes to GitHub:
   After committing the changes, push the recovery commit to GitHub: git push origin main This pushes the commit with the recovered file to the remote repository on GitHub.

Alternative Method: Using GitHub Web Interface (For Recent Commits)

If you’re working with a GitHub repository and need to recover a recently deleted file, you may be able to use the GitHub web interface, particularly if you haven’t yet cloned the repository locally.

1. Navigate to the Repository:
   Go to the repository on GitHub where the file was deleted.
2. Access the Commit History:
   Go to the “Commits” section of the repository by clicking the Commits link on the main page of your repository.
3. Find the Commit with the Deleted File:
   Browse through the commit history to find the commit where the file was deleted.
4. View the File in Previous Commit:
   Once you find the relevant commit, click on the commit hash to view the commit details. You can use the Browse files feature to see the state of the repository at that specific commit.
5. Restore the File:
   On the commit page, you should see the file in its state before deletion. GitHub provides the option to download individual files, or you can manually copy the contents and add them back to the current working branch.

Best Practices to Prevent Future File Deletions

While Git makes it easy to recover deleted files, it’s still important to take proactive steps to minimize the risk of accidental deletions.

1. Create Backups: Always back up important files to an external storage or cloud service.
2. Use Branches: Work in feature branches and merge into the main branch after careful review. This reduces the risk of making accidental changes to critical files.
3. Use Git Tags: Create tags for important commits, such as project milestones or stable versions, so you can easily revert to them if necessary.
4. Use .gitignore: Ensure that unnecessary or sensitive files are excluded from version control by adding them to a .gitignore file.
5. Enable Protected Branches: On GitHub, enable branch protection rules to prevent direct pushes to critical branches like main or master, reducing the chances of accidental deletions.

Conclusion

Recovering deleted files from GitHub is a straightforward process thanks to Git’s version control capabilities. Whether you’re working locally or directly on GitHub, Git makes it easy to trace your commit history and restore files from previous commits.

By following the steps outlined above, you can confidently recover deleted files and restore your codebase to its desired state. Remember to use best practices for version control to prevent accidental deletions and keep your project safe.