Remove file from latest commit

Asked 2023-09-20 20:54:45 View 479,297

How do I remove a file from the latest commit?

Answers

I think other answers here are wrong, because this is a question of moving the mistakenly committed files back to the staging area from the previous commit, without cancelling the changes done to them. This can be done like Paritosh Singh suggested:

git reset --soft HEAD^ 

or

git reset --soft HEAD~1

Then reset the unwanted files in order to leave them out from the commit (the old way):

git reset HEAD path/to/unwanted_file

Note, that since Git 2.23.0 one can (the new way):

git restore --staged path/to/unwanted_file

Now commit again, you can even re-use the same commit message:

git commit -c ORIG_HEAD  

EDIT: The easiest way to do this is to use e.g. git gui. Just select Commit => Amend Last Commit and simply uncheck the desired file from the commit and click Commit.

Answered   2023-09-20 20:54:45

  • Thanks for this. It's worth adding that if you have already pushed your earlier (wrong) commit, and now try to git push your fix up to your repo, it will complain Updates were rejected because the tip of your current branch is behind its remote counterpart.. If you're sure that you want to push them (e.g. it's your fork) then you could use the -f option to force the push, e.g. git push origin master -f. (Do not do this to an upstream repo that others are fetching from) - anyone
  • @PabloFernandez at the top of all of the answers are three tabs which allow you to control the ordering of answers: active, oldest and votes. My guess is yours is set to oldest. Switch it to votes even though the accepted answer will still be at the top, this answer will be second. - anyone
  • Is there any way to reset soft just one file from a commit? That seem to be a very useful option to have. - anyone
  • I knew this much about git reset but wanted a way to affect the existing commit "in place". I just learned about git commit -C. So for me, what I want is your exact recipe with one more step, the "new commit again" spelled out as git commit -C [hash of original HEAD commit from first step]. - anyone
  • Remember to do an actual commit, not an amend. If you do, it will be amending the previous commit. – oops - anyone

ATTENTION! If you only want to remove a file from your previous commit, and keep it on disk, read juzzlin's answer just above.

If this is your last commit and you want to completely delete the file from your local and the remote repository, you can:

  1. remove the file git rm <file>
  2. commit with amend flag: git commit --amend

The amend flag tells git to commit again, but "merge" (not in the sense of merging two branches) this commit with the last commit.

As stated in the comments, using git rm here is like using the rm command itself!

Answered   2023-09-20 20:54:45

  • you can also use git rm --cached to keep the files on disk - anyone
  • Warning to those browsing this answer: make sure you want to DELETE the file (as in gone gone gone!), not just remove it from the Commit list. - anyone
  • To add to what others say (and to make it easier to remember not to do this unless you really want to): The rm in the git command is doing what rm itself does! - anyone
  • Note that the files can still be restored, in case you changed your mind, the commit before git commit --amend is still there and can be found for example with git reflog. So it is not as bad as the other comments suggest. - anyone
  • When pushing you will need force push: git push -f if you use --amend. - anyone

As the accepted answer indicates, you can do this by resetting the entire commit. But this is a rather heavy handed approach.
A cleaner way to do this would be to keep the commit, and simply remove the changed files from it.

git reset HEAD^ -- path/to/file
git commit --amend --no-edit

The git reset will take the file as it was in the previous commit, and stage it in the index. The file in the working directory is untouched.
The git commit will then commit and squash the index into the current commit.

This essentially takes the version of the file that was in the previous commit and adds it to the current commit. This results in no net change, and so the file is effectively removed from the commit.

Answered   2023-09-20 20:54:45

  • This is a much better answer for removing just a single file, without overhauling the entire commit. - anyone
  • This is exactly the same as this answer :D stackoverflow.com/a/27340569/1623984 - anyone
  • @ThatsAMorais indeed :-). I'm wondering if this question got merged with another, and thats why I didn't see it. Or maybe I'm just blind. Either case, I think I'm inclined to leave it as based on votes it seems to be more popular (maybe people prefer the short and direct answer). - anyone
  • By all means leave it! :) We clearly had the right idea, and the purpose is to help. I think merging is a good theory. - anyone
  • Nice answer, but there is one gotcha you may need to watch out for: if you have any added or deleted files currently staged they will be added to the commit via the git commit --amend --no-edit command. Not sure why this is but it just bit me. - anyone

Existing answers are all talking about removing the unwanted files from the last commit.

If you want to remove unwanted files from an old commit (even pushed) and don't want to create a new commit, which is unnecessary, because of the action:

  1. Find the commit that you want the file to conform to using ;

git log --graph --decorate --oneline

  1. Checkout that commit using

git checkout <commit_id> <path_to_file>

