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

Question

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)?

Hydromancy

After revert, don't forget --cached when checking git diff. link – Connote

Answer 1

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.]

Testator

@shadowhand: Is there a way to reverse that, so it's the version right after? – Dianthus

@aliteralmind: No, unfortunately the Git history shortcut notation only goes backwards in history. – Testator

If you're going to use a branch name for abcde (e.g. develop) you'll want git checkout develop -- file/to/restore (note the double dash) – Shrive

@aliteralmind: Actually, yes, there's a way to do it: "git log --reverse -1 --ancestry-path yourgitrev..master" and then use the appropriate options to just get the git rev. --ancestry-path will "draw a line" between two commits and -1 will show you just one version, and --reverse will ensure the first entry emitted is the oldest one. – Claqueur

Be sure to checkout the revision hash that still has the file for which you're looking. If it was deleted in a revision, go to the hash at least one earlier than that. – Hinshelwood

To automate the entire process of searching through the history of a file and checking out the appropriate commit-id in one git command, use git prevision. – Kohler

If you want to delete your changes on this specific file, you can use git checkout path/to/file. If you don't specify a hash, HEAD is used. – Croy

Personally I find HEAD^ easier to type than HEAD~1 :) – Dagmar

Can we pass space-separated file-list right after the commit id? – Spinelli

@Dagmar Or use @^ instead of HEAD^. – Bisexual

I also just realized that you have to be on the branch you pushed TO, not from. – Critic

The command above worked for me. However, auto-complete suggested a capitalized version of the file, and that produced "FILE1/TO/RESTORE did not match any file(s) known to git." Cases need to match what git has in the repository. – Embryology

How can I check 2 or more files? – Secundines

I was going to +1 you but clearly I have been here at least once before :D A very useful answer that maybe I should memorise! – Nostalgia

Note for windows users: A relative path was not sufficient, I had to include the full path e.g. /d/Repos/MyRepo/Folder1/Folder2/FileIWantToCheckout.json – Mammal

Incorrect answer, this does not REVERT. This only changes the file so the contents are the exact same as the commit you give it, you have to commit again for this to actually be implemented. – Shopkeeper

