I want to revert changes made by a particular commit to a given file only.
Can I use git revert command for that?
Any other simple way to do it?
- Duplicate of stackoverflow.com/questions/215718/…koppor– koppor2016-12-09 15:15:24 +00:00Commented Dec 9, 2016 at 15:15
- Strange... why the change after all those years?VonC– VonC2017-09-05 12:08:45 +00:00Commented Sep 5, 2017 at 12:08
Add a comment |
9 Answers
The cleanest way I've seen of doing this is described here
git show some_commit_sha1 -- some_file.c | git apply -R Show the change and reverse it. Similar to VonC's response but using git show and git apply.
14 Comments
Mark Edington
Nicely done. The script solution is overkill for this. Why can't there just be git revert sha-1 filename ?
Kedar Mhaswade
This works on my Mac, but on Windows (under Cygwin) it gives me:
fatal: unrecognized input
angularsen
Just a tip, I almost always have to add the
-3 flag to git apply for three-way merge when the patch fails, since I am usually correcting a change a bit back in time.
Warpling
Maybe obvious to most but ensure
some_file.c includes the path to the file if there is one otherwise you'll silently patch nothing :)
manpatha
doesn't work for a binary file. Nevertheless, I copied original file back and did git add/git commit --amend.
|
Assuming it is ok to change the commit history, here's a workflow to revert changes in a single file in an earlier commit:
For example, you want to revert changes in 1 file (badfile.txt) in commit aaa222:
aaa333 Good commit aaa222 Problem commit containing badfile.txt aaa111 Base commit Rebase on the base commit, amend the problem commit, & continue.
1) Start interactive rebase:
git rebase -i aaa111 2) Mark the problem commit for edit in the editor by changing pick to e (for edit):
e aaa222 pick aaa333 3) Revert changes to the bad file:
git show -- badfile.txt | git apply -R 4) Add the changes & amend the commit:
git add badfile.txt git commit --amend 5) Finish the rebase:
git rebase --continue 
4 Comments
angularsen
Just want to point out that this assumes you can edit the git history. Some answers above create a new commit that reverses the particular change without editing the history, which is not always possible/allowed.
mraxus
Fantastic. This was exactly what I was looking for. I had this idea already, but got confused when doing the interactive rebase that the files when doing the
edit was not showing as changed. But the git show -- badfile.txt | git apply -R gave the answer I needed <3
Linda Lawton - DaImTo
if i understand this git apply -R removes the commit on that file setting it back to the original changed state?
Amr
for android studio users, you can right click the file that you want to change, and click rebase and choose the branch that has the good code (probably develop) and click accept theirs to fetch all changes from their and ignore your changes.
Much simpler:
git reset HEAD^ path/to/file/to/revert then
git commit --amend and then
git push -f the file is gone and commit hash, message, etc is the same.
2 Comments
Kevin
For completeness, do you need a
git checkout -- path/to/file/to/revert step? Also, it is not true that the hash is the same afterwards, right? The last sentence might be better as something like: "The result is that the last commit is replaced by a new one that differs only in that it does not contain the changes to the reverted file."
Forrest
@Kevin you're probably right. I'll have to double check that last line, but looking back at this from a couple years ago I'd be surprised if the commit hash is unchanged.
If you'd like to reset the changes on a file from your last commit, this is what I'm usually using. I think this is the simplest solution.
Please note that the file will be added to the staging area.
git checkout <prev_commit_hash> -- <path_to_your_file> Hope it helps :)
4 Comments
Preston McCormick
This is the way to go if you aren't looking to rewrite history. I've been using this to cleanup files I didn't really need to touch prior to a squash merge. Then the churn gets paved over anyway.
vpzomtrrfrt
This will revert all the changes to the file since that commit, not a single commit
Purgoufr
Correct words are "previous commit hash" not current commit. Thank you @Gabeeka
sandwood
This should be the accepted and most rated answer.
git revert is for all file contents within a commits.
For a single file, you can script it:
#!/bin/bash function output_help { echo "usage: git-revert-single-file <sha1> <file>" } sha1=$1 file=$2 if [[ $sha1 ]]; then git diff $sha1..$sha1^ -- $file | patch -p1 else output_help fi (From the git-shell-scripts utilities from smtlaissezfaire)
Note:
another way is described here if you have yet to commit your current modification.
git checkout -- filename git checkout has some options for a file, modifying the file from HEAD, overwriting your change.
Dropped.on.Caprica mentions in the comments:
You can add an alias to git so you can do
git revert-file <hash> <file-loc>and have that specific file be reverted.
See this gist.
[alias] revert-file = !sh /home/some-user/git-file-revert.sh 
2 Comments
AlbertEngelB
Just to add to the discussion here, you can add an alias to git so you can do
git revert-file <hash> <file-loc> and have that specific file be reverted. I lifted from this answer (though I had to make a couple edits to work correctly). You can find a copy of my .gitconfig and edited script here: gist.github.com/droppedoncaprica/5b67ec0021371a0ad438
VonC
@Dropped.on.Caprica good point. I have included it in the answer for more visibility.
I would simply use the --no-commit option to git-revert and then remove the files you don't want reverted from the index before finally committing it. Here's an example showing how to easily revert just the changes to foo.c in the second most recent commit:
$ git revert --no-commit HEAD~1 $ git reset HEAD $ git add foo.c $ git commit -m "Reverting recent change to foo.c" $ git reset --hard HEAD The first git-reset "unstages" all files, so that we can then add back just the one file we want reverted. The final git-reset --hard gets rid of the remaining file reverts that we don't want to keep.
Comments
git reset HEAD^ path/to/file/to/revert/in/commit The above command will take file out of commit, but it will reflect in git status.
git checkout path/to/file/to/revert/in/commit The above command will revert the changes (as a result you get file same as HEAD).
git commit (Pass --amend to amend commit.)
git push With this, the file which is already in the commit is removed and reverted.
The above steps should be followed from the the branch where the commit is made.
Comments
You can follow this procedure:
git revert -n <*commit*>(-nrevert all the changes but won't commit them)git add <*filename*>(name of the file/s you want to revert & commit)git commit -m 'reverted message'(add a message for reverting)- after committing discard the other files changes so the files stay updated with the changes you committed before the revert
Comments
Start an interactive rebase to modify the latest commit:
git rebase -i HEAD~1Change the
picktoeditfor the commit you want to modify:edit <commit-hash> Your commit messageRemove the file from the commit while keeping it in the working directory:
git rm --cached path/to/unwanted_fileThis command removes the file from the staging area but keeps it in the working directory.
Amend the commit:
git commit --amendThis will open the commit message editor. You can keep the same commit message.
Continue the rebase process:
git rebase --continueForce push the changes to the remote repository:
git push origin branch-name --force
I've used those steps a few times, especially when I committed large files I did not want to find in the repo. Be sure to sync with your colleagues as you will have to force push the modified commit that rewrite history
