如何撤消 Git 中最近的本地提交？

Question

I accidentally committed the wrong files to Git , but didn't push the commit to the server yet.

How do I undo those commits from the local repository?

Answer 1

Undo a commit & redo

$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~                              # (1)
[ edit files as necessary ]                    # (2)
$ git add .                                    # (3)
$ git commit -c ORIG_HEAD                      # (4)

1. git reset is the command responsible for the undo . It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You'll need to add them again before you can commit them again).
2. Make corrections to working tree files.
3. git add anything that you want to include in your new commit.
4. Commit the changes, reusing the old commit message. reset copied the old head to .git/ORIG_HEAD ; commit with -c ORIG_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option.

Alternatively, to edit the previous commit (or just its commit message) , commit --amend will add changes within the current index to the previous commit.

To remove (not revert) a commit that has been pushed to the server , rewriting history with git push origin main --force[-with-lease] is necessary. It's almost always a bad idea to use --force ; prefer --force-with-lease instead, and as noted in the git manual :

You should understand the implications of rewriting history if you [rewrite history] has already been published.

---

Further Reading

You can use git reflog to determine the SHA-1 for the commit to which you wish to revert. Once you have this value, use the sequence of commands as explained above.

---

HEAD~ is the same as HEAD~1 . The article What is the HEAD in git? is helpful if you want to uncommit multiple commits.

Answer 2

Undoing a commit is a little scary if you don't know how it works. But it's actually amazingly easy if you do understand. I'll show you the 4 different ways you can undo a commit.

Say you have this, where C is your HEAD and (F) is the state of your files.

   (F)
A-B-C
    ↑
  master

Option 1: git reset --hard

You want to destroy commit C and also throw away any uncommitted changes . You do this:

git reset --hard HEAD~1

The result is:

 (F)
A-B
  ↑
master

Now B is the HEAD. Because you used --hard , your files are reset to their state at commit B.

Option 2: git reset

Maybe commit C wasn't a disaster, but just a bit off. You want to undo the commit but keep your changes for a bit of editing before you do a better commit. Starting again from here, with C as your HEAD:

   (F)
A-B-C
    ↑
  master

Do this, leaving off the --hard :

git reset HEAD~1

In this case the result is:

   (F)
A-B-C
  ↑
master

In both cases, HEAD is just a pointer to the latest commit. When you do a git reset HEAD~1 , you tell Git to move the HEAD pointer back one commit. But (unless you use --hard ) you leave your files as they were. So now git status shows the changes you had checked into C. You haven't lost a thing!

Option 3: git reset --soft

For the lightest touch, you can even undo your commit but leave your files and your index :

git reset --soft HEAD~1

This not only leaves your files alone, it even leaves your index alone. When you do git status , you'll see that the same files are in the index as before. In fact, right after this command, you could do git commit and you'd be redoing the same commit you just had.

Option 4: you did git reset --hard and need to get that code back

One more thing: Suppose you destroy a commit as in the first example, but then discover you needed it after all ? Tough luck, right?

Nope, there's still a way to get it back. Type this

git reflog

and you'll see a list of (partial) commit shas (that is, hashes) that you've moved around in. Find the commit you destroyed, and do this:

git checkout -b someNewBranchName shaYouDestroyed

You've now resurrected that commit. Commits don't actually get destroyed in Git for some 90 days, so you can usually go back and rescue one you didn't mean to get rid of.

Answer 3

There are two ways to "undo" your last commit, depending on whether or not you have already made your commit public (pushed to your remote repository):

How to undo a local commit

Let's say I committed locally, but now I want to remove that commit.

git log
    commit 101: bad commit    # Latest commit. This would be called 'HEAD'.
    commit 100: good commit   # Second to last commit. This is the one we want.

To restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD :

git reset --soft HEAD^     # Use --soft if you want to keep your changes
git reset --hard HEAD^     # Use --hard if you don't care about keeping the changes you made

Now git log will show that our last commit has been removed.

How to undo a public commit

If you have already made your commits public, you will want to create a new commit which will "revert" the changes you made in your previous commit (current HEAD).

git revert HEAD

Your changes will now be reverted and ready for you to commit:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

For more information, check out Git Basics - Undoing Things .

Answer 4

Add/remove files to get things the way you want:

git rm classdir
git add sourcedir

Then amend the commit:

git commit --amend

The previous, erroneous commit will be edited to reflect the new index state - in other words, it'll be like you never made the mistake in the first place.

Note that you should only do this if you haven't pushed yet. If you have pushed, then you'll just have to commit a fix normally.

Answer 5

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

or

git reset --hard HEAD~1

Warning: The above command will permanently remove the modifications to the .java files (and any other files) that you wanted to commit.

The hard reset to HEAD-1 will set your working copy to the state of the commit before your wrong commit.

Answer 6

To change the last commit

Replace the files in the index:

git rm --cached *.class
git add *.java

Then, if it's a private branch, amend the commit:

git commit --amend

Or, if it's a shared branch, make a new commit:

git commit -m 'Replace .class files with .java files'

( To change a previous commit , use the awesome interactive rebase .)

---

ProTip™: Add *.class to a gitignore to stop this happening again.

---

To revert a commit

Amending a commit is the ideal solution if you need to change the last commit, but a more general solution is reset .

You can reset Git to any commit with:

git reset @~N

Where N is the number of commits before HEAD , and @~ resets to the previous commit.

Instead of amending the commit, you could use:

git reset @~
git add *.java
git commit -m "Add .java files"

Check out git help reset , specifically the sections on --soft --mixed and --hard , for a better understanding of what this does.

Reflog

If you mess up, you can always use the reflog to find dropped commits:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Answer 7

Use git revert <commit-id> .

To get the commit ID, just use git log .

Answer 8

If you are planning to undo a local commit entirely, whatever you change you did on the commit, and if you don't worry anything about that, just do the following command.

git reset --hard HEAD^1

(This command will ignore your entire commit and your changes will be lost completely from your local working tree). If you want to undo your commit, but you want your changes in the staging area (before commit just like after git add ) then do the following command.

git reset --soft HEAD^1

Now your committed files come into the staging area. Suppose if you want to upstage the files, because you need to edit some wrong content, then do the following command

git reset HEAD

Now committed files to come from the staged area into the unstaged area. Now files are ready to edit, so whatever you change, you want to go edit and added it and make a fresh/new commit.

