How to unstage files git

How to Unstage File in Git

Prerequisites:

Install GitHub Desktop.

GitHub Desktop helps the git user to perform the git-related tasks graphically. You can easily download the latest installer of this application for Ubuntu from github.com. You have to install and configure this application after download to use it. You can also check the tutorial for installing GitHub Desktop on Ubuntu to know the installation process properly.

Create a GitHub account

You will require to create a GitHub account to check the output of the commands used here in the remote server.

Create a local and remote repository

You have to create a local repository and publish the repository in the remote server to test the commands used in this tutorial. Go to the local repository folder to check the commands used in this tutorial.

Unstage file using git reset:

The way to unstage any repository file using the `git reset` command is shown in this part of the tutorial. The user can unstage all files or the particular file or the committed file using this command.

Unstage all files

Run the following command to check the current status of the repository.

The following output has shown that the upload1.php file is modified. The modified file can be re-added, or the old file can be restored.

Run the following commands to add the modified upload1.php file in the repository, check the status, unstage all staged files, and check the status again.

$ git add upload1.php

The following output shows that the modified file has been stored in the stage area of the git after executing the `git add` command. The file is unstaged again after executing the `git reset command.

Unstage a particular file

The `git reset` command can be used to unstage a particular file by mentioning the file name with this command. Run the following command to check the current status of the repository.

The following output shows that two files have been modified in the current repository. These are upload1.php and upload5.php.

Run the following commands to add the modified files and check the status again.

$ git add upload1.php

$ git add upload5.php

The following output shows that two modified files have been stored in the stage area of the repository now.

Run the following commands to unstage the upload5.php file from the repository and check the status of the repository again.

$ git reset upload5.php

The following output shows that upload5.php has unstaged and upload1.php has been stored in the stage area.

Unstage committed file

In the previous part of this tutorial, the `git reset` command has used to unstage the uncommitted files of the repository. The way to unstage the committed file has shown in this part of the tutorial.

Run the following command to check the status of the repository and commit the staged file with the commit message.

The `git status` output has shown that the upload1.php file is stored in the stage area, and upload5.php is not staged. Next, the upload1.php file has been updated by using the `git commit` command.

Now, run the following command to unstage the last committed task and check the status of the repository again.

The following output shows that the upload1.php file committed before is unstaged after executing the `git reset command.

Unstage file using `rm` command:

Using the `git rm` command is another way to unstage the file of the repository. Run the following command to add the modified file named upload1.php in the repository and check the current status of the repository.

$ git add upload1.php

The following output shows that the upload1.php file has been stored in the repository stage area and can be committed now or restored in the previous stage.

The `git rm` command is used to remove any file permanently from the repository. But if the user wants to unstage any file without removing the file from the repository using the `git rm` command, then the –cache option will be required to use with the `git rm` command. Run the following commands to unstage the upload1.php file by keeping the file in the repository and checking the repository’s status.

The following output shows that upload1.php has unstaged, but the file is not removed from the repository.

Conclusion:

Two different ways to unstage files of the repository have shown in this tutorial by using a local demo repository. The `git reset` and `git rm` commands have been used to unstage the staged files to help the git user apply the unstage command in their repository.

About the author

Fahmida Yesmin

I am a trainer of web programming courses. I like to write article or tutorial on various IT topics. I have a YouTube channel where many types of tutorials based on Ubuntu, Windows, Word, Excel, WordPress, Magento, Laravel etc. are published: Tutorials4u Help.

How to unstage large number of files without deleting the content

I managed to unstage the files using the following commands and managed to remove the dirty index.

Also it would be helpful if someone can explain the way this pipe operation works.

9 Answers 9

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

git reset

If all you want is to undo an overzealous «git add» run:

Your changes will be unstaged and ready for you to re-add as you please.

It will not only unstage your added files, but will revert any changes you made in your working directory. If you created any new files in working directory, it will not delete them though.

If you have a pristine repo (or HEAD isn’t set) [1] you could simply

Of course, this will require you to re-add the files that you did want to be added.

[1] Note (as explained in the comments) this would usually only happen when the repo is brand-new («pristine») or if no commits have been made. More technically, whenever there is no checkout or work-tree.

Just making it more clear 🙂

The pipe operator, in a shell, takes the stdout of the process on the left and passes it as stdin to the process on the right. It’s essentially the equivalent of:

2019 update

To unstage all the files in your project, run the following from the root of the repository (the command is recursive):