you can do this multiple times if you want to remove many files.

3.

git commit -am "remove unwanted files"

4.

Find the commit_id of the commit on which the files were added mistakenly, let's say "35c23c2" here

git rebase 35c23c2~1 -i // notice: "~1" is necessary

This command opens the editor according to your settings. The default one is vim. If you want to change the global git editor, use;

git config --global core.editor <editor_name>

5.

Move the last commit, which should be "remove unwanted files", to the next line of the incorrect commit("35c23c2" in our case), and set the command as fixup:

pick 35c23c2 the first commit
fixup 0d78b28 remove unwanted files

You should be good after saving the file.

6.

To finish :

git push -f

If you unfortunately get conflicts, you have to solve them manually.

Answered   2023-09-20 20:54:45

  • If you want to actually remove the files from the repo (not the filesystem), rather than merely revert them to a previous version, then instead of step 1 do git rm --cached <file(s)>. - anyone
  • Wait you can just move commits around the interactive-rebase file at will? - anyone
  • You totally can, but you may(or may not) get conflicts. - anyone
  • This process could be made a bit easier by adding --fixup=35c23c2 to the git commit command. This will setup the commit automatically as a fixup of the required commit and so you won't need to specify it in the rebase. Additionally, if you add --autosquash to the git rebase command, git will automatically move your commit to the correct location, so you don't need to do anything in the interactive rebase - just save the result (which means you don't even need to -i flag, though I like to use it anyway to make sure everything looks as I expect). - anyone
  • didnt work, it just does nothing after doing checkout spcific commit and file - anyone

If you have not pushed the changes on the server you can use

git reset --soft HEAD~1

It will reset all the changes and revert to one commit back

If you have pushed your changes then follow steps as answered by @CharlesB

Answered   2023-09-20 20:54:45

  • -1 git reset removes changes happened file from staging area, here the change has been committed - anyone
  • OK, but I'll keep my downvote since it's not what the OP want :) sorry - anyone
  • ok its fine for me, but why opponent don't want this. What is the problem? - anyone
  • not a big deal, but because the OP wants to remove unwanted file from last commit, and it just resets to the state before committing. still you have to redo the commit. - anyone
  • @Aris use <git diff --cached> to see the changes - anyone

Removing the file using rm will delete it!

You're always adding to a commit in git rather than removing, so in this instance return the file to the state it was in prior to the first commit (this may be a delete 'rm' action if the file is new) and then re-commit and the file will go.

To return the file to some previous state:

    git checkout <commit_id> <path_to_file>

or to return it to the state at the remote HEAD:

    git checkout origin/master <path_to_file>

then amend the commit and you should find the file has disappeared from the list (and not deleted from your disk!)

Answered   2023-09-20 20:54:45

git checkout HEAD~ path/to/file
git commit --amend

Answered   2023-09-20 20:54:45

  • This is the best way to modify the last commit, the one that has not been pushed. This will reset changes in one file, effectively removing that file from the last commit. - anyone
  • This also changed the file. How to preserve local changes in the file? - anyone

I will explain to you with example.
Let A, B, C be 3 successive commits. Commit B contains a file that should not have been committed.

git log  # take A commit_id
git rebase -i "A_commit_ID" # do an interactive rebase
change commit to 'e' in rebase vim # means commit will be edited
git rm unwanted_file
git rebase --continue
git push --force-with-lease <branchName>    

Answered   2023-09-20 20:54:45

  • If the particular file is not in the last or previous commit, this is the most elegant way. I'd even say it's the most elegant way in general. I like interactive rebasing. - anyone
  • For a single commit, change noop to edit [A_commit_ID] or e [A_commit_ID] - anyone
  • @moaz-rashad THX! Yes, that's the solution! - anyone

The following will unstage just the file you intended, which is what the OP asked.

git reset HEAD^ /path/to/file

You'll see something like the following...

Changes to be committed: (use "git reset HEAD ..." to unstage)

modified: /path/to/file

Changes not staged for commit: (use "git add ..." to update what will be committed) (use "git checkout -- ..." to discard changes in working directory)

modified: /path/to/file

  • "Changes to be committed" is the previous version of the file before the commit. This will look like a deletion if the file never existed. If you commit this change, there will be a revision that reverts the change to the file in your branch.
  • "Changes not staged for commit" is the change you committed, and the current state of the file

At this point, you can do whatever you like to the file, such as resetting to a different version.

When you're ready to commit:

git commit --amend -a

or (if you've got some other changes going on that you don't want to commit, yet)

git commit add /path/to/file
git commit --amend

Answered   2023-09-20 20:54:45

  • juzzlin's answer is great, but its excessive to unstage the entire commit when you only wish to unstage one. Unstaging the whole commit can cause problems if you have currently unstaged changes on files in that commit that you do not want to lose. - anyone

