How to Delete a File You Upload to Github
Every developer has deleted the wrong file from their project at least once. It tin either be a hastily executed`rm -rf` command, or an absent select and delete, or mayhap the result of an erroneous script. Whatever the reason, deleting an important file can exist troublesome if not fixed immediately. When working with a team, accidentally deleting a file and and so pushing it upstream tin be catastrophic for other team members who pull the changes. Depending on the file, either they'll get an error straight away, or in the worst instance, the mistake will pop up somewhere down the line—perhaps in some not-so-obvious place—at which betoken, it might be difficult to figure out the verbal cause.
So, now that you have accidentally deleted a file, or files, how do y'all recover them? Since Git is a version command system, information technology has features to roll back a unmarried file to a previous version, including deleted files.
In this tutorial, we'll look at three means to recover a deleted file: using the Git control line, using GitHub's web and app UI, and using a full-scale backup solution with BackHub.
You can follow along with this tutorial by cloning the demo repository.
Recovering Deleted Files with the Control Line
Recovering a deleted file using the Git command line involves the `git restore` or `git checkout`command. Whenever you alter files in Git—including creating new files, editing, or deleting existing files—the changes first equally unstaged. And so you stage the changes with the `git add` command, and finally, you commit the changes using the `git commit` command. Git provides ways to recover a deleted file at whatever signal in this life cycle of changes.
If y'all have non staged the deletion yet, only run`git restore <filename>` and the file will be restored from the index.
If you have staged the changes, however, running `git restore` will throw an error, since the file does not exist in the alphabetize anymore.
In this case, you need to run`git restore --staged --worktree <filename>`. The`--staged` argument tells`git` to restore the file in the alphabetize from Head, and the`--worktree` argument tells Git to restore the working tree likewise.
If you lot have deleted the file and already committed the changes, you need to use the `git checkout` control to restore the file. First, you need to find out the checksum of the commit that deleted the file, and then check out the file from the previous commit.
In the demo repo,`file1.txt` has already been deleted and committed. Let's recover that file. To effigy out which commit deleted`file1.txt`, you need to apply the`git rev-list` command:
```
git rev-list Head -northward one -- file1.txt
```
This command tells `git` to list all commits, which can be reached from the HEAD, that inverse the file`file1.txt`. The`-due north 1` selection tells`git` to limit the consequence to only one commit. The output is the checksum of the commit that deleted the file. Y'all tin can bank check that this is the offending commit by using the `git show` command with the checksum –
The commit before this one is the last commit where this file was present. You can restore the file from that particular commit past running the following command. The`^` at the end of the commit hash tells Git to fetch the commit earlier this 1:
"`
git checkout 3d5210ddd8632d539ed3f5e362dc047ed508a510^ file1.txt
"`
Pros and Cons of Using the Control Line
This method is the quickest to perform since you lot simply need access to the command line. Notwithstanding, it requires you to run different commands depending on your state of affairs. Also, it might not exist the easiest to principal, and some developers may prefer a more visual approach.
Using the GitHub Desktop App
If you are more comfortable with a graphical interface, yous can employ the GitHub Desktop, which is bachelor for macOS and Windows. Like to the previous case, there are two scenarios: one where you take not committed the deletion, and one where you take.
Any changes you make in your repository will show up in the staging area in the left sidebar of the app. There you can discard the changes, which works similar to the`git restore` control. If you lot have not still committed the deletion, you can use this characteristic to quickly recover the deleted file.
Get ahead and delete`file5.txt` from the repository and come up back to GitHub Desktop. You should see the deletion in the staging surface area.
You can correct-click on the modify and click onDiscard changes.
You will be asked for confirmation. One time confirmed, the change will be discarded and the deleted file will exist back in its place.
If you accept already committed the alter, you lot demand to know the commit hash of the offending commit. There is no way to do that from the GitHub desktop app, so yous need to use the command line and run the`git rev-listing` command we discussed before.
Just like before, let's restore the already deleted`file1.txt`. Kickoff, you need to know the hash of the commit that deleted the file:
```
$ git rev-list HEAD -due north 1 -- file1.txt
3d5210ddd8632d539ed3f5e362dc047ed508a510
```
In the app, the commits are listed with their names, not hashes. In guild to know the proper name of the commit, you need to run`git testify` command with the commit hash:
```
git show 3d5210ddd8632d539ed3f5e362dc047ed508a510
```
The name of the commit is "Add file4." Next, locate this commit in theHistory tab in the app.
Right-click on the commit and selectRevert changes in commit.
This will revert the offending commit and create a new commit.
Pros and Cons of Using GitHub Desktop App
This method is comparatively easier than using the command line and a better choice if you're comfortable with graphical interfaces. However, it has the following disadvantages:
- The desktop app is only available for Windows and macOS. If you're using Linux and so you won't be able to utilize this method.
- If y'all accept already committed the deletion, this method becomes cumbersome since you need to use the command line to find the commit name and then search through the history in the app to locate the commit.
- It is not possible to check out merely the required file from the commit using this method. You need to revert the entire commit, which means any other changes made by the commit will be reverted as well.
Using the GitHub Spider web UI
If you accept committed the deletion and pushed it to GitHub, information technology is possible to recover a deleted file using the GitHub Spider web UI. GitHub lets you browse the commit history and explore the project at any bespeak in history, which then allows you to view and download any file.
Let's recover the already deleted`file1.txt` in the repository. Similar to the previous arroyo, you need to know which commit deleted the file, using the`git rev-listing` command explained before. In our case, the commit hash is `3d5210ddd8632d539ed3f5e362dc047ed508a510`.
Open a browser and visit the URL –`https://github.com/<username>/<repo-name>/commits/3d5210ddd8632d539ed3f5e362dc047ed508a510^`. Make sure to supersede`<username>` and `<repo-name>` to point to your repository. This volition open up the commit before the offending commit.
Click onBrowse files and you will be presented with the projection structure of that particular commit.
Find the file yous desire to restore. In this case`file1.txt`. Open it past clicking on it.
Click on theRaw button and you will be presented with a raw text version of the file. You tin right-click on the page and selectSave As to download the file and salvage it to your projection. Now you can add information technology back to your local repo and commit –
```trounce
git add together file1.txt
git commit -m "Reintroduce file1.txt"
```
Pros and Cons of Using GitHub Web UI
Similar to using the app, this method is easier to use than the CLI method because of its graphical interface. You lot tin can too visually browse the repository at any point of your commit history without having to clone or checkout the commit.
The biggest disadvantage of this approach, nevertheless, is that in that location is no mode of selecting and downloading more than ane file. Then if you accept accidentally deleted more than i file, you have to download them i past one—a time-consuming job. Additionally, this method somewhat relies on the command line since you need the command line to figure out the commit hash.
Using a Full Backup
Recovering a deleted file with Git is a insufficiently complex process. Not only do you have to dabble with the command line to try and figure out the commit hashes, but you lot besides have to make sure that the commit you're restoring the file from is indeed the correct i. If you have accidentally deleted more than 1 file, restoring them from different commits can introduce inconsistency into your project. Using a full backup solution like BackHub can salve yous some trouble by backing up the entire repository, thus ensuring a consistent country.
BackHub offers powerful features like nightly snapshots, Amazon S3 sync, backing up repository metadata (issues, pull requests, wiki, etc.), and the ability to clone any snapshot direct from the BackHub server. Using their full backup solution will ensure you do not take to fiddle with Git when you accidentally delete ane or more files. Instead, you can just restore from a nightly backup. Fifty-fifty ameliorate, you can restore a deleted repository in just a few clicks if you happen to accidentally delete one.
Let'south learn the process of installing BackHub and restoring files from the backup.
Installing BackHub
BackHub plans start from $12 per month. You tin sign up for a gratis trial from the installation page. After signing up, you lot'll be directed to an install screen that sets upwards permissions with your GitHub account. Here you can select which repositories you want to back up using BackHub. You can either cullAll repositories to support all of your projects or individually select as many as you like. If you chooseAll repositories, any new repository you create on GitHub will automatically exist backed upward.
From there, you demand to sign in to GitHub and authorize BackHub to cease the installation. In one case you render to your BackHub dashboard, you should see a list of backed-up repositories.
From this point onward, BackHub volition keep nightly backups of the repositories. The snapshots are stored for thirty days, but upward to 1 year (365 days) of storage is available for enterprise plans. You can too connect an S3 bucket in the settings if you'd similar to preserve the snapshots indefinitely.
Restoring a Full Backup
Let'due south go over the steps of restoring a deleted file with BackHub.
Commencement, let's delete a file and push button.
```
rm file5.txt
git commit -am "Delete file5.txt"
git button origin main
```
In the BackHub dashboard, select the repository you'd like to restore.
On the left-hand side, yous can see the fourth dimension of the latest fill-in and the number of snapshots BackHub has created. If this is a recently added repository, yous volition accept just one snapshot of the current version. If the repository was added some time agone, y'all will have daily snapshots and y'all can choose the snapshot of whatever mean solar day to restore.
In one case the snapshot is chosen, click on theDownload Files button. The download will contain a Nil with all the files from the head of the primary branch. From in that location, you tin can easily re-create over the deleted file `file5.txt` to your local repository and welcome it back with a commit:
```
git add file5.txt
git commit -k "Reintroduce file5.txt"
```
Conclusion
Accidentally deleting important files is every developer'due south nightmare. With Git not having an intuitiveundo command, it can be difficult to efficiently restore a deleted file.
With a full backup solution set up, however, yous can balance assured y'all're able to combat any issues that might occur because of deleted files. You'll besides be able to restore deleted files without issue. Having a full backup solution tin prove to be useful in the long run, especially in critical business software or team-based environments. Check out BackHub for one of the best complete fill-in and restore solutions. Run into it in action yourself: start your costless trial of BackHub (at present part of Rewind).
Source: https://rewind.com/blog/recovering-deleted-files-in-github/
0 Response to "How to Delete a File You Upload to Github"
Post a Comment