More (link broken) ( Archived version )

Answer 9

If you have Git Extras installed, you can run git undo to undo the latest commit. git undo 3 will undo the last three commits.

Answer 10

I wanted to undo the latest five commits in our shared repository. I looked up the revision id that I wanted to rollback to. Then I typed in the following.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To git@bitbucket.org:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Answer 11

I prefer to use git rebase -i for this job, because a nice list pops up where I can choose the commits to get rid of. It might not be as direct as some other answers here, but it just feels right .

Choose how many commits you want to list, then invoke like this (to enlist last three)

git rebase -i HEAD~3

Sample list

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Then Git will remove commits for any line that you remove.

Answer 12

How to fix the previous local commit

Use git-gui (or similar) to perform a git commit --amend . From the GUI you can add or remove individual files from the commit. You can also modify the commit message.

How to undo the previous local commit

Just reset your branch to the previous location (for example, using gitk or git rebase ). Then reapply your changes from a saved copy. After garbage collection in your local repository, it will be like the unwanted commit never happened. To do all of that in a single command, use git reset HEAD~1 .

Word of warning : Careless use of git reset is a good way to get your working copy into a confusing state. I recommend that Git novices avoid this if they can.

How to undo a public commit

Perform a reverse cherry pick ( git-revert ) to undo the changes.

If you haven't yet pulled other changes onto your branch, you can simply do...

git revert --no-edit HEAD

Then push your updated branch to the shared repository.

The commit history will show both commits, separately .

---

Advanced: Correction of the private branch in public repository

This can be dangerous -- be sure you have a local copy of the branch to repush.

Also note: You don't want to do this if someone else may be working on the branch.

git push --delete (branch_name) ## remove public version of branch

Clean up your branch locally then repush...

git push origin (branch_name)

In the normal case, you probably needn't worry about your private-branch commit history being pristine. Just push a followup commit (see 'How to undo a public commit' above), and later, do a squash-merge to hide the history.

Answer 13

If you want to permanently undo it and you have cloned some repository.

The commit id can be seen by:

git log 

Then you can do like:

git reset --hard <commit_id>

git push origin <branch_name> -f

Answer 14

If you have committed junk but not pushed,

git reset --soft HEAD~1

HEAD~1 is a shorthand for the commit before head. Alternatively you can refer to the SHA-1 of the hash if you want to reset to. --soft option will delete the commit but it will leave all your changed files "Changes to be committed", as git status would put it.

If you want to get rid of any changes to tracked files in the working tree since the commit before head use " --hard " instead.

OR

If you already pushed and someone pulled which is usually my case, you can't use git reset . You can however do a git revert ,

git revert HEAD

This will create a new commit that reverses everything introduced by the accidental commit.

Answer 15

On SourceTree (GUI for GitHub), you may right-click the commit and do a 'Reverse Commit'. This should undo your changes.

On the terminal:

You may alternatively use:

git revert

Or:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

Answer 16

A single command:

git reset --soft 'HEAD^' 

It works great to undo the last local commit!

Answer 17

Just reset it doing the command below using git :

git reset --soft HEAD~1

Explain: what git reset does, it's basically reset to any commit you'd like to go back to, then if you combine it with --soft key, it will go back, but keep the changes in your file(s), so you get back to the stage which the file was just added, HEAD is the head of the branch and if you combine with ~1 (in this case you also use HEAD^ ), it will go back only one commit which what you want...

I create the steps in the image below in more details for you, including all steps that may happens in real situations and committing the code:

Answer 18

"Reset the working tree to the last commit"

git reset --hard HEAD^ 

"Clean unknown files from the working tree"

git clean    

see - Git Quick Reference

NOTE: This command will delete your previous commit , so use with caution! git reset --hard is safer.

Answer 19

How to undo the last Git commit?

To restore everything back to the way it was prior to the last commit, we need to reset to the commit before HEAD.

1. If you don't want to keep your changes that you made:

    git reset --hard HEAD^

2. If you want to keep your changes:

    git reset --soft HEAD^

Now check your git log. It will show that our last commit has been removed.

Answer 20

Use reflog to find a correct state

git reflog

REFLOG BEFORE RESET

Select the correct reflog (f3cb6e2 in my case) and type

git reset --hard f3cb6e2

After that the repo HEAD will be reset to that HEADid LOG AFTER RESET

Finally the reflog looks like the picture below

REFLOG FINAL

Answer 21

First run:

git reflog

It will show you all the possible actions you have performed on your repository, for example, commit, merge, pull, etc.

Then do:

git reset --hard ActionIdFromRefLog

Answer 22

Undo last commit:

git reset --soft HEAD^ or git reset --soft HEAD~

This will undo the last commit.

Here --soft means reset into staging.

HEAD~ or HEAD^ means to move to commit before HEAD.

---

Replace last commit to new commit:

git commit --amend -m "message"

It will replace the last commit with the new commit.

Answer 23

Another way:

Checkout the branch you want to revert, then reset your local working copy back to the commit that you want to be the latest one on the remote server (everything after it will go bye-bye). To do this, in SourceTree I right-clicked on the and selected "Reset BRANCHNAME to this commit".

Then navigate to your repository's local directory and run this command:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

This will erase all commits after the current one in your local repository but only for that one branch.

Answer 24

输入git log并找到最后一次提交的哈希码，然后输入：

git reset <the previous co>

Answer 25

In my case I accidentally committed some files I did not want to. So I did the following and it worked:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Verify the results with gitk or git log --stat

Answer 26

很简单，在命令行中运行它：

git reset --soft HEAD~ 

Answer 27

There are two main scenarios

You haven't pushed the commit yet