Use git checkout 5364aee~1 path/to/dir/* to restore a whole directory of files to their version prior to 5364aee. – Edentate

Can anyone explain the sidenote? Why is there a difference between switching between branches and discarding changes in the working directory? Doesn't switching a branch discard changes if the file names match? – Zedekiah

@MarkBolster: The form of the command shown in the answer uses git checkout -- for restoring specific file contents. Of course, the other completely different use of git checkout is for switching branches. It's unclear to me why somebody chose to use the same command name for two completely different things. (And no, switching branches never discards changes, if you try to do that, git will complain and ask you what you would like to do with the changes that would be overwritten.) – Testator

this literally does nothing – Numerology

@GregHewgill git has recently introduced git restore, it is the more appropriate command going forward. You might want to edit that into your answer. – Induration

@tschoppi: Thanks, I'll do that when the command is no longer marked as "experimental". – Testator

I tried restoring a folder using git checkout HEAD~2 -- my_folder/* and it didn't work. – Bummer

with git restore: git restore --source <hash>~1 -- <path>. Notice the ~1 after the hash which will restore the files to the state they were at the commit before the hash's commit. – Underhanded

what does -- mean? – Incur

-- : Do not interpret any more arguments as options. – Zavala

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) couldn't agreee more!!! – Norfolk

Answer 2

You can quickly review the changes made to a file using the diff command:

git diff <commit hash> <filename>

Then to revert a specific file to that commit use the reset command:

git reset <commit hash> <filename>

You may need to use the --hard option if you have local modifications.

A good workflow for managaging waypoints is to use tags to cleanly mark points in your timeline. I can't quite understand your last sentence but what you may want is diverge a branch from a previous point in time. To do this, use the handy checkout command:

git checkout <commit hash>
git checkout -b <new branch name>

You can then rebase that against your mainline when you are ready to merge those changes:

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

Reno

'git checkout <commit hash>' command has given me back my older version of the project exactly this for which I was searching Thanks Chris. – Boycott

'git reset <commit hash> <filename>' didn't change my specific file I wanted to change. Is there a way to checkout the version of the file, specifically, and not checkout the entire project? – Lxx

To revert the file git checkout <commit hash> <filename> worked better for me than git reset – Cabstand

I wanted an early version of a single file because I had overwritten 150 lines with a badly chosen copy/paste. git checkout <commit hash> <filename> worked for me. This should not be the accepted answer, IMHO. git reset did not. – Idomeneus

Git reset without hard option does not modify working copy, which is why it didn't have any effect. Hard reset causes file to look exactly as in repository in specified commit, and WILL DISCARD your local changes, if any. – Reimer

cannot use git reset to reset single file, you will get an error fatal: Cannot do hard reset with paths – Taima

What slier said: you cannot git reset --hard <commit hash> <filename>. This will error with fatal: Cannot do hard reset with paths. What Motti Strom said: use git checkout <commit hash> <filename> – Andrews

@HawkeyeParker uhh yes, we see that. Thanks for summarizing. – Leung

@Chris, fatal: Cannot do hard reset with paths. – Counterintelligence

I do not understand this, but thanks anyway, Chris Lloyd, this is very neat. – Henryhenryetta

@MottiStrom git checkout is not the same as git reset not even close. Don't why everyone is using them interchangably here. Git checkout simply applies changes from some commit but git reset "clears" changes without the need for additional commit – Vortex

"You may need to use the --hard option if you have local modifications." No, you can't. Git will return error saying "fatal: Cannot do hard reset with paths." – Vortex

In vim, you can do it in cmdline: :!git checkout <hash-yanked-from-diffview> % to revert this file to specific commit. – Repute

Answer 3

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]

Acetylide

What is the difference between this answer, which has --, and the accepted one which does not? – Underneath

In git, a ' -- ' before the file list tells git that all the next arguments should be interpreted as filenames, not as branch-names or anything else. It's a helpful disambiguator sometimes. – Acetylide

The '--' is not only a git convention, but something you find in various places in on the *nix commandline. rm -- -f (remove a file named -f) seems to be the canonical example. More detail here – Andrews

Just add to what @HawkeyeParker said, rm command uses getopt(3) to parse its arguments. getopt is the command to parse command arguments. gnu.org/software/libc/manual/html_node/Getopt.html – Basil

@HawkeyeParker you mean the filename is -f?! I'm assuming that's a very rare case right? – Twelvemo

@Acetylide You said -- should be interpreted as files but after seeing Greg Hewgill 2nd answer below I'm confused.he suggests git checkout -- foo <-- In his example is foo a filename? or it's just something tree-ish? I mean you can't checkout to a fileName! It's meaningless – Twelvemo

@Honey Yes, that's what I mean, and yeah, probably not common at all. I've seen that example in various places, maybe just to make it sortof memorable: rm -f is well-known to be scary/dangerous. But, the point is, in *nix a file name can start with a '-', and this will confuse various commandline interpreters which, when they see a '-', expect a command option to follow. It could be any file starting with '-'; e.g., "-mySpecialFile". – Andrews

@Honey #4715874 – Andrews

slightly worrying that nobody knows what ' -- ' really is.... well here it is unix.stackexchange.com/a/11382/73790 "[--] is used in most Bash built-in commands and many other commands to signify the end of command options, after which only positional arguments are accepted". – Generous

Answer 4

git checkout -- foo

That will reset foo to HEAD. You can also:

git checkout HEAD^ foo

for one revision back, etc.

Testator

I'd suggest using syntax git checkout -- foo to avoid any mistakes if foo is anything special (like a directory or a file called -f). With git, if you're unsure, always prefix all files and directories with the special argument --. – Heft

An additional note to Mikko's comment: -- is not a git command and not special to git. It is a bash built-in to signify the end of command options. You can use it with many other bash commands too. – Advisable

@Advisable it's also neither specific to bash nor a shell feature at all. It's a convention implemented in many different commands (and supported by getopt). – Testator

No, -- is not a builtin special word in bash. But it is a common convention supported by many commandline parsers and used by many CLIs, including git. – Vedavedalia

Windows treats ^ as an escape character, so git checkout HEAD~1 foo works for me. – Nyctaginaceous

Answer 5

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

Mcmillian

I suppose it's a dead thread kind of thing, but this is the correct "modern" answer. – Baumgardner

This is best answer as of 2021. – Supersaturated

and... the correct answer is in position 5, with all sorts of used-to-be-correct upvoted answers in the lead. Not a shining example of Stackoverflow's technical curating capability (no it is not up to the community to "upvote this answer 7500 times" to have it appear first in default order). – Bolshevism

you can use -s commit instead of --source=commit – Cadency

@JLPeyret Worse, the top voted answer gets more votes per unit time than this one, so it will never overtake as things are going now. BUT, this answer looks on track to overtake the second-most upvoted answer in just 250 years, and maybe when it's second it might start to gather more upvotes than the first? – Lien

@JLPeyret I edited the main answer to accomodate this information. Hopefully, it sticks. – Sopor

Maybe this is a dumb question, but what is the difference between file1/to/restore and file2/to/restore? Why are we listing two files? Is this for updating two files to a previous version? – Onyx

It just shows that this command is not limited to restoring a single file/directory at once - you can provide a list of files/directories that you want to restore to a previous version (e.g. file1/to/restore and file2/to/restore). – Mcmillian

Answer 6

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

git checkout HEAD file/to/restore

Knowing

what is the difference between this (git checkout HEAD file/to/restore) and git reset --hard file/to/restore ??? – Canton

1) easier to remember more general way 2) no worries to press Enter before entering file name – Noland

This is a more valid answer to the 'real' question. – Trample

Answer 7

I had the same issue just now and I found this answer easiest to understand (commit-ref is the SHA value of the change in the log you want to go back to):

git checkout [commit-ref] [filename]

This will put that old version in your working directory and from there you can commit it if you want.

Maitilde

Answer 8

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.

Bicknell

Answer 9

I think I've found it....from http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Sometimes you just want to go back and forget about every change past a certain point because they're all wrong.

Start with:

$ git log

which shows you a list of recent commits, and their SHA1 hashes.

Next, type:

$ git reset --hard SHA1_HASH

to restore the state to a given commit and erase all newer commits from the record permanently.

Cynic

Git never removes anything. Your old commits are still there but unless there is a branch tip pointing at them they are not reachable anymore. git reflog will still show them until you clean your repository with git-gc. – Jobholder

@Bombe: Thank you for the information. I had checked out an old version of a file. After reading your comment, I was able to use "gitref" to lookup the partial SHA1 hash, and use "checkout" to get back to the most recent version. Other git users might find this information helpful. – Immotile

possibly followed by a git push --force – Meaningless

If after the above "git reset --hard SHA1_HASH", you do a "git status" and see Untracked files, and you want to get rid of them too. Run "git clean --force -d" – Holmic

If you have uncommitted changes, you will loose them if do a git reset --hard – Ptisan

i found this article that helped me get passed this issue: blogs.gnome.org/diegoe/2009/03/18/… it seemed to work great and is very similar to this particular answer. – Thieve

Doesn't this reset ALL files? Not just a specific file? – Anderegg

@Jobholder - "Git never removes anything. Your old commits are still there but unless there is a branch tip pointing at them they are not reachable anymore." - but commits like this are pruned after some set time, so "Git never removes anything" is untrue. – Plasmo

@Bombe: git reflog will still show them until you clean your repository with git-gc – wrong. Reflog is a reference too and referenced commits will never be removed by git-gc. If you need to clean them right now, you have to do git reflog expire --expire-unreachable=now --all – Comte

@NickVolynkin Your information is wrong; git gc will sometimes remove commits from the reflog. As the git-gc man page says, the configuration variables gc.reflogExpire and gc.reflogExpireUnreachable set age thresholds for deletion from the reflog. Entries older than those values will be deleted when git gc is run. The values default to 90 days and 30 days for reachable and unreachable commits. – Toddtoddie

Answer 10

This worked for me:

git checkout <commit hash> file

Then commit the change:

git commit -a

Susanasusanetta

Answer 11

You have to be careful when you say "rollback". If you used to have one version of a file in commit $A, and then later made two changes in two separate commits $B and $C (so what you are seeing is the third iteration of the file), and if you say "I want to roll back to the first one", do you really mean it?

If you want to get rid of the changes both the second and the third iteration, it is very simple:

$ git checkout $A file

and then you commit the result. The command asks "I want to check out the file from the state recorded by the commit $A".

On the other hand, what you meant is to get rid of the change the second iteration (i.e. commit $B) brought in, while keeping what commit $C did to the file, you would want to revert $B

$ git revert $B

Note that whoever created commit $B may not have been very disciplined and may have committed totally unrelated change in the same commit, and this revert may touch files other than file you see offending changes, so you may want to check the result carefully after doing so.

Blaspheme

I did this, but then a "git log file" would say that I was on the original commit, HEAD. It seemed that "git checkout" was failing. However, a git status showed that the file was actually changed and and a "git diff --staged file" would show the actual changes. Also, a "git status" showed the file changed as well. So don't use "git log" here to track which files changed. – Aspergillus

@FrederickOllinger - that behavior makes sense, because git log shows commits, and you haven't committed the change (the reversion). If you do git commit after that revert, then git log will show the change. – Canales

Answer 12

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

Gestate

Answer 13

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

Byars

Answer 14

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>

Peta

Answer 15

First Reset Head For Target File

git reset HEAD path_to_file

Second Checkout That File

git checkout -- path_to_file

Lustick

+1, though not sure of the intent of resetting HEAD. It may or may not be needed. In my situation i only wanted to revert one particular file to the version in repository (which keeping remaining local changes intact. Just running the second step above was sufficient for me – Tremor

Yes I only need to run the 2nd command. Like --> shellhacks.com/git-revert-file-to-previous-commit – Szeged

Answer 16

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.

Dimpledimwit

Shouldn't that file be stages automatically already? I would rather be interested in how to check out without auto-staging the file. Of course, I can manually unstage, too, but it would be interesting to know how to avoid auto-staging. – Ender

Answer 17

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

Kohler

Answer 18

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

Homologous

This is a nice alternative if you're not sure which commit version you want and need to "peek" around without overwriting your working directory. – Acquittal

Answer 19

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

Magnusson

It should be eg revert --in REVISON -- FILENAME. The --in is important. For the Windows users out there: Open git bash. Execute echo %PATH. The first path should be in your user directory ending with bin. Create that path. Store eg there. Name it eg. Not eg.txt. – Surreptitious

Answer 20

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.

Seaver

Answer 21

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.

4. 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.

Georginageorgine

OK so I guess steps 1. and 2. are mutually exclusive: if abc1 is your last commit there is no need for 2. and if there were other commits after abc1 you can directly do 2. – Monde

Answer 22

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

Buckner

` Updates were rejected because the tip of your current branch is behind hint: its remote counterpart. Integrate the remote changes ` – Fitzwater

Answer 23

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).

Dinner

That should be the approved answer. May I suggest a slightly simplified version: git show -p <sha> path/to/file.ext|git apply -R – Disyllable

you can use <sha>^! instead of <sha>^ <sha> – Iinde

Answer 24

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

Haslet

Answer 25

git checkout ref|commitHash -- filePath

e.g.

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

Precondemn

Answer 26

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.

Dippold

Thanks, Abhishek. Based on your answer, I made this Shellscipt: gist.github.com/ivanleoncz/c20033e5f4b24304cbc39e0bac1d43e8 Feel free to improve :). – Vachell

didnt work. Only seems to undo the one specified commit. Doesn't roll back all changes to that commit. – Fitzwater

Answer 27

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

Principality

doesn't that revert ALL changes? – Liking

@Liking Yes, but the subsequent reset undoes the revert of all changes. The problem is that git-revert only operates on the whole repo, so to compensate we have to undo everything else. – Angelia

I recommend using: 1. git revert --no-commit <commit_hash> 2. git reset HEAD This saves an extra commit floating around and does all the changes only in your working directory. – Angelia

@greg-hewgill 's answer is better and spot on. This one is lousy and should not be used. – Tamarin

This is exactly what is needed for a true revert of specific files. I needed to undo changes to a few files from an earlier commit that had already been pushed to the remote repository. I reverted, reset, and committed the result: git revert _oldcommit_ --no-commit git reset -- _unchanged1_ _unchanged2_ ... git commit -m "branch without changes to specific files" The new branch tip reflected all changes except the reverted files. – Scotch

@DanielTranca Greg Hewgill's answer is not better if you want to revert changes. There may be intervening commits that changed other portions of the files. Nir M.'s answer addresses reverting only what was changed to the specific files in a single commit; his is the better answer to reverting, which I confirmed by arriving at equivalent steps myself. – Scotch

Answer 28

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.

Putrescent

Answer 29

Obviously someone either needs to write an intelligible book on git, or git needs to be better explained in the documentation. Faced with this same problem I guessed that

cd <working copy>
git revert master

would undo the last commit which is seemed to do.

Ian

Alsatia

Answer 30

git revert <hash>

Will revert a given commit. It sounds like you think git revert only affects the most recent commit.

That doesn't solve your problem, if you want to revert a change in a specific file and that commit changed more than that file.

Gospodin

Answer 31

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

1. open source tree, change to this commit

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

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

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

Coenesthesia

Answer 32

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

Clodhopping

How is your answer improving on this 5 years old one? – Inveteracy

My answer improves on simplicity, goes straight to the point and addresses use case more probable for git novices. Originally I wanted to answer here #37973253 but it is closed as duplicate, so I think it can be useful at least here. Thank you for feedback. – Clodhopping

From the question : "... its previous revision at a specific commit hash ...". Come on. – Inveteracy

You improved your answer indeed. Upvoted for the effort. 7695 more and you're on top ;-) – Inveteracy

Answer 33

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

Crippling

Your way is exactly the way of the accepted answer. – Tarragona

Answer 34

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)

Ultramontanism

Answer 35

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`!

Abuttal

Answer 36

• 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

Stunner

Answer 37

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.

Colwin