You can simply try.

git reset --soft HEAD~1

and create a new commit.

However, there is an awesome software "gitkraken". which makes it easy to work with git.

Answered   2023-09-20 20:54:45

  • And just to note: after this, you'd do git commit --amend to have the file removal updated in your last commit; and afterwards, you can check it has indeed been removed with git log -1 --stat - anyone
git rm --cached <file_to_remove_from_commit_<commit_id>_which_added_file>
git commit -m "removed unwanted file from git"

will leave you the local file still. If you don't want the file locally either, you can skip the --cached option.

If all work is on your local branch, you need to keep the file in a later commit, and like having a clean history, I think a simpler way to do this could be:

git rm --cached <file_to_remove_from_commit_<commit_id>_which_added_file>
git commit --squash <commit_id>
git add <file_to_remove_from_commit_<commit_id>_which_added_file>
git commit -m "brand new file!"
git rebase --interactive <commit_id>^

and you can then finish the rebase with ease without having to remember more complex commands or commit message or type as much.

Answered   2023-09-20 20:54:45

  • This works for me. I assume if you want to add the files back into the mix, just use git add -A or git add . and they are back. - anyone
  • This worked for me. I have no idea why git restore --staged didn't work on my version 2.37.3.windows.1. I was trying to remove .idea folder that had some files in it - anyone

Using git GUI can simplify removing a file from the prior commit.

Assuming that this isn't a shared branch and you don't mind rewriting history, then run:

git gui citool --amend

You can un-check the file that was mistakenly committed and then click "Commit".

enter image description here

The file is removed from the commit, but will be kept on disk. So if you un-checked the file after mistakenly adding it, it will show in your untracked files list (and if you un-checked the file after mistakenly modifying it it will show in your changes not staged for commit list).

Answered   2023-09-20 20:54:45

  • On Ubuntu, you can install git gui with sudo apt-get install git-gui - anyone
  • Thank you! I was stuck with a problem (bug?) where a folder containing a .git repo was added, and all the regular remove commands didn't work. This however helped. It being a few commits back, I first utilized git rebase -i HEAD~4 and then ran your command to open the editor. Another note: "Unstaging" can be found in the "Commit" menu. - anyone
  • The easiest solution of all. Simplest to remember. And much less error-prone than using git reset --soft HEAD^ (remembering the --soft arg), followed by git commit -c ORIG_HEAD (rather than --amend, which screws everything up). - anyone
  • thanks, there were 3 binary objects in my last commit and push was taking forever. Your answer helped me to delete 3 objects. - anyone

Keep the file locally (remove from git commit)

If you want to keep the file you can use --cached like so:

git rm --cached filename

enter image description here

Delete local file (and remove from git commit)

else if you want to delete the file just use:

git rm filename

enter image description here

Answered   2023-09-20 20:54:45