If the problem was extra files you commited (and you don't want those on repository), you can remove them using git rm and then commiting with --amend

git rm <pathToFile>

You can also remove entire directories with -r , or even combine with other Bash commands

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

After removing the files, you can commit, with --amend option

git commit --amend -C HEAD # the -C option is to use the same commit message

This will rewrite your recent local commit removing the extra files, so, these files will never be sent on push and also will be removed from your local .git repository by GC.

You already pushed the commit

You can apply the same solution of the other scenario and then doing git push with the -f option, but it is not recommended since it overwrites the remote history with a divergent change (it can mess your repository).

Instead, you have to do the commit without --amend (remember this about -amend`: That option rewrites the history on the last commit).

Answer 28

For a local commit

git reset --soft HEAD~1

or if you do not remember exactly in which commit it is, you might use

git rm --cached <file>

For a pushed commit

The proper way of removing files from the repository history is using git filter-branch . That is,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

But I recomnend you use this command with care. Read more at git-filter-branch(1) Manual Page .

Answer 29

WHAT TO USE, reset --soft or reset --hard ?

I am just adding two cents for @Kyralessa's answer:

If you are unsure what to use go for --soft (I used this convention to remember it -- s oft for safe).

Why?

If you choose --hard by mistake you will LOSE your changes as it wasn't before. If you choose --soft by mistake you can achieve the same results of --hard by applying additional commands

git reset HEAD file.html
git checkout -- file.html

Full example

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Credits goes to @Kyralessa.

Answer 30

要重置到以前的版本，永久删除所有未提交的更改：

git reset --hard HEAD~1

Answer 31

There are many ways to do it:

Git command to undo the last commit/ previous commits:

Warning: Do Not use --hard if you do not know what you are doing. --hard is too dangerous , and it might delete your files.

Basic command to revert the commit in Git is:

$ git reset --hard <COMMIT -ID>

or

$ git reset --hard HEAD~<n>

COMMIT-ID : ID for the commit

n: is number of last commits you want to revert

You can get the commit id as shown below:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

where d81d3f1 and be20eb8 are commit id.

Now let's see some cases:

Suppose you want to revert the last commit 'd81d3f1'. Here are two options:

$ git reset --hard d81d3f1

or

$ git reset --hard HEAD~1

Suppose you want to revert the commit 'be20eb8':

$ git reset --hard be20eb8

For more detailed information you can refer and try out some other commands too for resetting head to a specified state:

$ git reset --help

Answer 32

Use SourceTree (graphical tool for Git) to see your commits and tree. You can manually reset it directly by right clicking it.

Answer 33

Think we have code.txt file. We make some changes on it and commit. We can undo this commit in three ways , but first you should know what is the staged file... An staged file is a file that ready to commit and if you run git status this file will be shown with green color and if this is not staged for commit will be shown with red color:

It means if you commit your change, your changes on this file is not saved. You can add this file in your stage with git add code.txt and then commit your change:

Undo last commit:

1. Now if we want to just undo commit without any other changes, we can use

   git reset --soft HEAD^

   

2. If we want to undo commit and its changes ( THIS IS DANGEROUS, because your change will lost ), we can use

   git reset --hard HEAD^

   

3. And if we want to undo commit and remove changes from stage, we can use

   git reset --mixed HEAD^ or in a short form git reset HEAD^

   

Answer 34

Usually, you want to undo a commit because you made a mistake and you want to fix it - essentially what the OP did when he asked the question. Really, you actually want to redo a commit.

Most of the answers here focus on the command line. While the command line is the best way to use Git when you're comfortable with it, its probably a bit alien to those coming from other version control systems to Git.

Here's how to do it using a GUI. If you have Git installed, you already have everything you need to follow these instructions.

NOTE: I will assume here that you realised the commit was wrong before you pushed it. If you don't know what pushing means, then you probably haven't pushed. Carry on with the instructions. If you have pushed the faulty commit, the least risky way is just to follow up the faulty commit with a new commit that fixes things, the way you would do it in a version control system that does not allow you to rewrite history.

That said, here's how to fix your most recent fault commit using a GUI:

1. Navigate to your repository on the command line and start the GUI with git gui
2. Choose "Amend last commit". You will see your last commit message, the files you staged and the files you didn't.
3. Now change things to how you want them to look and click Commit.

Answer 35

You can use:

git reset HEAD@{1}

This command will delete your wrong commit without a Git log.

Answer 36

如果您想恢复最后一次提交，但仍想在本地保留在提交中所做的更改，请使用以下命令：

git reset HEAD~1 --mixed

Answer 37

Undo the Last Commit

There are tons of situations where you really want to undo that last commit into your code. Eg because you'd like to restructure it extensively - or even discard it altogether!

In these cases, the "reset" command is your best friend:

$ git reset --soft HEAD~1

The above command (reset) will rewind your current HEAD branch to the specified revision. In our example above, we'd like to return to the one before the current revision - effectively making our last commit undone.

Note the --soft flag: this makes sure that the changes in undone revisions are preserved. After running the command, you'll find the changes as uncommitted local modifications in your working copy.

If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes any more.

$ git reset --hard HEAD~1

Answer 38

Just undo the last commit:

git reset --soft HEAD~

Or undo the time before last time commit:

git reset --soft HEAD~2

Or undo any previous commit:

git reset --soft <commitID>

(you can get the commitID using git reflog )

When you undo a previous commit, remember to clean the workplace with

git clean

More details can be found in the docs: git-reset

Answer 39

Before answering let's add some background, explaining what is this HEAD .

First of all what is HEAD?

HEAD is simply a reference to the current commit (latest) on the current branch.
There can only be a single HEAD at any given time. (excluding git worktree )

The content of HEAD is stored inside .git/HEAD and it contains the 40 bytes SHA-1 of the current commit.

---

detached HEAD

If you are not on the latest commit - meaning that HEAD is pointing to a prior commit in history its called detached HEAD .

On the command line, it will look like this- SHA-1 instead of the branch name since the HEAD is not pointing to the tip of the current branch

A few options on how to recover from a detached HEAD:

---

git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

This will checkout new branch pointing to the desired commit.
This command will checkout to a given commit.
At this point, you can create a branch and start to work from this point on.

# Checkout a given commit. 
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# create a new branch forked to the given commit
git checkout -b <branch name>

---

git reflog

You can always use the reflog as well.
git reflog will display any change which updated the HEAD and checking out the desired reflog entry will set the HEAD back to this commit.

Every time the HEAD is modified there will be a new entry in the reflog

git reflog
git checkout HEAD@{...}

This will get you back to your desired commit

---

git reset --hard <commit_id>

"Move" your HEAD back to the desired commit.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.

• Note: ( Since Git 2.7 )
  you can also use the git rebase --no-autostash as well.

---

git revert <sha-1>

"Undo" the given commit or commit range.
The reset command will "undo" any changes made in the given commit.
A new commit with the undo patch will be committed while the original commit will remain in the history as well.

# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>

---

This schema illustrates which command does what.
As you can see there reset && checkout modify the HEAD .

Answer 40

In my case I committed and pushed to the wrong branch, so what I wanted was to have all my changes back so I can commit them to a new correct branch, so I did this:

On the same branch that you committed and pushed, if you type "git status" you won't see anything new because you committed and pushed, now type:

    git reset --soft HEAD~1

This will get all your changes(files) back in the stage area, now to get them back in the working directory(unstage) you just type:

git reset FILE

Where "File" is the file that you want to commit again. Now, this FILE should be in the working directory(unstaged) with all the changes that you did. Now you can change to whatever branch that you want and commit the changes in that branch. Of course, the initial branch that you committed is still there with all changes, but in my case that was ok, if it is not for you-you can look for ways to revert that commit in that branch.

Answer 41

Undo the last commit:

git reset --soft HEAD^ or git reset --soft HEAD~

This will undo the last commit.

Here --soft means reset into staging.

HEAD~ or HEAD^ means to move to commit before HEAD.

Replace the last commit to new commit:

git commit --amend -m "message"

It will replace the last commit with the new commit.

Answer 42

If you are working with SourceTree , this will help you.

Right click on the commit then select " Reset (current branch)/master to this commit " and last select "Soft" reset .

Answer 43

To undo your local commit you use git reset <commit> . Also that tutorial is very helpful to show you how it works.

Alternatively, you can use git revert <commit> : reverting should be used when you want to add another commit that rolls back the changes (but keeps them in the project history).

Answer 44

Suppose you made a wrong commit locally and pushed it to a remote repository. You can undo the mess with these two commands:

First, we need to correct our local repository by going back to the commit that we desire:

git reset --hard <previous good commit id where you want the local repository  to go>

Now we forcefully push this good commit on the remote repository by using this command:

git push --force-with-lease

The 'with-lease' version of the force option it will prevent accidental deletion of new commits you do not know about (ie coming from another source since your last pull).

Answer 45

VISUAL STUDIO USERS (2015, etc.)

If you cannot synchronise in Visual Studio as you are not allowed to push to a branch like "development" then as much as I tried, in Visual Studio NEITHER the REVERT NOR the RESET (hard or soft) would work.

Per the answer with TONS OF VOTES:

Use this at the command prompt of root of your project to nuke anything that will attempt to get pushed:

git reset --hard HEAD~1

Backup or zip your files just in case you don't wish to lose any work, etc...

Answer 46

Everybody comments in such a complicated manner.

If you want to remove the last commit from your branch, the simplest way to do it is:

git reset --hard HEAD~1

Now to actually push that change to get rid of your last commit, you have to

git push --force

And that's it. This will remove your last commit.

Answer 47

A Typical Git Cycle

In speaking of Git-related commands in the previous answers, I would like to share my typical Git cycles with all readers which may helpful. Here is how I work with Git,

1. Cloning the first time from the remote server

   git clone $project

2. Pulling from remote (when I don't have a pending local commit to push)

   git pull

3. Adding a new local file1 into $to_be_committed_list (just imagine $to_be_committed_list means staged area)

   git add $file1

4. Removing mistakenly added file2 from $to_be_committed_list (assume that file2 is added like step 3, which I didn't want)

   git reset $file2

5. Committing file1 which is in $to_be_committed_list

   git commit -m "commit message description"

6. Syncing local commit with remote repository before pushing

   git pull --rebase

7. Resolving when conflict occurs prerequisite configure mergetool

   git mergetool #resolve merging here, also can manually merge

8. Adding conflict-resolved files, let's say file1 :

   git add $file1

9. Continuing my previous rebase command

   git rebase --continue

10. Pushing ready and already synced last local commit

    git push origin head:refs/for/$branch # branch = master, dev, etc.

Answer 48

In these cases, the "reset" command is your best friend:

git reset --soft HEAD~1

Reset will rewind your current HEAD branch to the specified revision. In our example above, we'd like to return to the one before the current revision - effectively making our last commit undone.

Note the --soft flag: this makes sure that the changes in undone revisions are preserved. After running the command, you'll find the changes as uncommitted local modifications in your working copy.

If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes anymore.

git reset --hard HEAD~1

Answer 49

Remove a wrong commit that is already pushed to Github

git push origin +(previous good commit id):(branch name)

Please specify the last good commit id you would like to reset back in Github.

For example. If latest commit id is wrong then specify the previous commit id in above git command with the branch name.

You can get previous commit id using git log

Answer 50

In order to get rid of (all the changes in) last commit, last 2 commits and last n commits:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

And, to get rid of anything after a specific commit:

git reset --hard <commit sha>

eg,

git reset --hard 0d12345

Be careful with the hard option: it deletes the local changes in your repo as well and reverts to the previous mentioned commit. You should only run this if you are sure you messed up in your last commit(s) and would like to go back in time.

As a side-note, about 7 letters of the commit hash is enough, but in bigger projects, you may need up to 12 letters for it to be unique. You can also use the entire commit SHA if you prefer.

The above commands work in GitHub for Windows as well.

Answer 51

I got the commit ID from bitbucket and then did:

git checkout commitID .

Example:

git checkout 7991072 .

And it reverted it back up to that working copy of that commit.

Answer 52

You need to do the easy and fast

    git commit --amend

if it's a private branch or

    git commit -m 'Replace .class files with .java files'

if it's a shared or public branch.

Answer 53

Do as the following steps.

Step 1

Hit git log

From the list of log, find the last commit hash code and then enter:

Step 2

git reset <hash code>

Answer 54

使用此命令

git checkout -b old-state 0d1d7fc32

Answer 55

您始终可以执行git checkout <SHA code>的先前版本，然后使用新代码再次提交。

Answer 56

使用这个命令：

git checkout -b old-state number_commit

Answer 57

In order to remove some files from a Git commit, use the “git reset” command with the “–soft” option and specify the commit before HEAD.

$ git reset --soft HEAD~1

When running this command, you will be presented with the files from the most recent commit (HEAD) and you will be able to commit them.

Now that your files are in the staging area, you can remove them (or unstage them) using the “git reset” command again.

$ git reset HEAD <file>

Note: this time, you are resetting from HEAD as you simply want to exclude files from your staging area

If you are simply not interested in this file any more, you can use the “git rm” command in order to delete the file from the index (also called the staging area).

$ git rm --cached <file>

When you are done with the modifications, you can simply commit your changes again with the “–amend” option.

$ git commit --amend

To verify that the files were correctly removed from the repository, you can run the “git ls-files” command and check that the file does not appear in the file (if it was a new one of course)

$ git ls-files

 <file1>
 <file2>

Remove a File From a Commit using Git Restore

Since Git 2.23, there is a new way to remove files from commit, but you will have to make sure that you are using a Git version greater or equal than 2.23.

$ git --version

Git version 2.24.1

Note: Git 2.23 was released in August 2019 and you may not have this version already available on your computer.

To install newer versions of Git, you can check this tutorial. To remove files from commits, use the “git restore” command, specify the source using the “–source” option and the file to be removed from the repository.

For example, in order to remove the file named “myfile” from the HEAD, you would write the following command

$ git restore --source=HEAD^ --staged  -- <file>

As an example, let's pretend that you edited a file in your most recent commit on your “master” branch.

The file is correctly committed but you want to remove it from your Git repository.

To remove your file from the Git repository, you want first to restore it.

$ git restore --source=HEAD^ --staged  -- newfile

$ git status

On branch 'master'

Your branch is ahead of 'origin/master' by 1 commit. (use "git push" to publish your local commits)

Changes to be committed:

 (use "git restore --staged <file>..." to unstage)
    modified:   newfile

Changes not staged for commit:

 (use "git add <file>..." to update what will be committed)
 (use "git restore <file>..." to discard changes in working directory)
      modified:   newfile

As you can see, your file is back to the staging area.

From there, you have two choices, you can choose to edit your file in order to re-commit it again, or to simply delete it from your Git repository.

Remove a File from a Git Repository

In this section, we are going to describe the steps in order to remove the file from your Git repository.

First, you need to unstage your file as you won't be able to remove it if it is staged.

To unstage a file, use the “git reset” command and specify the HEAD as source.

$ git reset HEAD newfile

When your file is correctly unstaged, use the “git rm” command with the “–cached” option in order to remove this file from the Git index (this won't delete the file on disk)

$ git rm --cached newfile

rm 'newfile'

Now if you check the repository status, you will be able to see that Git staged a deletion commit.

$ git status

On branch 'master'

Your branch is ahead of 'origin/master' by 1 commit. (use "git push" to publish your local commits)

Changes to be committed:

 (use "git restore --staged <file>..." to unstage)
    deleted:    newfile

Now that your file is staged, simply use the “git commit” with the “–amend” option in order to amend the most recent commit from your repository.

`$ git commit --amend

 [master 90f8bb1] Commit from HEAD
  Date: Fri Dec 20 03:29:50 2019 -0500
  1 file changed, 2 deletions(-)
  delete mode 100644 newfile

`As you can see, this won't create a new commit but it will essentially modify the most recent commit in order to include your changes.

Remove a Specific File from a Git Commit

In some cases, you don't want all the files to be staged again: you only one to modify one very specific file of your repository.

In order to remove a specific file from a Git commit, use the “git reset” command with the “–soft” option, specify the commit before HEAD and the file that you want to remove.

$ git reset HEAD^ -- <file>

When you are done with the modifications, your file will be back in the staging area.

First, you can choose to remove the file from the staging area by using the “git reset” command and specify that you want to reset from the HEAD.

$ git reset HEAD <file>

Note: it does not mean that you will lose the changes on this file, just that the file will be removed from the staging area.

If you want to completely remove the file from the index, you will have to use the “git rm” command with the “–cached” option.

$ git reset HEAD <file>

In order to make sure that your file was correctly removed from the staging area, use the “git ls-files” command to list files that belong to the index.

$ git ls-files

When you are completely done with your modifications, you can amend the commit you removed the files from by using the “git commit” command with the “–amend” option.

$ git commit --amend

Answer 58

You can undo your Git commits in two ways: First is you can use git revert , if you want to keep your commit history:

git revert HEAD~3
git revert <hashcode of commit>

Second is you can use git reset , which would delete all your commit history and bring your head to commit where you want it.

git reset <hashcode of commit>
git reset HEAD~3

You can also use the --hard keyword if any of it starts behaving otherwise. But, I would only recommend it until it's extremely necessary.

Answer 59

git reset --soft HEAD~1

Reset will rewind your current HEAD branch to the specified revision.

Note the --soft flag: this makes sure that the changes in undone revisions are preserved. After running the command, you'll find the changes as uncommitted local modifications in your working copy.

If you don't want to keep these changes, simply use the --hard flag. Be sure to only do this when you're sure you don't need these changes anymore.

 git reset --hard HEAD~1

Undoing Multiple Commits

git reset --hard 0ad5a7a6

Keep in mind, however, that using the reset command undoes all commits that came after the one you returned to:

Answer 60

Reference: How to undo last commit in Git?

If you have Git Extensions installed you can easily undo/revert any commit (you can download Git Extensions from here ).

Open Git Extensions, right click on the commit you want to revert then select "Revert commit".

A popup will be opened (see the screenshot below)

Select "Automatically create a commit" if you want to directly commit the reverted changes or if you want to manually commit the reverted changes keep the box un-selected and click on "Revert this commit" button.

Answer 61

I have found this site which describes how to undo things that you have committed into the repository.

Some commands:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

Answer 62

Here is site: Oh shit, git! .

Here are many recipes how to undo things in Git. Some of them:

Oh shit, I need to change the message on my last commit!

git commit --amend
# follow prompts to change the commit message

Oh shit, I accidentally committed something to master that should have been on a brand new branch!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

Answer 63

You can undo your commits from the local repository. Please follow the below scenario.

In the below image I check out the 'test' branch (using Git command git checkout -b test ) as a local and check status (using Git command git status ) of local branch that there is nothing to commit.

In the next image image you can see here I made a few changes in Filter1.txt and added that file to the staging area and then committed my changes with some message (using Git command git commit -m "Doing commit to test revert back" ).

"-m is for commit message"

In the next image you can see your commits log whatever you have made commits (using Git command git log ).

So in the above image you can see the commit id with each commit and with your commit message now whatever commit you want to revert back or undo copy that commit id and hit the below Git command, git revert {"paste your commit id"} . Example:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

I have reverted back my last commit. Now if you check your Git status, you can see the modified file which is Filter1.txt and yet to commit.

Answer 64

The difference between git reset --mixed, --soft and --hard

Prerequisite: When a modification to an existing file in your repository is made, this change is initially considered as unstaged. In order to commit the changes, it needs to be staged which means adding it to the index using git add . During a commit operation, the files that are staged gets added to an index.

Let's take an example:

- A - B - C (master)

HEAD points to C and the index matches C .

--soft

• When we execute git reset --soft B with the intention of removing the commit C and pointing the master/HEAD to B .
• The master/HEAD will now point to B, but the index still has changed from C .
• When executing git status you could see the files indexed in commit C as staged .
• Executing a git commit at this point will create a new commit with the same changes as C

--mixed

• Execute git reset --mixed B .
• On execution, master/HEAD will point to B and the index is also modified to match B because of the mixed flag used.
• If we run git commit at this point, nothing will happen since the index matches HEAD .
• We still have the changes in the working directory, but since they're not in the index, git status shows them as unstaged .
• To commit them, you would git add and then commit as usual.

--hard

• Execute git reset --hard B
• On execution, master/HEAD will point to B and modifies your working directory
• The changes added in C and all the uncommitted changes will be removed .
• Files in the working copy will match the commit B, this will result in loosing permanently all changes which were made in commit C plus uncommitted changes

Hope this comparison of flags that are available to use with git reset command will help someone to use them wisely. Refer these for further details link1 & link2

Answer 65

The simplest way to undo the last commit is

git reset HEAD^

This will bring the project state before you have made the commit.

Answer 66

For sake of completeness, I will give the one glaringly obvious method that was overlooked by the previous answers.

Since the commit was not pushed, the remote was unchanged, so:

1. Delete the local repository.
2. Clone the remote repository.

This is sometimes necessary if your fancy Git client goes bye-bye (looking at you, egit).

Don't forget to re-commit your saved changes since the last push.

Answer 67

Undoing a series of local commits

OP: How do I undo the most recent local commits in Git? I accidentally committed the wrong files [as part of several commits].

Start case

There are several ways to "undo" as series of commits, depending on the outcome you're after. Considering the start case below, reset , rebase and filter-branch can all be used to rewrite your history.

How can C1 and C2 be undone to remove the tmp.log file from each commit?

In the examples below, absolute commit references are used, but it works the same way if you're more used to relative references (ie HEAD~2 or HEAD@{n} ).

Alternative 1: reset

$ git reset --soft t56pi

With reset , a branch can be reset to a previous state, and any compounded changes be reverted to the Staging Area , from where any unwanted changes can then be discarded.

Note: As reset clusters all previous changes into the Staging Area , individual commit meta-data is lost. If this is not OK with you, chances are you're probably better off with rebase or filter-branch instead.

Alternative 2: rebase

$ git rebase --interactive t56pi

Using an interactive rebase each offending commit in the branch can be rewritten, allowing you to modify and discard unwanted changes. In the infographic above, the source tree on the right illustrates the state post rebase .

Step-by-step

1. Select from which commit the rebase should be based (eg t56pi )
2. Select which commits you'd like to change by replacing pick with edit . Save and close.
3. Git will now stop on each selected commit allowing you to reset HEAD , remove the unwanted files, and create brand new commits.

Note: With rebase much of the commit meta data is kept, in contrast to the reset alternative above. This is most likely a preferred option, if you want to keep much of your history but only remove the unwanted files.

Alternative 3: filter-branch

$ git filter-branch --tree-filter 'rm -r ./tmp.log' t56pi..HEAD

Above command would filter out the file ./tmp.log from all commits in the desired range t56pi..HEAD (assuming our initial start case from above). See below illustration for clarity.

Similar to rebase , filter-branch can be used to wipe unwanted files from a subsection of a branch. Instead of manually editing each commit through the rebase process, filter-branch can automatically preformed the desired action on each commit.

Note: Just like rebase , filter-branch would preserve the rest of the commit meta-data, by only discarding the desired file. Notice how C1 and C2 have been rewritten, and the log-file discarded from each commit.

Conclusion

Just like anything related to software development, there are multiple ways to achieve the same (or similar) outcome for a give problem. You just need to pick the one most suitable for your particular case.

Finally - a friendly advice

Do note that all three alternatives above rewrites the history completely. Unless you know exactly what you're doing and have good communication within your team - only rewrite commits that have not yet been published remotely!

Source: All examples above are borrowed from this blog .

Answer 68

HEAD:

Before reset commit we should know about HEAD... HEAD is nothing but your current state in your working directory. It is represented by a commit number.

Git commit:

Each change assigned under a commit which is represented by a unique tag. Commits can't be deleted. So if you want your last commit, you can simply dive into it using git reset .

You can dive into the last commit using two methods:

Method 1: (if you don't know the commit number, but want to move onto the very first)

git reset HEAD~1  # It will move your head to last commit

Method 2: (if you know the commit you simply reset onto your known commit)

git reset 0xab3 # Commit number

Note: if you want to know a recent commit try git log -p -1

Here is the graphical representation:

Answer 69

Just use git reset --hard <last good SHA> to reset your changes and give new commit. You can also use git checkout -- <bad filename> .

Answer 70

I validate an efficient method proposed, and here is a concrete example using it:

In case you want to permanently undo/cancel your last commit (and so on, one by one, as many as you want) three steps:

1: Get the id = SHA of the commit you want to arrive on with, of course

$ git log

2: Delete your previous commit with

$ git reset --hard 'your SHA'

3: Force the new local history upon your origin GitHub with the -f option (the last commit track will be erased from the GitHub history)

$ git push origin master -f

Example

$ git log

Last commit to cancel

commit e305d21bdcdc51d623faec631ced72645cca9131 (HEAD -> master, origin/master, origin/HEAD)
Author: Christophe <blabla@bla.com>
Date:   Thu Jul 30 03:42:26 2020 +0200

U2_30 S45; updating files package.json & yarn.lock for GitHub Web Page from docs/CV_Portfolio...

Commit we want now on HEAD

commit 36212a48b0123456789e01a6c174103be9a11e61
Author: Christophe <blabla@bla.com>
Date:   Thu Jul 30 02:38:01 2020 +0200

First commit, new title

Reach the commit before by deleting the last one

$ git reset --hard 36212a4

HEAD is now at 36212a4 First commit, new title

Check it's OK

$ git log

commit 36212a48b0123456789e01a6c174103be9a11e61 (HEAD -> master)
Author: Christophe <blabla@bla.com>
Date:   Thu Jul 30 02:38:01 2020 +0200

    First commit, new title

$ git status

On branch master
Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
 (use "git pull" to update your local branch)

nothing to commit, working tree clean

Update your history on the Git(Hub)

$ git push origin master -f

Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/ GitUser bla bla/React-Apps.git
 + e305d21...36212a4 master -> master (forced update)

Check it's all right

$ git status

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Answer 71

A simple step-by-step guide is as follows:

• Destroy a commit and throw away any uncommitted changes

git reset --hard HEAD~1

• undo the commit but keep your changes

git reset HEAD~1

• Keep your files, and stage all changes back automatically

git reset --soft HEAD~1

• resurrect a commit you destroyed

git reflog #to find the sh

Answer 72

If you would like to eliminate the wrong files you should do

git reset --soft <your_last_good_commit_hash_here> Here, if you do git status , you will see the files in the staging area. You can select the wrong files and take them down from the staging area.

Like the following.

git reset wrongFile1 wrongFile2 wrongFile3

You can now just add the files that you need to push,

git add goodFile1 goodFile2

Commit them

git commit -v or git commit -am "Message"

And push

git push origin master

However, if you do not care about the changed files you can hard reset to previous good commit and push everything to the server.

By

git reset --hard <your_last_good_commit_hash_here>

git push origin master

If you already published your wrong files to the server, you can use the --force flag to push to the server and edit the history.

git push --force origin master

Answer 73

git reset --soft HEAD~1

git status

Output

On branch master
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)

Changes to be committed:
(use "git restore --staged ..." to unstage) new file: file1

git log --oneline --graph

Output

• 90f8bb1 (HEAD -> master) Second commit \
• 7083e29 Initial repository commit \

Answer 74

Before answering, let's add some background, explaining what this HEAD is.

First of all what is HEAD?

HEAD is simply a reference to the current commit (latest) on the current branch.
There can only be a single HEAD at any given time (excluding git worktree ).

The content of HEAD is stored inside .git/HEAD and it contains the 40 bytes SHA-1 of the current commit.

---

detached HEAD

If you are not on the latest commit - meaning that HEAD is pointing to a prior commit in history it's called detached HEAD .

On the command line, it will look like this - SHA-1 instead of the branch name since the HEAD is not pointing to the tip of the current branch:

---

A few options on how to recover from a detached HEAD:

---

git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits to go back

This will checkout the new branch pointing to the desired commit.
This command will checkout to a given commit.
At this point, you can create a branch and start to work from this point on.

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

---

git reflog

You can always use the reflog as well.
git reflog will display any change which updated the HEAD and checking out the desired reflog entry will set the HEAD back to this commit.

Every time the HEAD is modified there will be a new entry in the reflog

git reflog
git checkout HEAD@{...}

This will get you back to your desired commit

---

git reset --hard <commit_id>

"Move" your HEAD back to the desired commit.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.

• Note: ( Since Git 2.7 ) you can also use the git rebase --no-autostash as well.

---

git revert <sha-1>

"Undo" the given commit or commit range.
The reset command will "undo" any changes made in the given commit.
A new commit with the undo patch will be committed while the original commit will remain in history as well.

# Add a new commit with the undo of the original one.
# The <sha-1> can be any commit(s) or commit range
git revert <sha-1>

---

This schema illustrates which command does what.
As you can see there, reset && checkout modify the HEAD .

Answer 75

在 IntelliJ IDEA 中，您只需按Alt + 9打开 Git 存储库日志，鼠标右键单击提交列表中的某个标记，然后选择： “将当前分支重置到此处...” 。

Answer 76

Rebasing and dropping commits are the best when you want to keep the history clean useful when proposing patches to a public branch etc.

If you have to drop the topmost commit then the following one-liner helps

git rebase --onto HEAD~1 HEAD

But if you want to drop 1 of many commits you did say

a -> b -> c -> d -> master

and you want to drop commit 'c'

git rebase --onto b c

This will make 'b' as the new base of 'd' eliminating 'c'

Answer 77

What I do each time I need to undo a commit/commits are:

1. git reset HEAD~<n> // the number of last commits I need to undo

2. git status // optional. All files are now in red (unstaged).

3. Now, I can add & commit just the files that I need:

• git add <file names> & git commit -m "message" -m "details"

4. Optional: I can rollback the changes of the rest files, if I need, to their previous condition, with checkout:

• git checkout <filename>

5. if I had already pushed it to remote origin, previously:

• git push origin <branch name> -f // use -f to force the push.

Answer 78

To undo the last local commit, without throwing away its changes, I have this handy alias in ~/.gitconfig

[alias]
  undo = reset --soft HEAD^

Then I simply use git undo which is super-easy to remember.

Answer 79

Find the last commit hash code by seeing the log by:

git log

Then

git reset <the previous co>

Answer 80

Assuming you're working in Visual Studio, if you go in to you branch history and look at all of your commits, simply select the event prior to the commit you want to undo, right-click it, and select Revert . Easy as that.

Answer 81

Replace your local version, including your changes with the server version. These two lines of code will force Git to pull and overwrite local.

Open a command prompt and navigate to the Git project root. If you use Visual Studio, click on Team , Sync and click on "Open Command Prompt" (see the image) below.

Once in the Cmd prompt, go ahead with the following two instructions.

git fetch --all

Then you do

git reset --hard origin/master

This will overwrite the existing local version with the one on the Git server.

Answer 82

I wrote about this ages ago after having these same problems myself:

How to delete/revert a Git commit

Basically you just need to do:

git log , get the first seven characters of the SHA hash, and then do a git revert <sha> followed by git push --force .

You can also revert this by using the Git revert command as follows: git revert <sha> -m -1 and then git push .

Answer 83

Try this, hard reset to previous commit where those files were not added, then:

git reset --hard <commit_hash>

Make sure you have a backup of your changes just in case, as it's a hard reset, which means they'll be lost (unless you stashed earlier)

Answer 84

如果您只是想丢弃所有本地更改/提交并使您的本地分支看起来像您开始的原始分支......

git reset --hard origin/branch-name

Answer 85

If you want to undo the very first commit in your repo

You'll encounter this problem:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

The error occurs because if the last commit is the initial commit (or no parents) of the repository, there is no HEAD~.

Solution

If you want to reset the only commit on "master" branch

$ git update-ref -d HEAD
$ git rm --cached -r .

Answer 86

Get last commit ID by using this command (in the log one on the top it is the latest one):

git log

Get the commit id (GUID) and run this command:

git revert <commit_id>

Answer 87

How to edit an earlier commit

Generally I don't want to undo a bunch of commits, but rather edit an earlier commit to how I wish I had committed it in the first place.

I found myself fixing a past commit frequently enough that I wrote a script for it.

Here's the workflow:

1.  git commit-edit <commit-hash>

   This will drop you at the commit you want to edit.

   The changes of the commit will be un staged, ready to be staged as you wish it was the first time.

2. Fix and stage the commit as you wish it had been in the first place.

   (You may want to use git stash save --keep-index to squirrel away any files you're not committing)

3. Redo the commit with --amend , eg:

    git commit --amend

4. Complete the rebase:

    git rebase --continue

---

Call this following git-commit-edit and put it in your $PATH :

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "$@"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

Answer 88

You can use git revert <commit-id> .

And for getting the commit ID, just use git log .

Answer 89

Visual Studio Code makes this very easy.

Answer 90

#1) $ git commit -m "Something terribly misguided" 
#2) $ git reset HEAD~                              

[ edit files as necessary ]

 #3) $ git add .
#4) $ git commit -c ORIG_HEAD  

Answer 91

git revert commit

This will generate the opposite changes from the commit which you want to revert back, and then just commit that changes. I think this is the simplest way.

https://git-scm.com/docs/git-revert

Answer 92

$ git commit -m 'Initial commit'
$ git add forgotten_file
$ git commit --amend

It's important to understand that when you're amending your last commit, you're not so much fixing it as replacing it entirely with a new, improved commit that pushes the old commit out of the way and puts the new commit in its place. Effectively, it's as if the previous commit never happened, and it won't show up in your repository history.

The obvious value to amending commits is to make minor improvements to your last commit, without cluttering your repository history with commit messages of the form, “Oops, forgot to add a file” or “Darn, fixing a typo in last commit”.

2.4 Git Basics - Undoing Things

Answer 93

I usually first find the commit hash of my recent commit:

git log

It looks like this: commit {long_hash}

Copy this long_hash and reset to it (go back to same files/state it was on that commit):

git reset --hard {insert long_hash without braces}

Answer 94

The easiest way is to:

$ git reset --soft HEAD~1

Do it as many times as you required the undo. The committed changes will be in recent changes, and then you can make a new commit to the correct branch or so.

Answer 95

git push --delete (branch_name) //this will be removing the public version of your branch

git push origin (branch_name) //This will add the previous version back

Answer 96

git reset HEAD@{n} will reset your last n actions.

For reset, for the last action, use git reset HEAD@{1} .

Answer 97

If the repository has been committed locally and not yet pushed to the server, another crude/layman way of solving it would be:

1. Git clone the repository in another location.
2. Copy the modifications (files/directories) from the original repository into this new one. Then commit and push with the changes from the new one.
3. Replace the old repository with this new one.

Answer 98

Firstly, run this command to reset the commit :

git reset --hard HEAD~1

Secondly, run this command to push the new commit :

git push upstream head -f

Answer 99

You can use the git reset unwanted_file command with the file you don't want to stage. By using this command, we can move the changed file from the staging area to the working directory.

How can I undo commits in Git locally and remotely?

Answer 100

IN CASE IF YOU WANT TO REVET TO A LAST COMMIT AND REMOVE THE LOG HISTORY AS WELL

Use below command lets say you want to go to previous commit which has commitID SHA - 71e2e57458bde883a37b332035f784c6653ec509 the you can point to this commit it will not display any log message after this commit and all history will be erased after that.

git push origin +71e2e57458bde883a37b332035f784c6653ec509^:master

Answer 101

git reset --soft HEAD~1

Soft: This will remove the commit from local only and keep the changes done in files as it is.

    git reset --hard HEAD~1
    git push origin master

Hard: This will remove that commit from local and remote and remove changes done in files.

Answer 102

In Visual Studio, simply revert your commit then push it together with the auto created revert commit. Everything is shown in the screen shots below

Answer 103

If you are using GitHub desktop there will be an undo button on the left side under the blue Commit to BRANCH_NAME button

Answer 104

If you want to preserve your work and commit after doing some more work, then you can use --amend<\/code> flag to overwrite last commit.

Answer 105

If you have made local commits that you don't like, and they have not been pushed yet you can reset things back to a previous good commit. It will be as if the bad commits never happened. Here's how:

In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo. Run git status and make sure you have a clean working tree. Each commit has a unique hash (which looks something like 2f5451f). You need to find the hash for the last good commit (the one you want to revert back to). Here are two places you can see the hash for commits: In the commit history on GitHub or Bitbucket or website. In your terminal (Terminal, Git Bash, or Windows Command Prompt) run the command git log --online Once you know the hash for the last good commit (the one you want to revert back to), run the following command (replacing 2f5451f with your commit's hash):

git reset 2f5451f
git reset --hard 2f5451f

NOTE: If you do git reset the commits will be removed, but the changes will appear as uncommitted, giving you access to the code. This is the safest option because maybe you wanted some of that code and you can now make changes and new commits that are good. Often though you'll want to undo the commits and throw away the code, which is what git reset --hard does.

Answer 106

git diff + git apply have been the best option for my team so far, it's clean and super easy, not only for the last commit

Answer 107

To undo the most recent local commits, you can use the git reset command followed by the commit hash. This will move the current branch pointer to the previous commit, effectively deleting the recent commits.

For example, if you want to undo the last commit, you can use the following command:

git reset HEAD~1 This will undo the last commit and all the changes made in that commit. The changes will still be present in your working directory, so you will need to commit the changes again if you want to keep them.

If you want to completely remove the changes made in the recent commits, you can use the git reset command with the --hard flag. This will discard all changes made in the recent commits and reset the files in your working directory to match the previous commit.

For example, to completely remove the last commit:

git reset --hard HEAD~1 This will discard all changes made in the last commit and reset the files in your working directory to match the previous commit.

Be careful when using the git reset command, as it can permanently destroy work if used improperly. It is always a good idea to create a backup of your work before using the git reset command.