How Do I Undo File Upload in Github

Every developer has deleted the wrong file from their projection at least one time. It tin either exist a hastily executed`rm -rf` control, or an absent-minded select and delete, or possibly the effect of an erroneous script. Whatsoever the reason, deleting an important file can be troublesome if not fixed immediately. When working with a team, accidentally deleting a file then pushing it upstream can exist catastrophic for other team members who pull the changes. Depending on the file, either they'll go an error direct away, or in the worst example, the error volition pop upward somewhere downwards the line—maybe in some not-so-obvious place—at which point, it might be difficult to figure out the exact cause.

And then, at present that yous have accidentally deleted a file, or files, how do you recover them? Since Git is a version control system, it has features to roll back a single file to a previous version, including deleted files.

In this tutorial, nosotros'll wait at three ways 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.

Y'all 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 y'all modify files in Git—including creating new files, editing, or deleting existing files—the changes start as unstaged. Then you stage the changes with the `git add` control, and finally, y'all commit the changes using the `git commit` command. Git provides ways to recover a deleted file at any betoken in this life cycle of changes.

If y'all accept not staged the deletion nonetheless, but run`git restore <filename>` and the file volition be restored from the alphabetize.

If you take staged the changes, however, running `git restore` volition throw an fault, since the file does non exist in the index anymore.

In this case, you need to run`git restore --staged --worktree <filename>`. The`--staged` argument tells`git` to restore the file in the index from HEAD, and the`--worktree` argument tells Git to restore the working tree too.

If you have deleted the file and already committed the changes, y'all 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, so cheque out the file from the previous commit.

In the demo repo,`file1.txt` has already been deleted and committed. Permit's recover that file. To effigy out which commit deleted`file1.txt`, you need to use the`git rev-list` command:

```

git rev-list HEAD -n i -- file1.txt

```

This command tells `git` to listing all commits, which can exist reached from the HEAD, that changed the file`file1.txt`. The`-n i` option tells`git` to limit the consequence to only one commit. The output is the checksum of the commit that deleted the file. Yous tin check that this is the offending commit past using the `git show` command with the checksum –

The commit earlier this one is the last commit where this file was present. You tin can restore the file from that item commit past running the following command. The`^` at the stop of the commit hash tells Git to fetch the commit before this one:

"`

git checkout 3d5210ddd8632d539ed3f5e362dc047ed508a510^ file1.txt

"`

Pros and Cons of Using the Command Line

This method is the quickest to perform since you lot only need access to the command line. Withal, it requires you to run different commands depending on your situation. Also, it might not exist the easiest to master, and some developers may prefer a more than visual approach.

Using the GitHub Desktop App

If yous are more comfortable with a graphical interface, you can use the GitHub Desktop, which is bachelor for macOS and Windows. Similar to the previous instance, there are two scenarios: 1 where you have non committed the deletion, and one where you lot accept.

Any changes you make in your repository volition show up in the staging area in the left sidebar of the app. At that place you lot can discard the changes, which works like to the`git restore` command. If you have non nevertheless committed the deletion, you can utilize this feature to rapidly recover the deleted file.

Go ahead and delete`file5.txt` from the repository and come back to GitHub Desktop. Yous should see the deletion in the staging area.

You can correct-click on the alter and click onDiscard changes.

You volition be asked for confirmation. Once confirmed, the modify volition be discarded and the deleted file will be back in its place.

If you lot have already committed the modify, you lot need to know the commit hash of the offending commit. At that place is no way to do that from the GitHub desktop app, so y'all need to use the command line and run the`git rev-list` command nosotros discussed earlier.

But like earlier, let's restore the already deleted`file1.txt`. Beginning, you need to know the hash of the commit that deleted the file:

```

$ git rev-list HEAD -n 1 -- file1.txt

3d5210ddd8632d539ed3f5e362dc047ed508a510

```

In the app, the commits are listed with their names, non hashes. In gild to know the proper noun of the commit, you need to run`git show` command with the commit hash:

```

git bear witness 3d5210ddd8632d539ed3f5e362dc047ed508a510

```

The proper 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 selection if y'all're comfortable with graphical interfaces. However, it has the following disadvantages:

• The desktop app is but available for Windows and macOS. If you're using Linux then yous won't be able to utilise this method.
• If you take already committed the deletion, this method becomes cumbersome since you need to apply the command line to observe the commit name 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 exist reverted also.

Using the GitHub Web UI

If you accept committed the deletion and pushed it to GitHub, it 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 point in history, which and so allows you to view and download any file.

