#git-reset

git reset is one of the commands I use less frequently, which means it is easier to forget when and how to use it to achieve the desired effect.

Let's say I have just commited something and then I decided that what I commited should not be commited. Basically, I want to get rid of the very last commit, no matter the consequences.

$ mkdir repo $ cd repo $ git init Initialized empty Git repository in /Users/mczenko/Projects/learning/test_git/repo/.git/ $ echo "file1" > file1.txt $ git add file1.txt $ git commit -am 'Initial commit.' [master (root-commit) c9859f4] Initial commit. 1 file changed, 1 insertion(+) create mode 100644 file1.txt $ git log --oneline c9859f4 Initial commit.

Now, I add another file and I commit it to the repository:

$ echo "file2" > file2.txt $ git add file2.txt $ git commit -am "Added file2.txt" [master 11d160b] Added file2.txt 1 file changed, 1 insertion(+) create mode 100644 file2.txt $ git log --oneline 11d160b Added file2.txt c9859f4 Initial commit.

This will be our invariant, from which we will investigate the impact of variuos forms of git reset.

git reset --hard

Let's say I decided that I actually do not need file2.txt:

$ git reset --hard c9859f4 HEAD is now at c9859f4 Initial commit. $ git log --oneline c9859f4 Initial commit. $ ls file1.txt

If after that you realized that there was somathing important in file2.txt and you want to get it back, there is a good news: git actually did not remove your file:

$ git reflog c9859f4 HEAD@{0}: reset: moving to c9859f4 11d160b HEAD@{1}: commit: Added file2.txt c9859f4 HEAD@{2}: commit (initial): Initial commit. $ git checkout -b recovered 11d160b Switched to a new branch 'recovered' $ ls file1.txt file2.txt $ cat file2.txt file2 $ git checkout master Switched to branch 'master' $ git merge recovered Updating c9859f4..11d160b Fast-forward file2.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 file2.txt $ git branch -d recovered Deleted branch recovered (was 11d160b). $ git reflog 11d160b HEAD@{0}: merge recovered: Fast-forward c9859f4 HEAD@{1}: checkout: moving from recovered to master 11d160b HEAD@{2}: checkout: moving from master to recovered c9859f4 HEAD@{3}: reset: moving to c9859f4 11d160b HEAD@{4}: commit: Added file2.txt c9859f4 HEAD@{5}: commit (initial): Initial commit.

We see that git reflog records a lot of useful information about the repository, not only the commits.

What's intersting here is that the recovered commit preserves its original commit id:

Original:

$ git log --oneline 11d160b Added file2.txt c9859f4 Initial commit.

Recovered

$ git log --oneline 11d160b Added file2.txt c9859f4 Initial commit.

We are now back with the original content. Let's try another version of git reset: soft reset.

git reset --soft

git reset --soft leaves the content in the staged area. Handy if you simply want to revise last commit:

$ git reset --soft c9859f4 $ ls file1.txt file2.txt $ git status On branch master Changes to be committed: (use "git reset HEAD <file>..." to unstage) new file: file2.txt

I use git reset --soft when I want to move the last commit to a new branch:

$ git reset HEAD . $ git status On branch master Untracked files: (use "git add <file>..." to include in what will be committed) file2.txt

Now I can easily move the changes I've done to a new branch:

$ git checkout -b new_branch Switched to a new branch 'new_branch' $ git status On branch new_branch Untracked files: (use "git add <file>..." to include in what will be committed) file2.txt nothing added to commit but untracked files present (use "git add" to track)

We can now commit file2.txt and then merge it with master:

$ git add file2.txt $ git status On branch new_branch Changes to be committed: (use "git reset HEAD <file>..." to unstage) new file: file2.txt $ git commit -m "file2.txt added again." [new_branch 14a6c4b] file2.txt added again. 1 file changed, 1 insertion(+) create mode 100644 file2.txt $ git status On branch new_branch nothing to commit, working directory clean $ git log --oneline 14a6c4b file2.txt added again. c9859f4 Initial commit. $ git checkout master Switched to branch 'master' $ git merge new_branch Updating c9859f4..14a6c4b Fast-forward file2.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 file2.txt $ git log --oneline 14a6c4b file2.txt added again. c9859f4 Initial commit.

Of course, in this case the new commit has new commit id.

git reset

Finally, what does simple git reset do?

$ git reset c9859f4 $ git status On branch master Untracked files: (use "git add <file>..." to include in what will be committed) file2.txt nothing added to commit but untracked files present (use "git add" to track)

As we see, ordinary git reset marks the changes from the last commit as untracked without going through the staging area.

Do you see a mistake in this post, or you think something should written in a less ambiguous way? Please let me know. It is not my intention to have anyone learing gits the wrong way because of my incompetence.

External references:

If I run into a problem I'm not familiar with, I would just google the answer and try to follow the instructions on how to fix it. If it's a problem that I know I will run into again, I'll spend time studying the subject matter. Otherwise, I wouldn't care about how it works at all, as long as my problem is fixed. Using git reset was one of those problems that I would look up on stackoverflow.com and never care to look into. I would copy and paste the code I need for my specific problem, but didn't really understand what it was doing. 