If you only want to unstage the files in a directory, navigate to it before running the above or run:

Notes

This is a new command, but the behaviour of the old commands remains unchanged. So the older answers with git reset or git reset HEAD are still perfectly valid.

When running git status with staged uncommitted file(s), this is now what Git suggests to use to unstage file(s) (instead of git reset HEAD as it used to prior to v2.23).

to unstage everything. This is effectively the same as sehe’s solution, but avoids mucking with Git internals.

Warning: do not use the following command unless you want to lose uncommitted work!

Using git reset has been explained, but you asked for an explanation of the piped commands as well, so here goes:

In other words, «list all files git knows about and remove your local copy».

In other words, all changes, staged or unstaged, are gone, and your working tree is empty. Have a cry, checkout your files fresh from origin or remote, and redo your work. Curse the sadist who wrote these infernal lines; I have no clue whatsoever why anybody would want to do this.

TL;DR: you just hosed everything; start over and use git reset from now on.

I’m afraid that the first of those command lines unconditionally deleted from the working copy all the files that are in git’s staging area. The second one unstaged all the files that were tracked but have now been deleted. Unfortunately this means that you will have lost any uncommitted modifications to those files.

If you want to get your working copy and index back to how they were at the last commit, you can (carefully) use the following command:

Update: it sounds from your comments on Amber’s answer that you haven’t yet created any commits (since HEAD cannot be resolved), so this won’t help, I’m afraid.

. then the command xargs echo whatever will invoke the command:

Git unstage [a Git commands tutorial]

How to unstage files from index

If you’re in a hurry, here’s the magic word to unstage all of your changes, without deleting anything:

Now you can go back and `git add` the correct files, leaving your index tidied up and ready for committing. But wait, there’s more! If you want to learn how this works or some alternate approaches, read on.

What exactly is the “index”?

Before we dive into fine-tuning the `git reset` command, it’s worth quickly reviewing what the index actually is in Git, why it’s necessary, and how it works. There’s a great article on the Git workflow at git scm, but I’ll summarize it here.

There are three steps: first, you create and/or modify files in your working directory, the files as they exist on your hard drive. Then, you need to specify which changes you want batch together. Finally, you take that set of changes and name and describe them, creating a commit which is then stored in Git for future reference.

As I mentioned briefly at the beginning of this article, the index plays a crucial role in this process: helping you batch those changes together. As you’re working, you might make a number of different updates before reaching a good breaking point, and you don’t necessarily want to store them all together. So you need a way to pick, of the changes to your files since the last commit, which ones belong together.

The index is actually nothing more than a single binary file stored in .git/index (if you want to get really in-depth, read this article on the Git index). After you create a commit, it’s reset to an empty state. And as you `git add` changes, they’re added to this file.

With this understanding in hand, it’s easy to imagine not only how `git add`, `git reset`, and `git rm` work, but also some preventative measures to avoid having to manually unstage changes. We’ll cover some of those later, too.

How to reset a specific file

If you need to unstage a specific file, you can simply pass the path to that file to the `git reset` command. This works with both files and directories:

This command will leave the rest of your changes in the index untouched. It’s handy for when you’re ready to commit a series of changes, and then realize you want to extract some of them (whether because they’re cleanup, or out of scope, or just messy up your diff) to another commit, without having to go back and re-add everything else. It’s all about efficiency!

Removing a new file from the index

We’ve talked about the Git remove command `git rm` before in the context of removing untracked files. Applied with a lighter touch, it can be used to unstage files as well:

As with the targeted `git reset` command, this command will also leave the rest of your files untouched as well. This command is particularly useful for when you’ve just created and staged a file, and less so for when you’ve only staged changes to an existing and committed file (because in those cases that file will still exist in Git history).

Using .gitignore to prevent adding files to index

Obviously, this isn’t always ideal, since you often have files in your repository that you don’t want to ever commit (think build log files, secret files, node_modules, etc.).

Unstaging files just added to .gitignore

So let’s say you’ve added a new logging tool or build process and introduced some junk to your working directory, or maybe you decided to engage in a little spring cleaning. Let’s further suppose you’ve already accidentally committed or staged these unwanted files to the repository.

You can and should do two things at this point: add those files to your .gitignore file, and unstage the changes that have already been added. Luckily, there’s a quick and easy way to combine those two steps into one.

You can read up on how to do it in detail here. The basic process is to make sure all your changes are committed, including your .gitignore file, delete all the files in your index, and then re-add everything.