Let'south recover the already deleted`file1.txt` in the repository. Similar to the previous arroyo, you demand to know which commit deleted the file, using the`git rev-list` control 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 replace`<username>` and `<repo-name>` to indicate to your repository. This volition open up the commit before the offending commit.

Click onScan files and y'all will exist presented with the project structure of that item commit.

Discover the file y'all desire to restore. In this case`file1.txt`. Open up information technology by clicking on it.

Click on theRaw push button and you will be presented with a raw text version of the file. You can right-click on the page and selectSave Equally to download the file and salvage it to your project. Now yous can add information technology back to your local repo and commit –

```shell

git add file1.txt

git commit -grand "Reintroduce file1.txt"

```

Pros and Cons of Using GitHub Web UI

Similar to using the app, this method is easier to apply than the CLI method because of its graphical interface. You lot tin can as well visually browse the repository at any indicate of your commit history without having to clone or checkout the commit.

The biggest disadvantage of this approach, however, is that there is no fashion of selecting and downloading more ane file. So if you have accidentally deleted more than one file, you have to download them one by one—a time-consuming task. Additionally, this method somewhat relies on the command line since you need the command line to figure out the commit hash.

Using a Full Fill-in

Recovering a deleted file with Git is a insufficiently circuitous procedure. Not just exercise you lot have to fiddle with the command line to try and figure out the commit hashes, just you also have to brand sure that the commit yous're restoring the file from is indeed the right one. If you accept accidentally deleted more than one file, restoring them from different commits tin can introduce inconsistency into your project. Using a full backup solution like BackHub can salve you some trouble by backing upwards the unabridged repository, thus ensuring a consistent country.

BackHub offers powerful features similar nightly snapshots, Amazon S3 sync, backing upwards repository metadata (issues, pull requests, wiki, etc.), and the ability to clone any snapshot directly from the BackHub server. Using their full backup solution will ensure y'all do not have to dabble with Git when you accidentally delete ane or more files. Instead, yous can just restore from a nightly backup. Even better, you can restore a deleted repository in simply a few clicks if you happen to accidentally delete one.

Permit'south learn the process of installing BackHub and restoring files from the fill-in.

Installing BackHub

BackHub plans start from $12 per month. Y'all tin can sign up for a complimentary trial from the installation folio. After signing up, you'll be directed to an install screen that sets upwardly permissions with your GitHub account. Here you can select which repositories yous desire to dorsum up using BackHub. You can either chooseAll repositories to support all of your projects or individually select as many as you similar. If you chooseAll repositories, any new repository y'all create on GitHub will automatically be backed upwardly.

From there, you need to sign in to GitHub and authorize BackHub to terminate the installation. In one case y'all return to your BackHub dashboard, yous should come across a list of backed-up repositories.

From this point onward, BackHub volition keep nightly backups of the repositories. The snapshots are stored for xxx days, merely up to 1 year (365 days) of storage is available for enterprise plans. Y'all can also connect an S3 saucepan in the settings if you'd like to preserve the snapshots indefinitely.

Restoring a Full Fill-in

Let's become over the steps of restoring a deleted file with BackHub.

Outset, permit'due south delete a file and push.

```

rm file5.txt

git commit -am "Delete file5.txt"

git push origin principal

```

In the BackHub dashboard, select the repository you'd similar to restore.

On the left-hand side, you lot can see the time of the latest backup and the number of snapshots BackHub has created. If this is a recently added repository, yous will have but one snapshot of the current version. If the repository was added some time agone, you volition accept daily snapshots and you can choose the snapshot of any day to restore.

Once the snapshot is chosen, click on theDownload Files push. The download will incorporate a ZIP with all the files from the head of the master branch. From there, y'all 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 -m "Reintroduce file5.txt"

```

Conclusion

Accidentally deleting important files is every programmer'southward nightmare. With Git not having an intuitiveundo command, it can be difficult to efficiently restore a deleted file.

With a full fill-in solution set, however, y'all can residuum assured you're able to combat any issues that might occur because of deleted files. Y'all'll also be able to restore deleted files without issue. Having a full backup solution tin can prove to be useful in the long run, especially in disquisitional business software or squad-based environments. Cheque out BackHub for one of the best complete fill-in and restore solutions. See it in action yourself: start your free trial of BackHub (now part of Rewind).

adairgrionve.blogspot.com

Source: https://rewind.com/blog/recovering-deleted-files-in-github/

Share this post