30

First, I have seen the answer to this question here before, but it is buried by so many "answers" which don't answer my question properly, that I cannot find it again.

So here it goes: How do I restore in Git to a previous version in my history, so that it becomes the new commit on top of my current history?

Basically, this is the most fundamental thing I would like to do with a version control system. Simply doing a reset doesn't work, because it throws away my history, a simple revert doesn't work either, because sometimes it gives me error messages (what I want to do should be possible without any error messages).

If I just do a git revert this error happens:

git revert HEAD~1 error: could not revert f1b44e3... Towards translating API to kernel. hint: after resolving the conflicts, mark the corrected paths hint: with 'git add <paths>' or 'git rm <paths>' hint: and commit the result with 'git commit'
Improve this question
1
  • 1
    git revert means "back out one single, specific commit", not "go back to a previous version". Mercurial's name for this operation is better: hg backout. Mercurial has an hg revert with the meaning you expected here! Meanwhile Dai's answer is correct. Commented Jun 23, 2017 at 21:51

4 Answers 4

Reset to default
50

Simply "checkout the commit". This will overwrite your current working directory with the specified snapshot (commit) of your repo from history and make that your new working-set which you can stage and commit as you wish.

cd ~/git/your-repo-root git log # find the commit id you want git checkout <commitId> .

Important note: the trailing . in the previous line is important! If you omit it, you will end up in a "detached HEAD" state, which you do not want here.

If you commit immediately afterwards then your repo will have the same filesystem contents as the commit you performed the checkout to (assuming you have no other unstaged or staged changes):

git commit -m "Restoring old source code"

This will not rewrite history nor edit or delete any previous commits - so it works similar to a "rollback" on Mediawiki:

See also: Rollback to an old Git commit in a public repo

Regarding the . (dot)

The . (dot) character means "current directory" - it is not anything special or unique to git, it's a standard command-line filesystem convention that's the same on Windows, Linux, macOS, and even MS-DOS. It works similar to how .. means "parent directory". I recommend reading these:

Regarding checkout

Be aware: checkout is an overloaded command in git - it can mean to switch branches (a la svn switch) or to get a specific file or commit from history and put into your workspace (a la svn update -r <id>). It can mean other things too: https://git-scm.com/docs/git-checkout - I appreciate it can confuse people, especially myself when I started using git after using TFS for years (where "Checkout" means something else entirely).

Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

Argh. This won't work either. I want the old stuff committed on top of my last commit. Please guys, don't spam with wrong answers if you don't know how to do what I want.
@StevenObua But that's what this does - it will take the old snapshot, then when you commit it, it will be the new HEAD. I've modified my answer to include the final git commit.
Ok, will try that out when I am home again!
That's exactly what I wanted Dai. Thank you very much, and I am sorry for not reading your answer careful enough. In my mind checkout always created a new branch for the specified version, I didn't know about the other meaning.
If you, like me, missed the trailing . and end up in a detached HEAD state, then git checkout master (or presumably substitute master for whatever branch you were working on) will essentially undo that command.
|
2

Edit: I see that you want to keep the history, so my answer below is nullified. However, it is still useful. You can reorder the lines in the editor, then proceed.

Now, back to the original answer.

You could try the rebase command.

git rebase -i HEAD~n

Where n is about one more than the number of commits between current and the one you want to revert to. So let's say, deleting the last 3 commits:

git rebase -i HEAD~4

Once you're there, it will open in VIM or Nano (or other editor). Simply delete the lines of the commits to remove, and exit the editor.

In VIM that would be esc and type :exit enter.

Now, simply push it. That will result in an error, so do a force push.

git push -f

You might have to specify branch name and upstream too. That should do it!

This method completely deletes the bad commits, so it won't just add a new commit with the revert changes.

Here's the docs: https://git-scm.com/docs/rebase

Improve this answer

Comments

1

Take a note of the commit hash of current HEAD

  1. git reset --hard <old-commit>
  2. git reset --soft <previous-HEAD>
  3. git add . && git commit -m "message"

Done!

Improve this answer

Comments

0

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

git revert HEAD~1
Improve this answer

1 Comment

Nope. That command sometimes gives errors where you need to do further things. I don't want that.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.