Since `git add` only adds things that aren’t in your .gitignore files, all of the unwanted work won’t make it into your next commit. And since you made sure you committed everything before kicking off the process, you don’t have to be afraid of accidentally discarding changes.

Learn from Nana, AWS Hero & CNCF Ambassador, how to enforce K8s best practices with Datree

рџЌї Techworld with Nana: How to enforce Kubernetes best practices and prevent misconfigurations from reaching production. Watch now.

Headingajsdajk jkahskjafhkasj khfsakjhf

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.

How to unstage files in git without loosing changes

Table of Contents

Quick cheat sheet to unstage files in git

You are working on a project, staging, committing, and pushing changes. You just staged a file, and you want to remove it from the index, but not sure the best command to use. Worry no more because you are in the right place.

Here are the top three commands to use.

1. The cached command

helps to unstage new files, i.e., files not committed.

2. The restore command

is crucial in unstaging modified files, i.e., files already committed.

3. Git reset mixed

You can use the reset command in four ways when unstaging a file.

to git unstage files before committing them.

Reset either the HEAD

to unstage modified files.

Learning how to apply the commands will enable you to control the staging area and easily collaborate with other developers.

It would be best to understand file staging before taking a practical look at the git unstage file. The tutorial then presents you with relatable examples of each of the three primary commands in action.

What do we mean by git unstage file?

Git unstage file is a way to undo changes at the index. An index is the second stage in the git workflow.

The first stage is the working directory. The working directory is the place you actively create or modify files. Next, it sends your files to temporary storage called the index or staging area. At the index, git takes a snapshot of the changes before finally storing them in the git database.

Three things happen in the git database. First, git takes a copy of the staging area changes and stores it. Secondly, each round of storage gets an id called commit hash. The commit hash forms part of the history.

Lastly, git makes one of the commits the HEAD. The HEAD is the commit you are viewing to act on, usually the last commit in history.

Unstaging a file returns the file’s changes to the working directory without deleting it from the file system. Then, the file is untracked, as you are about to see in the examples section.

Lab setup to explore steps the unstage files in git

We will explore what happens when you git ustage file before and after pushing to a remote repo. For that reason, we will have two workstations: a local repo without a remote and another one with a remote.

Navigate to the unstage_before_push directory.

Initialize the repo.

Add two HTML files.

Like in the unstage_before_push directory, let us create some files to ease manipulating the index.

Create some text files.

We will not initialize a repo this time around because GitHub already did it for us. You have the first commit if you created the remote with a README.md file. Let us confirm that.

I have a commit.

Let us stage, commit and push the two text files we just created.

The remote repo’s page on GitHub shows our new commit.

Now that we have a setup to explore the git unstage file, let us dive into more relatable examples.

git unstage file before push

If you have not modified the tracked files, use any of these commands to unstage them:

cd into the unstage_before_push directory.

Running the command

shows our files are untracked.

Stage the files.

Recheck the status.

The files are staged, and git is ready to commit the changes.

The index.html file got unstaged!

Use any of these commands:

Example-2: Use git reset to unstage file before commit

Git reset is one of the most crucial commands when undoing changes. The three types of reset command are hard, soft, and mixed.

Git reset hard removes changes from the commit history and deletes the files from the working directory. Git reset soft resets the commit HEAD, while git reset mixed unstages files. It is the default git commit that is why you won’t see us specifying any flag when resetting changes in this tutorial.

The ability of the mixed command to exist in various forms and take various flags enables us to apply it in several ways to git unstage files. Here is an example.

Running the command

in the unstage_before_push folder unstages the about.hmtl file.

Another way to reset changes on new files is using the double slashes before the filename. Note: leave a space between the two slashes and the filename.

Let us use it to unstage the index.html file, as follows:

Checking the status

shows the index.html file is back to the untracked stage.

Enough with new files. Let us see how to git unstage files after commit and push.

Git unstage file after push

Sometimes you need to git unstage files after push. That is, modify a file, restage and unstage file. Let me demonstrate the scenario.

We can unstage the files using the following three commands.

Navigate into the unstage_after_push directory.

Modify the text files.

Stage the changes.

Checking the status,

git tells us we have unstaged the modified files.

Run the command

to unstage the file1.tx t file

Checking the status

confirms the restore command unstaged file1.txt

Example-5: unstage file using the git reset HEAD command

We can undo the changes made on file2.txt by playing the command

Checking the status