However, it's actually very important to understand how git reset works, because it's dangerous. It could potentially destroy hours and hours of hard work if used incorrectly. This is especially why we shouldn't use it on commits that have been made public; the Golden Rule of Rebasing from my last post applies here too! 

Now, the part that confuses most people are the differences between git reset --soft, --mixed, and --hard. We'll look at the definition of the three that the Atlassian Git Tutorials gives us and see how it works through an example:

--soft – The staged snapshot and working directory are not altered in any way.

--mixed – The staged snapshot is updated to match the specified commit, but the working directory is not affected. This is the default option.

--hard – The staged snapshot and the working directory are both updated to match the specified commit.

Example

Let's see how this looks when we put it to practice. First, let's create a project, git init, and add a file with 4 different commit changes.

Now, if you type git log --oneline, you will see something like this:

728c3d8 4th commit c4b5c59 3rd commit 3780981 2nd commit bb21b0c 1st commit

Okay, now let's write one more line of code in our file and just run a git add without git commit in order to test the "staged snapshot" and "working directory" changes.My file looks like this but the commit history is still the same.

1st commit 2nd commit 3rd commit 4th commit 5th commit

git status looks like this:

On branch master Changes to be committed: (use "git reset HEAD ..." to unstage) modified: readme.txt

First, let's try a git reset --soft:

git reset --soft HEAD~1

Once we run git status and look at our file, we can see that they're still the same. However, git log --oneline changed to this:

c4b5c59 3rd commit 3780981 2nd commit bb21b0c 1st commit

Now, let's try a git reset --mixed.

git reset --mixed HEAD~1

We get a message saying:

Unstaged changes after reset: M readme.txt

We run git status and it looks like this: and look at our file, we can see that they're still the same. However, git log --oneline changed to this:

3780981 2nd commit bb21b0c 1st commit

Lastly, we'll run git reset --hard after we git add the file.

git add . git reset --hard HEAD~1

Our git log --oneline shows just one commit as expected:

bb21b0c 1st commit

If we take a look inside of our file, all we have left is what we wrote on our 1st commit. And git status tells us that there is nothing committed and nothing to be staged anymore:

On branch master nothing to commit, working directory clean

Lastly, there is another way to call on git reset besides calling git reset on commits. You can call it on files like this:

git reset HEAD~2 foo.rb

Resolved: What's the difference between "git reset" and "git checkout"? #computers #fix #development

What’s the difference between "git reset" and "git checkout"?

I’ve always thought of git reset and git checkout as the same, in the sense that both bring the project back to a specific commit. However, I feel they can’t be exactly the same, as that would be redundant. What is the actual difference between the two? I’m a bit confused, as the svn only has svn co to revert the commit.

ADDED

The fol…

How to: Git: can't undo local changes (error: path … is unmerged)

Git: can’t undo local changes (error: path … is unmerged)

I have following working tree state

$ git status foo/bar.txt # On branch master # Unmerged paths: # (use "git reset HEAD <file>..." to unstage) # (use "git add/rm <file>..." as appropriate to mark resolution) # # deleted by us: foo/bar.txt # no changes added to commit (use "git add" and/or "git commit -a")

File foo/bar.txtis there and I…

Fixed How to uncommit my last commit in git #dev #it #asnwer

How to uncommit my last commit in git

How can I uncommit my last commit in git? I have googled it.

Is it

git reset hard HEAD

or

git reset hard HEAD^

Thank you.

Answer: How to uncommit my last commit in git

git reset hard HEAD^

note: if you’re on windows you’ll need to quote the HEAD^ so

git reset hard "HEAD^"

Answer: How to uncommit my last commit in git

It’s the latter.

git reset hard HEAD^

Fixed Undo a particular commit in Git #dev #it #asnwer

Undo a particular commit in Git

What is the simplest way to undo a particular commit that is:

not in the head or HEAD

Has been pushed to the remote.

Because if it is not the latest commit,

git reset HEAD

doesn’t work. And because it has been pushed to a remote,

git rebase -i

and

git rebase onto

will cause some problem in the remotes.

More so, I don’t want to modify the history really. If…

Fixed Git – how to revert uncommitted changes including files and folders? #dev #it #asnwer

Git – how to revert uncommitted changes including files and folders?

Is there a git command to Revert All Uncommitted Changes in Working Tree and Index and to remove also New Files and Folders ?

Answer: Git – how to revert uncommitted changes including files and folders?

I think you can use the following command: git reset hard

Answer: Git – how to revert uncommitted changes including files and…

How to: How to cancel a local git commit

How to cancel a local git commit

My issue is I have changed a file eg: README, added a new line ‘this for my testing line‘ and saved the file, then I issued the following commands

git status # On branch master # Changed but not updated: # (use "git add ..." to update what will be committed) # (use "git checkout ..." to discard changes in working directory) # # modified: README # no changes added…