CODEWITHSUNDEEP
gitversion-controlgit-checkoutgit-restore
Hates_
Hates_

Reputation: 68771

How can I reset or revert a file to a specific revision?

How can I revert a modified file to its previous revision at a specific commit hash (which I determined via git log and git diff)?

Upvotes: 5833

Views: 3190723

Answers (30)

MenyT
MenyT

Reputation: 2265

Git 2.23.0+

Revert file to state as in origin/main

git restore --source origin/main filename

Revert file to state as in specific commit

git restore --source <hash> filename

Before Git 2.23.0

Revert file to state as in origin/main

git checkout origin/main filename

Revert file to state as in specific commit

git checkout <hash> filename

Upvotes: 31

Greg Hewgill
Greg Hewgill

Reputation: 994301

Assuming the hash of the commit you want is c5f567:

git checkout c5f567 -- file1/to/restore file2/to/restore

The git checkout man page gives more information.

If you want to revert to the commit before c5f567, append ~1 (where 1 is the number of commits you want to go back, it can be anything):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

As a side note, I've always been uncomfortable with this command because it's used for both ordinary things (changing between branches) and unusual, destructive things (discarding changes in the working directory).

For the meaning of -- in the command, refer to In Git, what does -- (dash dash) mean?

There is also a new git restore command that is specifically designed for restoring working copy files that have been modified. If your git is new enough you can use this command, but the documentation comes with a warning:

THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.

Because git restore is experimental, it should not yet be promoted as the primary answer to this question. When the command is no longer marked as "experimental", then this answer can be amended to promote the use of git restore. [At the time of writing, the git restore command has been marked as "experimental" for at least four years.]

Upvotes: 7837

Jamie M.
Jamie M.

Reputation: 722