If you want to preserve your commit (maybe you already spent some time writing a detailed commit message and don't want to lose it), and you only want to remove the file from the commit, but not from the repository entirely:

git checkout origin/<remote-branch> <filename>
git commit --amend

Answered   2023-09-20 20:54:45

Just wanted to complement the top answer as I had to run an extra command:

git reset --soft HEAD^
git checkout origin/master <filepath>

Cheers!

Answered   2023-09-20 20:54:45

  • Welcome. This answer would be better if you explained what the commands actually do. - anyone

Do a sequence of the following commands:

//to remove the last commit, but preserve changes  
git reset --soft HEAD~1

//to remove unneded file from the staging area  
git reset HEAD `<your file>` 

//finally make a new commit  
git commit -m 'Your message'

Answered   2023-09-20 20:54:45

  • I've tried to do these steps, and I see this error error: failed to push some refs to 'git....' To prevent you from losing history, non-fast-forward updates were rejected Merge the remote changes (e.g. 'git pull') before pushing again. See the 'Note about fast-forwards' section of 'git push --help' for details. (after git pull I have the same changes) - anyone
  • It means that the state of your remote repo has changed while you were doing your local job. And after 'git pull' your local changes should be merged with remote ones, that's it. Of course, your changes must remain. - anyone
  • In other words, if you get that error @Dezigo, add the -f flag to force the update. - anyone

If you want to remove files from previous commits use filters

git filter-branch --prune-empty --index-filter 'git rm --ignore-unmatch --cached "file_to_be_removed.dmg"'

If you see this error:

Cannot create a new backup. A previous backup already exists in refs/original/ Force overwriting the backup with -f

Just remove refs backups on your local repo

$ rm -rf .git/refs/original/refs

Answered   2023-09-20 20:54:45

  • Note that in case of existing backup, the error message clearly indicates the solution: add "-f" as in git filter-branch -f [...etc...]. No need to manually remove the refs. - anyone
git reset --soft HEAD~1. 

This will undo the last commit in local repos and move everything back to stage area like before doing the commit. Then just use any Git UI tool as normal (like TortoiseGit, Git UI, Git Extensions...) to unstage the files that we do not want to commit then do the commit again.

Answered   2023-09-20 20:54:45

  1. git reset --soft HEAD~1
  2. git reset HEAD /file/to/delete
  3. git rm --cached /file/to/delete
  4. git commit --amend -m "your message"
  • key point is the --amend

then can:

git push -u origin master

Answered   2023-09-20 20:54:45

Something that worked for me, but still think there should be a better solution:

$ git revert <commit_id>
$ git reset HEAD~1 --hard

Just leave the change you want to discard in the other commit, check others out

$ git commit --amend // or stash and rebase to <commit_id> to amend changes

Answered   2023-09-20 20:54:45

git reset --soft HEAD^ winds back your commit, and when you type git status, it tells you what to do:

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

Answered   2023-09-20 20:54:45

Actually, I think a quicker and easier way is to use git rebase interactive mode.

git rebase -i head~1  

(or head~4, how ever far you want to go)

and then, instead of 'pick', use 'edit'. I did not realize how powerful 'edit' is.

https://www.youtube.com/watch?v=2dQosJaLN18

Hope you will find it helpful.

Answered   2023-09-20 20:54:45

  • the video is 10 minutes and isn't so useful - anyone

Had the same issue where I have changes in a local branch where I wanted to revert just one file. What worked for me was -

(feature/target_branch below is where I have all my changes including those I wanted to undo for a specific file)

(origin/feature/target_branch is the remote branch where I want to push my changes to)

(feature/staging is my temporary staging branch where I will be pushing from all my wanted changes excluding the change to that one file)

  1. Create a local branch from my origin/feature/target_branch - called it feature/staging

  2. Merged my working local branch feature/target_branch to the feature/staging branch

  3. Checked out feature/staging then git reset --soft ORIG_HEAD (Now all changes from the feature/staging' will be staged but uncommitted.)

  4. Unstaged the file which I have previously checked in with unnecessary changes

  5. Changed the upstream branch for feature/staging to origin/feature/target_branch

  6. Committed the rest of the staged changes and pushed upstream to my remote origin/feature/target_branch

Answered   2023-09-20 20:54:45

If you dont need that file anymore, you could do

git rm file
git commit --amend
git push origin branch

Answered   2023-09-20 20:54:45

if you dont push your changes to git yet

git reset --soft HEAD~1

It will reset all the changes and revert to one commit back

If this is the last commit you made and you want to delete the file from local and remote repository try this :

git rm <file>
 git commit --amend

or even better :

reset first

git reset --soft HEAD~1

reset the unwanted file

git reset HEAD path/to/unwanted_file

commit again

git commit -c ORIG_HEAD  

Answered   2023-09-20 20:54:45

  • its same as above but even really helped to crosscheck - anyone

Another approach that we can do is to :

  1. Delete the file
  2. Make a new commit with the deleted file
  3. Do an interactive rebase and squash both commits
  4. Push

Answered   2023-09-20 20:54:45

If you're using GitHub and haven't yet pushed the commit, GitHub Desktop solves this problem easily:

  1. Choose Repository -> Undo Most Recent Commit
  2. Unselect the file that you mistakenly added. Your previous commit message will be in the dialog box already.
  3. Press the Commit button!

Answered   2023-09-20 20:54:45

This is worked for me to remove the file from bit bucket repo which I pushed the file to branch initially.

git checkout origin/develop <path-to-file>
git add <path-to-file>
git commit -m "Message"
git push

Answered   2023-09-20 20:54:45

  • I think this is an underrated answer for many use cases. Git checkout of the original file from the main branch might be what the user is after. - anyone

I copied the current files in a different folder, then get rid of all unpushed changes by:

git reset --hard @{u}

Then copy things back. Commit, Push.

Answered   2023-09-20 20:54:45

If for any reason (as it was in my case) you'll have trouble reseting all files from the last commit - as in git reset --soft HEAD^ - and your case mets the following conditions, you can do as I explain below.

  1. the file you are trying to remove already existed in repository before the last commit
  2. you can undo all changes in the file since the previous commit (HEAD~2 - the commit just before the last commit)

You can then undo all the changes since the previous commit (HEAD~2), save the file, stage it (git add filename) and then run git commit --amend --no-edit. This will commit the "new changes" - which is actually recommitting the file to the last commit as it was before the last commit.

Answered   2023-09-20 20:54:45