Is there a way to go through different commits on a file. Say I modified a file 5 times and I want to go back to change 2, after I already committed and pushed to a repository.
In my understanding the only way is to keep many branches, have I got that right? If I'm right I'm gonna have hundreds of branches in a few days, so I'm probably not understanding it really.
Could anyone clear that up please?
Let's start with a qualitative description of what we want to do (much of this is said in Ben Straub's answer). We've made some number of commits, five of which changed a given file, and we want to revert the file to one of the previous versions. First of all, git doesn't keep version numbers for individual files. It just tracks content - a commit is essentially a snapshot of the work tree, along with some metadata (e.g. commit message). So, we have to know which commit has the version of the file we want. Once we know that, we'll need to make a new commit reverting the file to that state. (We can't just muck around with history, because we've already pushed this content, and editing history messes with everyone else.)
So let's start with finding the right commit. You can see the commits which have made modifications to given file(s) very easily:
git log path/to/file
If your commit messages aren't good enough, and you need to see what was done to the file in each commit, use the -p/--patch option:
git log -p path/to/file
Or, if you prefer the graphical view of gitk
gitk path/to/file
You can also do this once you've started gitk through the view menu; one of the options for a view is a list of paths to include.
Either way, you'll be able to find the SHA1 (hash) of the commit with the version of the file you want. Now, all you have to do is this:
# get the version of the file from the given commit
git checkout <commit> path/to/file
# and commit this modification
git commit
(The checkout command first reads the file into the index, then copies it into the work tree, so there's no need to use git add to add it to the index in preparation for committing.)
If your file may not have a simple history (e.g. renames and copies), see VonC's excellent comment. git can be directed to search more carefully for such things, at the expense of speed. If you're confident the history's simple, you needn't bother.
-C or --find-copies-harder to detect renames and copies, plus --follow to continue listing the history of a file beyond renames? Given the emphasis of your answer on file content, it might be good to complete it by mentioning its natural consequence: the inference aspect (see stackoverflow.com/questions/612580/…)
gitk before either - amazing!
Commented
Mar 25, 2013 at 21:49
HEAD~3 will work, if the commit you want is the one three before HEAD. In general you may not be totally confident, so I covered how to figure out which commit you actually want.
Git is very flexible. You shouldn't need hundreds of branches to do what you are asking. If you want to revert the state all the way back to the 2nd change (and it is indeed a change that was already committed and pushed), use git revert. Something like:
git revert a4r9593432
where a4r9593432 is the starting characters of the hash of the commit you want to back out.
If the commit contains changes to many files, but you just want to revert just one of the files, you can use git reset (the 2nd or 3rd form):
git reset a4r9593432 -- path/to/file.txt
# the reverted state is added to the staging area, ready for commit
git diff --cached path/to/file.txt # view the changes
git commit
git checkout HEAD path/to/file.txt # make the working tree match HEAD
But this is pretty complex, and git reset is dangerous. Use git checkout <hash> <file path> instead, as Jefromi suggests.
If you just want to view what the file looked like in commit x, you can use git show:
git show a4r9593432:path/to/file.txt
For all of the commands, there are many ways to refer to a commit other than via the commit hash (see Naming Commits in the Git User Manual).
git revert just back out one change though -- not "revert the state all the way back to the 2nd change"?
Commented
Apr 29, 2010 at 0:44
get revert to back out all of the commits to a certain point in time. Or you can do something like what you suggest in your answer with git diff and git apply.
Commented
Apr 29, 2010 at 2:03
git revert is not for one specific file, but for the whole repository.
Commented
Mar 4, 2015 at 13:01
Git doesn't think in terms of file versions. A version in git is a snapshot of the entire tree.
Given this, what you really want is a tree that has the latest content of most files, but with the contents of one file the same as it was 5 commits ago. This will take the form of a new commit on top of the old ones, and the latest version of the tree will have what you want.
I don't know if there's a one-liner that will revert a single file to the contents of 5 commits ago, but the lo-fi solution should work: checkout master~5, copy the file somewhere else, checkout master, copy the file back, then commit.
You can take a diff that undoes the changes you want and commit that.
E.g. If you want to undo the changes in the range from..to, do the following
git diff to..from > foo.diff # get a reverse diff
patch < foo.diff
git commit -a -m "Undid changes from..to".
git diff to..from path/to/file). To apply a patch, you should use git apply instead of patch. And there's no need to use a patch at all in this case; see my answer.
git revert would do. A file- and commit- specific patch is a far more precise and semantically correct change.
Commented
May 4, 2015 at 23:51
Extracted from here: http://git.661346.n2.nabble.com/Revert-a-single-commit-in-a-single-file-td6064050.html
git revert <commit>
git reset
git add <path>
git commit ...
git reset --hard # making sure you didn't have uncommited changes earlier
It worked very fine to me.
git revert, git reset and git add, then I searched before commiting to see if I was doing right. +1 for your answer!
Commented
Nov 17, 2015 at 12:07