I know people are going to hate this but Sourcetree has a "reverse file" option when viewing the commit history. Click on "History" > Click on the file to revert > Click the ellipsis on the right hand side > Choose "Reverse File". You will see the reverted file changes when you click on file status. Commit > Push and voila`!

Upvotes: 0

Valeriy K.
Valeriy K.

Reputation: 2904

git log --oneline  // you see commits, find commit hash to which you want reset
git diff y0urhash src/main/.../../YourFile.java   // to see difference
git reset y0urhash src/main/.../../YourFile.java   // revert to y0urhash commit
git status                                        // check files to commit
git commit -m "your commit message"
git push origin

Upvotes: 15

user1034533
user1034533

Reputation: 1074

For files 'a.txt', 'b.txt', 'c.txt':

  1. git revert -n <commit> (e.g. git revert -n HEAD to revert the last commit). This will prepare (but not commit!) and stage all the changes to undo a specific commit

  2. git reset. This will unstage all the reverse changes so you can manually add the files you want changed back.

  3. git add a.txt b.txt c.txt. This adds the files you want to undo changes to to your new commit.

  4. git commit -m 'Undo <commit> for a.txt, b.txt, c.txt'. Commit the actual changes

  5. git reset --hard. Get rid of anything you don't want undone.

Upvotes: -5

Dev-lop-er
Dev-lop-er

Reputation: 728

  • Run the following command that does a soft reset and the changes comes to your local.
git reset --soft HEAD^1
  • See the status of files that you previously committed that comes to your local and then make the change.
 git status

  • Commit and push the file after making the changes.

  • Previous commit history for the wrong committed files will not be shown

Before pulling from origin always have pruning (Optional Step)

 git remote prune origin

Upvotes: -5

ireshika piyumalie
ireshika piyumalie

Reputation: 2402

  1. Git revert file to a specific commit
git checkout Last_Stable_commit_Number -- fileName

2.Git revert file to a specific branch

git checkout branchName_Which_Has_stable_Commit fileName

Upvotes: 45

mjarosie
mjarosie

Reputation: 4603

As of git v2.23.0 there's a new git restore method which is supposed to assume part of what git checkout was responsible for (even the accepted answer mentions that git checkout is quite confusing). See highlights of changes on github blog.

The default behaviour of this command is to restore the state of a working tree with the content coming from the source parameter (which in your case will be a commit hash).

So based on Greg Hewgill's answer (assuming the commit hash is c5f567) the command would look like this:

git restore --source=c5f567 file1/to/restore file2/to/restore

Or if you want to restore to the content of one commit before c5f567:

git restore --source=c5f567~1 file1/to/restore file2/to/restore

Upvotes: 219

Aaron Maenpaa
Aaron Maenpaa

Reputation: 122970

Amusingly, git checkout foo will not work if the working copy is in a directory named foo; however, both git checkout HEAD foo and git checkout ./foo will:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Upvotes: 42

Abhishek Dwivedi
Abhishek Dwivedi

Reputation: 7416

This is a very simple step. Checkout file to the commit id we want, here one commit id before, and then just git commit amend and we are done.

# git checkout <previous commit_id> <file_name>
# git commit --amend

This is very handy. If we want to bring any file to any prior commit id at the top of commit, we can easily do.

Upvotes: 11

saber tabatabaee yazdi
saber tabatabaee yazdi

Reputation: 4959

if you commit a wrong file in your last commits follow the instruction :

  1. open source tree, change to this commit

open source tree

  1. change the lines and find your commit that the wrong file sent as commit

enter image description here

  1. you can see the list of your changes in that commit list of files in the source tree
  2. select it and then click on ... buttons right-hand side ... click reverse file
  3. then you can see it on file status tab at the bottom left-hand side then click unstage:

file status tab

  1. open your visual studio code and revert back by committing your removed files
  2. after them all, you can see results in your last commit in the source tree

enter image description here

Upvotes: 6

Nir M.
Nir M.

Reputation: 159

You can do it in 4 steps:

  1. revert the entire commit with the file you want to specifically revert - it will create a new commit on your branch
  2. soft reset that commit - removes the commit and moves the changes to the working area
  3. handpick the files to revert and commit them
  4. drop all other files in your work area

What you need to type in your terminal:

  1. git revert <commit_hash>
  2. git reset HEAD~1
  3. git add <file_i_want_to_revert> && git commit -m 'reverting file'
  4. git checkout .

good luck

Upvotes: 10

Peter V. M&#248;rch
Peter V. M&#248;rch

Reputation: 15967

Many suggestions here, most along the lines of git checkout $revision -- $file. A couple of obscure alternatives:

git show $revision:$file > $file

And also, I use this a lot just to see a particular version temporarily:

git show $revision:$file

or

git show $revision:$file | vim -R -

(OBS: $file needs to be prefixed with ./ if it is a relative path for git show $revision:$file to work)

And the even more weird:

git archive $revision $file | tar -x0 > $file

Upvotes: 23

Chris Halcrow
Chris Halcrow

Reputation: 31980

If you're using Git Extensions and you only want to revert to the parent commit for the file, you can select the commit that contains the changes you want to revert, then select the 'Diff' tab in the details pane, right-click the file you want to revert, then 'Reset file(s) to' ...., then 'A' (the parent)

Upvotes: 2

Gulshan Maurya
Gulshan Maurya

Reputation: 1030

First Reset Head For Target File

git reset HEAD path_to_file

Second Checkout That File

git checkout -- path_to_file

Upvotes: 28

desmond13
desmond13

Reputation: 3149

For me none of the reply seemed really clear and therefore I would like to add mine which seems super easy.

I have a commit abc1 and after it I have done several (or one modification) to a file file.txt.

Now say that I messed up something in the file file.txt and I want to go back to a previous commit abc1.

1.git checkout file.txt : this will remove local changes, if you don't need them

2.git checkout abc1 file.txt : this will bring your file to your wanted version

3.git commit -m "Restored file.txt to version abc1" : this will commit your reversion.

  1. git push : this will push everything on the remote repository

Between the step 2 and 3 of course you can do git status to understand what is going on. Usually you should see the file.txt already added and that is why there is no need of a git add.

Upvotes: 18

Francis Bacon
Francis Bacon

Reputation: 4785

Here is my way.

a) In Android Studio, open the file.

b) git -> Show History, find the previous commit I want to revert to. Get the commit_id (i.e. commit hash).

c) git checkout commit_id file_path

Upvotes: 3

Vince
Vince

Reputation: 3344

Many answers here claims to use git reset ... <file> or git checkout ... <file> but by doing so, you will loose every modifications on <file> committed after the commit you want to revert.

If you want to revert changes from one commit on a single file only, just as git revert would do but only for one file (or say a subset of the commit files), I suggest to use both git diff and git apply like that (with <sha> = the hash of the commit you want to revert) :

git diff <sha>^ <sha> path/to/file.ext | git apply -R

Basically, it will first generate a patch corresponding to the changes you want to revert, and then reverse-apply the patch to drop those changes.

Of course, it shall not work if reverted lines had been modified by any commit between <sha1> and HEAD (conflict).

Upvotes: 14

TheCodeArtist
TheCodeArtist

Reputation: 22507

git-aliases, awk and shell-functions to the rescue!

git prevision <N> <filename>

where <N> is the number of revisions of the file to rollback for file <filename>.
For example, to checkout the immediate previous revision of a single file x/y/z.c, run

git prevision -1 x/y/z.c

How git prevision works?

Add the following to your gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

The command basically

  • performs a git log on the specified file and
  • picks the appropriate commit-id in the history of the file and
  • executes a git checkout to the commit-id for the specified file.

Essentially, all that one would manually do in this situation,
wrapped-up in one beautiful, efficient git-alias - git-prevision

Upvotes: 23

foxxtrot
foxxtrot

Reputation: 11412

You can use any reference to a git commit, including the SHA-1 if that's most convenient. The point is that the command looks like this:

git checkout [commit-ref] -- [filename]

Upvotes: 441

cmcginty
cmcginty

Reputation: 117096

Here's how rebase works:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Assume you have

---o----o----o----o  master
    \---A----B       <my branch>

The first two commands ... commit git checkout git rebase master

... check out the branch of changes you want to apply to the master branch. The rebase command takes the commits from <my branch> (that are not found in master) and reapplies them to the head of master. In other words, the parent of the first commit in <my branch> is no longer a previous commit in the master history, but the current head of master. The two commands are the same as:

git rebase master <my branch>

It might be easier to remember this command as both the "base" and "modify" branches are explicit.

. The final history result is:

---o----o----o----o   master
                   \----A'----B'  <my branch>

The final two commands ...

git checkout master
git merge <my branch>

... do a fast-forward merge to apply all <my branch> changes onto master. Without this step, the rebase commit does not get added to master. The final result is:

---o----o----o----o----A'----B'  master, <my branch>

master and <my branch> both reference B'. Also, from this point it is safe to delete the <my branch> reference.

git branch -d <my branch>

Upvotes: 34

Damien Diederen
Damien Diederen

Reputation: 2474

Note, however, that git checkout ./foo and git checkout HEAD ./foo are not exactly the same thing; case in point:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(The second add stages the file in the index, but it does not get committed.)

Git checkout ./foo means revert path ./foo from the index; adding HEAD instructs Git to revert that path in the index to its HEAD revision before doing so.

Upvotes: 19

shah1988
shah1988

Reputation: 2684

In order to go to a previous commit version of the file, get the commit number, say eb917a1 then 

git checkout eb917a1 YourFileName

If you just need to go back to the last commited version

git reset HEAD YourFileName
git checkout YourFileName

This will simply take you to the last committed state of the file

Upvotes: 12

ModernIncantations
ModernIncantations

Reputation: 401

In the case that you want to revert a file to a previous commit (and the file you want to revert already committed) you can use

git checkout HEAD^1 path/to/file

or

git checkout HEAD~1 path/to/file

Then just stage and commit the "new" version.

Armed with the knowledge that a commit can have two parents in the case of a merge, you should know that HEAD^1 is the first parent and HEAD~1 is the second parent.

Either will work if there is only one parent in the tree.

Upvotes: 25

Aristotle Pagaltzis
Aristotle Pagaltzis

Reputation: 118069

I have to plug EasyGit here, which is a wrapper to make git more approachable to novices without confusing seasoned users. One of the things it does is give more meanings to git revert. In this case, you would simply say:

eg revert foo/bar foo/baz

Upvotes: 22

Amos Folarin
Amos Folarin

Reputation: 2179

git checkout ref|commitHash -- filePath

e.g. 

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

Upvotes: 11

Greg Hewgill
Greg Hewgill

Reputation: 994301

git checkout -- foo

That will reset foo to HEAD. You can also:

git checkout HEAD^ foo

for one revision back, etc.

Upvotes: 388

mustafakyr
mustafakyr

Reputation: 91

Use git log to obtain the hash key for specific version and then use git checkout <hashkey>

Note: Do not forget to type the hash before the last one. Last hash points your current position (HEAD) and changes nothing.

Upvotes: 9

Ron DeVera
Ron DeVera

Reputation: 14644

If you know how many commits you need to go back, you can use:

git checkout master~5 image.png

This assumes that you're on the master branch, and the version you want is 5 commits back.

Upvotes: 104

CDR
CDR

Reputation: 8408

And to revert to last committed version, which is most frequently needed, you can use this simpler command.

git checkout HEAD file/to/restore

Upvotes: 160

Related Questions