shows file2.txt got untracked. Now, both of our files are unstaged.

Stage both files in readiness for the reset all command

Example-6: git unstage file using the reset all command

Finally, we can unstage all the modified files using the reset command using git reset all command.

Recheck the status.

And voila, all the modified files got unstaged!

Summary

Using the right command is the key to unlocking efficiency when undoing changes. It is more convenient to git unstage files using the cached, reset and restore commands by grouping the commands as follows.

How To Unstage Files on Git | Different Ways to Unstage Files in Git

As developers, using & working with Git is mandatory. Git Users every time deals with many files in the local repository. If any user accidentally added any file to your Git then you can remove it from your index by performing the unstage files on Git. Unstaging file is very beneficial, it can be used to separate files in different commits or to do work on some other modifications.

If you are a beginner, then take help from the Junos Notes provided Git Commands Tutorial. However, this tutorial is completely on How to unstage files on Git and it addresses various methods to unstage all files or particular files or committed files elaborately in the below modules.

Prerequisites

Unstage a File in Git

In Git, unstaging a file can be done in two ways.

1) git rm –cached
2) git reset Head

1. Unstage Files using git `rm` command

One of the methods to unstage git files is using the ‘rm’ command. It can be used in two ways:

1) On the brand new file which is not on Github.
2) On the existing file which exists on Github.

Let’s check the process of using the git rm command in both scenarios.

Case 1: rm –cached on new file which is not committed.

rm –cached
is useful to remove only the file(s) from the staging area where this file is not available on GitHub ever. After executing this command, the file rests in the local machine, it just unstaged from the staging area.

Example:

Case 2: rm –cached on existing file.

2. Unstage Files using git reset

The most effortless way to unstage files on Git is by using the “git reset” command and specify the file you want to unstage.

By default, the commit parameter is optional: if you don’t specify it, it will be referring to HEAD.

What does the git reset command do?

This command will reset the index entries (the ones you added to your staging area) to their state at the specified commit (or HEAD if you didn’t specify any commits).

Also, we use the double dashes as argument disambiguation meaning that the argument that you are specifying may be related to two distinct objects: branches and directories for example.

As a quick example, let’s pretend that you added a file named “README” to your staging area, but now you want to unstage this file.

In order to unstage the README file, you would execute the following command

You can now check the status of your working directory again with “git status”

As you probably understood by now, the “git reset” command is doing the exact opposite of the “git add” command: it removes files from the index.

Unstage all files on Git

Previously, we have seen how you can unstage a file by specifying a path or a file to be reset.

In some cases, you may want to unstage all your files from your index.

To unstage all files also you can use the “git reset” command without specifying any files or paths.

Again, let’s pretend that you have created two files and one directory and that you added them to your staging area.

In order to unstage all files and directories, execute “git reset” and they will be removed from the staging area back to your working directory.

Remove unstaged changes on Git

In some cases, after unstaging files from your staging area, you may want to remove them completely.

In order to remove unstaged changes, use the “git checkout” command and specify the paths to be removed.

Again, let’s say that you have one file that is currently unstaged in your working directory.

In order to discard changes done to this unstaged file, execute the “git checkout” command and specify the filename.

Alternatively, if you want to discard your entire working directory, head back to the root of your project and execute the following command.

Unstage Committed Files on Git

In some cases, you actually committed files to your git directory (or repository) but you want to unstage them in order to make some modifications to your commit.

Luckily for you, there’s also a command for that.

Unstage Commits Soft

To unstage commits on Git, use the “git reset” command with the “–soft” option and specify the commit hash.

Alternatively, if you want to unstage your last commit, you can the “HEAD” notation in order to revert it easily.

Using the “–soft” argument, changes are kept in your working directory and index.

As a consequence, your modifications are kept, they are just not in the Git repository anymore.

Inspecting your repository after a soft reset would give you the following output, given that you unstaged the last commit.

What happens if you were to hard reset your commit?

In this case, all changes would be discarded and you would lose your changes.

Unstage Commits Hard

To unstage commits on Git and discard all changes, use the “git reset” command with the “–hard” argument.

Note: Be careful when using the reset hard command, you will lose all your changes when hard resetting.

Conclusion

In this tutorial, you learned how you can unstage files easily on Git using the “git reset” command.

You learned that you can either specify a path or a single file to unstage files and keep on working on your files until you commit them to your repository.

If you are curious about Git, we have a whole section dedicated to it on the website, make sure to have a look!