How do I force an overwrite of local files on a git pull? My local repository contains a file of the same filename as on the server.
error: Untracked working tree file 'example.txt' would be overwritten by merge
How do I force "git pull" to overwrite local files?
8.4m Views Asked by Jakub Troszok At
53
There are 53 best solutions below
0
On
Step 1. (optional)
From the root of your local repository, save a backup and
empty the current folder:
mkdir -p ../<branch>-bkp && mv --backup=t * ../<branch>-bkp
Step 2. Download all files and folders of the branch from the remote repository:
git checkout <branch> && git add -A . && git reset --hard origin/<branch> && git pull
where you should replace <branch> with the name of the branch
you want to overwrite.
Comments:
- You may prefer to manually backup and remove the current files and
folders instead of step 1.
In fact, I recommend doing this with a file-handler in the GUI of your operating system. - If you skip step 1, beware: you will lose all work in the local repository!
- Important: if you leave out
git pullin step 2,
you risk not getting the latest version from the remote repository!
According to the second reference below,git reset --hardwill
reset the staging area and the working directory to match the most recent commit.
My experience contradicts this claim! - If you run
git reset --hard origin/<branch_to_overwrite>without first deleting all files and folders from your local repository, beware that any junk files still laying around may sneak into the remote repository at a latergit pusheven if that was not your intention.
The extragit add -A .in step 2 prevents this from happening if you choose to leave out step 1.
References:
https://gitforwindows.org/
https://www.atlassian.com/git/tutorials/undoing-changes/git-reset
https://www.atlassian.com/git/tutorials/rewriting-history/git-reflog
0
On
1: Reset to a previous commit
git reset --hard HEAD
2: Delete Untracked Files
git clean -f
3: Pull the commits
git pull
Sources:
0
On
First of all, try the standard way:
git reset HEAD --hard # To remove all not committed changes!
git clean -fd # To remove all untracked (non-git) files and folders!
Warning: Above commands can results in data/files loss only if you don't have them committed! If you're not sure, make the backup first of your whole repository folder.
Then pull it again.
If above won't help and you don't care about your untracked files/directories (make the backup first just in case), try the following simple steps:
cd your_git_repo # where 'your_git_repo' is your git repository folder
rm -rfv * # WARNING: only run inside your git repository!
git pull # pull the sources again
This will REMOVE all git files (excempt .git/ dir, where you have all commits) and pull it again.
Why git reset HEAD --hard could fail in some cases?
Custom rules in
.gitattributes fileHaving
eol=lfrule in .gitattributes could cause git to modify some file changes by converting CRLF line-endings into LF in some text files.If that's the case, you've to commit these CRLF/LF changes (by reviewing them in
git status), or try:git config core.autcrlf falseto temporary ignore them.File system incompability
When you're using file-system which doesn't support permission attributes. In example you have two repositories, one on Linux/Mac (
ext3/hfs+) and another one on FAT32/NTFS based file-system.As you notice, there are two different kind of file systems, so the one which doesn't support Unix permissions basically can't reset file permissions on system which doesn't support that kind of permissions, so no matter how
--hardyou try, git always detect some "changes".
0
On
Once you do git pull, you will get list of files that are not matching. If the number of files is not very large then you can checkout those files, this action will overwrite those files.
git checkout -- <filename>
I usually do it if for quick check I modify local files on server (no recommended and probabaly reason behind you getting this issue :D ), I checkout the changed files after finding solution.
0
On
Despite the fact that this question has already many answers, the original question is to solve this question
error: Untracked working tree file 'public/images/icon.gif' would be overwritten by merge
As binary files can't be merged a simple answer is
git checkout public/images/icon.gif
With that the file will recover the previous state it had in this branch.
I usually do git stash if I don't want to lose my changes or something like git checkout . if I don't care about locally modified files. IMO much more simple than reset --hard, clean... and all this stuff more suited to leave the branch as in remote, including commits, untracked files, rather than just solving a locally modified file.
0
On
Don't use git reset --hard. That will wipe their changes which may well be completely undesirable. Instead:
git pull
git reset origin/master
git checkout <file1> <file2> ...
You can of course use git fetch instead of git pull since it clearly isn't going to merge, but if you usually pull it makes sense to continue to pull here.
So what happens here is that git pull updates your origin/master reference; git reset updates your local branch reference on to be the same as origin/master without updating any files, so your checked-out state is unchanged; then git checkout reverts files to your local branch index state as needed. In cases where exactly the same file has been added on live and on upstream master, the index already matches the file following the reset, so in the common case you don't need to do git checkout at all.
If the upstream branch also contains commits which you want to apply automatically, you can follow a subtle variation on the process:
git pull
git merge <commit before problem commit>
git reset <problem commit>
git checkout <file1> <file2> ...
git pull
0
On
"My local changes was small, or my changes doesn't work. I just want to reset everything back to original. I know that all my local changes will be lost."
If that's the case then:
git reset --hard
git pull
0
On
For those who don't like reset, I like this approach:
git checkout branchname # go to your branch
git fetch origin branchname # fetch the remote
git checkout -b backup # optionally, mark your remote as a backup
git branch -f branchname origin/branchname # force your local branch to be equal to the fetched origin/branchname
1
On
This solution is always running.
cd $GIT_ROOT_DIRECTORY
git fetch origin/$TARGET_BRANCH
git rm -rf --cached .
git reset --hard origin/TARGET_BRANCH
git clean -df
git pull origin $TARGET_BRANCH
4
On
I summarized other answers. You can execute git pull without errors:
git fetch --all
git reset --hard origin/master
git reset --hard HEAD
git clean -f -d
git pull
Warning: This script is very powerful, so you could lose your changes.
3
On
Here is a generic solution if you do not always want to paste the branch name or you want to automate this within a script
git fetch
git reset --keep origin/$(git rev-parse --abbrev-ref HEAD)
If you want to reset your local changes too:
git fetch
git reset --hard origin/$(git rev-parse --abbrev-ref HEAD)
You also could add a bash alias using this command:
alias gplf='git fetch && echo "HEAD was at $(git rev-parse --short HEAD)" && git reset --hard origin/$(git rev-parse --abbrev-ref HEAD)'
3
On
You might find this command helpful to throw away local changes:
git checkout <your-branch> -f
And then do a cleanup (removes untracked files from the working tree):
git clean -f
If you want to remove untracked directories in addition to untracked files:
git clean -fd
2
On
The only thing that worked for me was:
git reset --hard HEAD~5
This will take you back five commits and then with
git pull
I found that by looking up how to undo a Git merge.
9
On
Instead of doing:
git fetch --all
git reset --hard origin/master
I'd advise doing the following:
git fetch origin master
git reset --hard origin/master
No need to fetch all remotes and branches if you're going to reset to the origin/master branch right?
4
On
You could try git pull --force or maybe stash your commits by using git stash and then running git pull.
13
On
Like Hedgehog I think the answers are terrible. But though Hedgehog's answer might be better, I don't think it is as elegant as it could be. The way I found to do this is by using fetch and merge with a defined strategy. Which should make it so that your local changes are preserved as long as they are not one of the files that you are trying to force an overwrite with.
First do a commit of your changes
git add *
git commit -a -m "local file server commit message"
Then fetch the changes and overwrite if there is a conflict
git fetch origin master
git merge -s recursive -X theirs origin/master
-X is an option name, and theirs is the value for that option. You're choosing to use their changes (the other option is ours changes) if there is a conflict.
1
On
I had the same problem. No one gave me this solution, but it worked for me.
I solved it by:
- Delete all the files. Leave just the
.gitdirectory. git reset --hard HEADgit pullgit push
Now it works.
10
On
WARNING: git clean deletes all your untracked files/directories and can't be undone.
Sometimes just clean -f does not help. In case you have untracked DIRECTORIES, -d option also needed:
# WARNING: this can't be undone!
git reset --hard HEAD
git clean -f -d
git pull
WARNING: git clean deletes all your untracked files/directories and can't be undone.
Consider using -n (--dry-run) flag first. This will show you what will be deleted without actually deleting anything:
git clean -n -f -d
Example output:
Would remove untracked-file-1.txt
Would remove untracked-file-2.txt
Would remove untracked/folder
...
2
On
Based on my own similar experiences, the solution offered by Strahinja Kustudic above is by far the best. As others have pointed out, simply doing hard reset will remove all the untracked files which could include lots of things that you don't want removed, such as config files. What is safer, is to remove only the files that are about to be added, and for that matter, you'd likely also want to checkout any locally-modified files that are about to be updated.
That in mind, I updated Kustudic's script to do just that. I also fixed a typo (a missing ' in the original).
#/bin/sh
# Fetch the newest code
git fetch
# Delete all files which are being added,
# so there are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
echo "Deleting untracked file $file..."
rm -vf "$file"
done
# Checkout all files which have been locally modified
for file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`
do
echo "Checking out modified file $file..."
git checkout $file
done
# Finally merge all the changes (you could use merge here as well)
git pull
0
On
This is the best practice for reverting changes:
git commitCommit your staged changes so they will be saved in the reflog ( see below )git fetchFetch the latest upstream changesgit reset --hard origin/masterHard reset to the origin master branch
The reflog records branches and other references being updated in the local repository. Or simply put - the reflog is the history of your changes.
So it's always a great practice to commit. Commits are appended to the reflog which ensures you will always have a way to retrieve the deleted code.
0
On
I believe there are two possible causes of conflict, which must be solved separately, and as far as I can tell none of the above answers deals with both:
Local files that are untracked need to be deleted, either manually (safer) or as suggested in other answers, by
git clean -f -dLocal commits that are not on the remote branch need to be deleted as well. IMO the easiest way to achieve this is with:
git reset --hard origin/master(replace 'master' by whatever branch you are working on, and run agit fetch originfirst)
0
On
Requirements:
- Track local changes so no-one here ever loses them.
- Make the local repository match the remote origin repository.
Solution:
- Stash the local changes.
Fetch with a clean of files and directories ignoring .gitignore and hard reset to origin.
git stash --include-untracked git fetch --all git clean -fdx git reset --hard origin/master
2
On
I know of a much easier and less painful method:
$ git branch -m [branch_to_force_pull] tmp
$ git fetch
$ git checkout [branch_to_force_pull]
$ git branch -D tmp
That's it!
16
On
This will remove all uncommitted changes, even if staged,
and then pull:
git reset --hard HEAD
git pull
But any local file that's not tracked by Git will not be affected.
1
On
It seems like most answers here are focused on the master branch; however, there are times when I'm working on the same feature branch in two different places and I want a rebase in one to be reflected in the other without a lot of jumping through hoops.
Based on a combination of RNA's answer and torek's answer to a similar question, I've come up with this which works splendidly:
git fetch
git reset --hard @{u}
Run this from a branch and it'll only reset your local branch to the upstream version.
This can be nicely put into a git alias (git forcepull) as well:
git config alias.forcepull "!git fetch ; git reset --hard @{u}"
Or, in your .gitconfig file:
[alias]
forcepull = "!git fetch ; git reset --hard @{u}"
Enjoy!
3
On
Bonus:
In speaking of pull/fetch/merge in the previous answers, I would like to share an interesting and productive trick,
git pull --rebase
This above command is the most useful command in my Git life which saved a lot of time.
Before pushing your newly commit to server, try this command and it will automatically synchronise the latest server changes (with a fetch + merge) and will place your commit at the top in the Git log. There isn't any need to worry about manual pull/merge.
Find details in What does "git pull --rebase" do?.
0
On
Another way of solving this is to first stash any uncommitted changes using git stash and then run
git pull --rebase=interactive -s recursive -X theirs
In the interactive rebase you can change all your local undesired commits to drop, which will get rid of them and leave you at the head of the remote branch without introducing a merge commit.
Now you can run git stash apply if you had local stashed changed that you want to bring back.
0
On
I had the same problem and for some reason, even a git clean -f -d would not do it. Here is why: For some reason, if your file is ignored by Git (via a .gitignore entry, I assume), it still bothers about overwriting this with a later pull, but a clean will not remove it, unless you add -x.
0
On
You could ignore that file with a file in your project base folder:
.gitignore
public/images/*
Then pull the changes and then remove that line from your gitignore file.
0
On
I just solved this myself by:
git checkout -b tmp # "tmp" or pick a better name for your local changes branch
git add -A
git commit -m 'tmp'
git pull
git checkout master # Or whatever branch you were on originally
git pull
git diff tmp
where the last command gives a list of what your local changes were. Keep modifying the "tmp" branch until it is acceptable and then merge back onto master with:
git checkout master && git merge tmp
For next time, you can probably handle this in a cleaner way by looking up "git stash branch" though stash is likely to cause you trouble on the first few tries, so do first experiment on a non-critical project...
0
On
Despite the original question, the top answers can cause problems for people who have a similar problem, but don't want to lose their local files. For example, see Al-Punk and crizCraig's comments.
The following version commits your local changes to a temporary branch (tmp), checks out the original branch (which I'm assuming is master) and merges the updates. You could do this with stash, but I've found it's usually easier to simply use the branch / merge approach.
git checkout -b tmp
git add *; git commit -am "my temporary files"
git checkout master
git fetch origin master
git merge -s recursive -X theirs origin master
where we assume the other repository is origin master.
3
On
I am not sure why anyone did not talk about FETCH_HEAD yet.
git fetch origin master && git reset --hard FETCH_HEAD
If you want to put it in an alias, the command would be:
git config --global alias.fpull '!git fetch origin master && git reset --hard FETCH_HEAD'
1
On
Just do
git fetch origin branchname
git checkout -f origin/branchname // This will overwrite ONLY new included files
git checkout branchname
git merge origin/branchname
So you avoid all unwanted side effects, like deleting files or directories you wanted to keep, etc.
1
On
If you are working on your code and find the new changes a huge mistake or unwanted you can simply use an alternative like:
git restore .
where . means all the files present in the directory.
0
On
I was trying to use the Material2 branch on the Angular2-Webpack-Starter and had a heck of a time. This was the only way I could download and use that branch.
git clone --depth 1 https://github.com/angularclass/angular2-webpack-starter.git
cd angular2-webpack-starter/
git checkout -b material2
Open the project folder and delete all non-hidden files and folders. Leave all the hidden ones.
git add .
git commit -m "pokemon go"
git reset --hard
git pull origin material2
(When the editor pops up, hit ':wq', and then press Enter)
Now you are ready.
0
On
The simplest way I found was to
Rename the branch to something else
Checkout to the branch you want to pull and pull from origin
git branch -m to-delete git checkout main git pullFinally, you can delete the old branch
git branch -D to-delete
0
On
I read through all the answers but I was looking for a single command to do this. Here is what I did. Added a git alias to .gitconfig
[alias]
fp = "!f(){ git fetch ${1} ${2} && git reset --hard ${1}/${2};};f"
Run your command as
git fp origin master
equivalent to
git fetch origin master
git reset --hard origin/master
1
On
Reset the index and the head to origin/master, but do not reset the working tree:
git reset origin/master
0
On
I was trapped in a similar problem my repository was in a branch in which every file was put in asubfolder myapp/subfolder and this command works to clean history.
git clean -f -d
3
On
The problem with all these solutions is that they are all either too complex or, an even bigger problem, is that they remove all untracked files from the webserver, which we don't want since there are always needed configuration files which are on the server and not in the Git repository.
Here is the cleanest solution which we are using:
# Fetch the newest code
git fetch
# Delete all files which are being added, so there
# are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
rm -f -- "$file"
done
# Checkout all files which were locally modified
for file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`
do
git checkout -- "$file"
done
# Finally pull all the changes
# (you could merge as well e.g. 'merge origin/master')
git pull
The first command fetches the newest data.
The second command checks if there are any files that are being added to the repository and deletes those untracked files from the local repository which would cause conflicts.
The third command checks-out all the files which were locally modified.
Finally, we do a pull to update to the newest version, but this time without any conflicts, since untracked files which are in the repo don't exist anymore and all the locally modified files are already the same as in the repository.
1
On
Instead of merging with git pull, try this:
git fetch --all
followed by:
git reset --hard origin/master.
0
On
The key to this is using FETCH_HEAD.
git fetch origin <your e.g. feature branch>
git reset --hard FETCH_HEAD
I've tried HEAD and git pull and none worked.
1
On
These four commands work for me.
git reset --hard HEAD
git checkout origin/master
git branch -D master
git checkout -b master
To check/pull after executing these commands
git pull origin master
I tried a lot but finally got success with these commands.
0
On
An easier way would be to:
git checkout --theirs /path/to/file.extension
git pull origin master
This will override your local file with the file on git
0
On
I used this command to get rid of the local files preventing me from doing a pull/merge. But be careful! Run git merge … first to see whether there are only those files you really want to remove.
git merge origin/master 2>&1 >/dev/null | grep ^[[:space:]] | sed s/^[[:space:]]//g | xargs -L1 rm
git mergelists among other things all those files. They are prepended by some white-space.2>&1 >/dev/nullredirects the error output to the standard one so it is picked up bygrep.grep ^[[:space:]]filters only the lines with file names.sed s/^[[:space:]]//gtrims the white-space from the beginning.xargs -L1 rmcallsrmon each of those files, deleting them.
Handle with care: Whatever git merge outputs, the rm will be called for every line beginning with a white-space.
13
On
It looks like the best way is to first do:
git clean
To delete all untracked files and then continue with the usual git pull...
8
On
Some answers seem to be terrible. Terrible in the sense of what happened to @Lauri by following David Avsajanishvili suggestion.
Rather (git > v1.7.6):
git stash --include-untracked
git pull
Later you can clean the stash history.
Manually, one-by-one:
$ git stash list
stash@{0}: WIP on <branch>: ...
stash@{1}: WIP on <branch>: ...
$ git stash drop stash@{0}
$ git stash drop stash@{1}
Brutally, all-at-once:
$ git stash clear
Of course if you want to go back to what you stashed:
$ git stash list
...
$ git stash apply stash@{5}
First, update all
origin/<branch>refs to latest:Backup your current branch (e.g.
master):Jump to the latest commit on
origin/masterand checkout those files:Explanation:
git fetchdownloads the latest from remote without trying to merge or rebase anything.git resetresets the master branch to what you just fetched. The--hardoption changes all the files in your working tree to match the files inorigin/master.Maintain current local commits
[*]: It's worth noting that it is possible to maintain current local commits by creating a branch from
masterbefore resetting:After this, all of the old commits will be kept in
new-branch-to-save-current-commits.Uncommitted changes
Uncommitted changes, even if staged (with
git add), will be lost. Make sure tostashor commit anything you need. For example, run the following:And later (after
git reset), reapply these uncommitted changes: