Undo working copy modifications of one file in Git?

After the last commit, I modified a bunch of files in my working copy, but I want to undo the changes to one of those files, as in reset it to the same state as the most recent commit.

However, I only want to undo the working copy changes of just that one file alone, nothing else with it.

  • In short, what are the advantages of git and mercurial over subversion?
  • How should framework/library files be treated in git?
  • Is 'pull' a synonym for 'clone' in a Mercurial source-control repository?
  • GIT: Reverting last commit?
  • Why does my git origin want to remove all my pushed changes?
  • git pull and git push in one go
  • How do I do that?

  • JGit http clone repository but the repository can't pull
  • Force merge files while rebasing with master: GIT
  • Rebase a GitHub pull request on top of my newer local commits
  • How to replace an eclipse project with latest version from head using EGit?
  • editing commits with git rebase
  • git for mercurial like git-svn
  • 11 Solutions collect form web for “Undo working copy modifications of one file in Git?”

    You can use

    git checkout -- file
    

    You can do it without the -- (as suggested by nimrodm), but if the filename looks like a branch or tag (or other revision identifier), it may get confused, so using -- is best.

    You can also check out a particular version of a file:

    git checkout v1.2.3 -- file         # tag v1.2.3
    git checkout stable -- file         # stable branch
    git checkout origin/master -- file  # upstream master
    git checkout HEAD -- file           # the version from the most recent commit
    git checkout HEAD^ -- file          # the version before the most recent commit
    
    git checkout <commit> <filename>
    

    I used this today because I realized that my favicon had been overwritten a few commits ago when I upgrated to drupal 6.10, so I had to get it back. Here is what I did:

    git checkout 088ecd favicon.ico
    

    Just use

    git checkout filename
    

    This will replace filename with the latest version from the current branch.

    WARNING: your changes will be discarded — no backup is kept.

    If your file is already staged (happens when you do a git add etc after the file is edited) to unstage your changes.

    Use

    git reset HEAD <file>
    

    Then

    git checkout <file>
    

    If not already staged, just use

    git checkout <file>
    

    If you want to just undo the previous commit’s changes to that one file, you can try this:

    git checkout branchname^ filename
    

    This will checkout the file as it was before the last commit. If you want to go a few more commits back, use the branchname~n notation.

    I restore my files using the SHA id, What i do is git checkout <sha hash id> <file name>

    I always get confused with this, so here is a reminder test case; let’s say we have this bash script to test git:

    set -x
    rm -rf test
    mkdir test
    cd test
    git init
    git config user.name test
    git config user.email test@test.com
    echo 1 > a.txt
    echo 1 > b.txt
    git add *
    git commit -m "initial commit"
    echo 2 >> b.txt
    git add b.txt
    git commit -m "second commit"
    echo 3 >> b.txt
    

    At this point, the change is not staged in the cache, so git status is:

    $ git status
    On branch master
    Changes not staged for commit:
      (use "git add <file>..." to update what will be committed)
      (use "git checkout -- <file>..." to discard changes in working directory)
    
        modified:   b.txt
    
    no changes added to commit (use "git add" and/or "git commit -a")
    

    If from this point, we do git checkout, the result is this:

    $ git checkout HEAD -- b.txt
    $ git status
    On branch master
    nothing to commit, working directory clean
    

    If instead we do git reset, the result is:

    $ git reset HEAD -- b.txt
    Unstaged changes after reset:
    M   b.txt
    $ git status
    On branch master
    Changes not staged for commit:
      (use "git add <file>..." to update what will be committed)
      (use "git checkout -- <file>..." to discard changes in working directory)
    
        modified:   b.txt
    
    no changes added to commit (use "git add" and/or "git commit -a")
    

    So, in this case – if the changes are not staged, git reset makes no difference, while git checkout overwrites the changes.


    Now, let’s say that the last change from the script above is staged/cached, that is to say we also did git add b.txt at the end.

    In this case, git status at this point is:

    $ git status
    On branch master
    Changes to be committed:
      (use "git reset HEAD <file>..." to unstage)
    
        modified:   b.txt
    

    If from this point, we do git checkout, the result is this:

    $ git checkout HEAD -- b.txt
    $ git status
    On branch master
    nothing to commit, working directory clean
    

    If instead we do git reset, the result is:

    $ git reset HEAD -- b.txt
    Unstaged changes after reset:
    M   b.txt
    $ git status
    On branch master
    Changes not staged for commit:
      (use "git add <file>..." to update what will be committed)
      (use "git checkout -- <file>..." to discard changes in working directory)
    
        modified:   b.txt
    
    no changes added to commit (use "git add" and/or "git commit -a")
    

    So, in this case – if the changes are staged, git reset will basically make staged changes into unstaged changes – while git checkout will overwrite the changes completely.

    If you have not yet pushed or otherwise shared your commit:

    git diff --stat HEAD^...HEAD | \
    fgrep filename_snippet_to_revert | cut -d' ' -f2 | xargs git checkout HEAD^ --
    git commit -a --amend
    

    This answers is for command needed for undoign local changes which are in multiple specific files in same or multiple folders(or directories).
    This answers specifically addresses question where a user has more than one file but the user doesn’t want to undo all local changes:

    if you have one or more files you could apply the samne command (git checkout -- file ) to
    each of those files by listing each of their location separated by
    space as in:

    git checkout -- name1/name2/fileOne.ext nameA/subFolder/fileTwo.ext
    

    mind the space abve between name1/name2/fileOne.ext nameA/subFolder/fileTwo.ext

    For multiple files in the same folder:

    If you happen to need to discard changes for all of the files in a
    certain directory, use the git checkout as follows:

    git checkout -- name1/name2/*
    

    The asterisk in the above does the trick of undoing all files at that location under name1/name2.

    And, similarly the following can undo changes in all files for
    multiple folders:

    git checkout -- name1/name2/* nameA/subFolder/*
    

    again mind the space between name1/name2/* nameA/subFolder/* in the
    above.

    Note: name1, name2, nameA, subFolder – all of these example folder names indicate the folder or package where the file(s) in question may be residing.

    For me only this one worked

    git checkout -p filename
    

    enter image description here

    If it is already committed, you can revert the change for the file and commit again, then squash new commit with last commit.

    Git Baby is a git and github fan, let's start git clone.