1508

How do I resolve a git merge conflict in favor of pulled changes ?

Basically I need to remove all conflicting changes from a working tree without having to go through all of the conflicts with a git mergetool while keeping all conflict-free changes. Preferably doing this while pulling, not afterwards.

Deepak Rai
  • 2,063
  • 3
  • 17
  • 31
sanmai
  • 23,569
  • 11
  • 54
  • 73
  • 3
    possible duplicate of [git merge -s ours, what about "theirs"](http://stackoverflow.com/questions/173919/git-merge-s-ours-what-about-theirs) –  Apr 12 '14 at 02:41
  • 2
    Duplicate of [git pull from remote.. can I force it to overwrite rather than report conflicts?](http://stackoverflow.com/questions/4785107/git-pull-from-remote-can-i-force-it-to-overwrite-rather-than-report-conflicts) You can see the same solution there. – Dan Dascalescu Jul 15 '14 at 00:39
  • 3
    @DanDascalescu Accepted answer there doesn't answer this questions, so clearly it isn't a duplicate. Plus, that other question is quite ambiguous: it is very hard to tell what is asked. All in all I can't agree with you. What is you point in this? – sanmai Jul 15 '14 at 00:44
  • 2
    @sanmai You have two answers - and you accepted one of them. Can you better explain what you are expecting in an answer and how much more detail do you want here? – Edward Thomson Jul 25 '14 at 02:31
  • 2
    @EdwardThomson well, actually I was thinking to give this reputation for the first answer, but if you ask, I might wait and see if a better answer comes up – sanmai Jul 25 '14 at 02:42
  • @sanmai I see; I didn't know if you had some additional questions. Thanks! – Edward Thomson Jul 25 '14 at 02:44
  • There's actually a special bounty reason that you're supposed to use for awarding existing answers, it has the message "*One or more of the answers is exemplary and worthy of an additional bounty.*" Just something to keep in mind for next time `;)` –  Jul 25 '14 at 03:13

12 Answers12

1595
git pull -s recursive -X theirs <remoterepo or other repo>

Or, simply, for the default repository:

git pull -X theirs

If you're already in conflicted state...

git checkout --theirs path/to/file
sanmai
  • 23,569
  • 11
  • 54
  • 73
Pascal Fares
  • 16,498
  • 1
  • 12
  • 12
  • 47
    Note that `-s recursive` here is redundant, since that's the default merge strategy. So you could simplify it to `git pull -X theirs`, which is basically equivalent to [`git pull --strategy-option theirs`](http://stackoverflow.com/a/10697551/456814). –  Jul 28 '14 at 03:26
  • 7
    If I do this, I end up back in the `MERGING` state. I can then `git merge --abort` and try again, but each time I end up with a merge occurring. … I know that a rebase was pushed to my upstream though, so perhaps that's causing this? – Benjohn Jul 14 '16 at 09:03
  • 30
    Be careful with `git checkout --theirs path/to/file`. Used it during rebase and got unexpected results. Found explanation in doc: _Note that during git rebase and git pull --rebase, ours and theirs may appear swapped; --ours gives the version from the branch the changes are rebased onto, while --theirs gives the version from the branch that holds your work that is being rebased._ – Vuk Djapic Jul 06 '17 at 15:13
  • 11
    Note that `git checkout --theirs/--ours path` man page states that it works for **unmerged paths**. So if there were no conflict in path, it is already merged this command will do nothing. This might case issues when you want for example 'theirs' version of a whole sub-folder. So in such case it would be safer to do `git checkout MERGE_HEAD path` or use commit hash. – fsw Aug 23 '17 at 09:17
  • 6
    `git pull -X theirs` creates a merge commit if there are conflicts (e.g. if another committer ran `git push -f` to the remote). If you don't want merge commits, run instead `git fetch && git reset --hard origin/master`. – Dan Dascalescu Jan 23 '18 at 10:02
  • One thing to note with this technique is that, if you're not happy with the result of the `checkout` command, you can run it again with the `--conflict=merge` option to get the full conflict markers in the file again. – Shinigami Mar 25 '18 at 01:32
  • Out of all the answers, this one works: git checkout --theirs path/to/file – Donato Sep 28 '18 at 23:56
  • 1
    `git checkout --theirs .` – Black Mar 25 '19 at 16:45
  • Wanted to upvote this but also didn't want to ruin 1111 – Salim Djerbouh Mar 05 '20 at 22:42
1106

You can use the recursive "theirs" strategy option:

git merge --strategy-option theirs

From the man:

ours
    This option forces conflicting hunks to be auto-resolved cleanly by 
    favoring our version. Changes from the other tree that do not 
    conflict with our side are reflected to the merge result.

    This should not be confused with the ours merge strategy, which does 
    not even look at what the other tree contains at all. It discards 
    everything the other tree did, declaring our history contains all that
    happened in it.

theirs
    This is opposite of ours.

Note: as the man page says, the "ours" merge strategy-option is very different from the "ours" merge strategy.

N T
  • 543
  • 5
  • 9
Ikke
  • 90,705
  • 23
  • 91
  • 118
  • Here is more detailed explanation: http://lostechies.com/joshuaflanagan/2010/01/29/how-to-resolve-a-binary-file-conflict-with-git/ – mPrinC Sep 17 '13 at 00:34
  • 235
    Also `git checkout --theirs` to operate on a single conflicting file – dvd Jul 31 '14 at 12:24
  • 50
    This doesn't work if you are already in the conflict resolution state. In that case I believe the best way to resolve is to `git checkout -- the/conflicted.file`; and then `git add` their changes. – ThorSummoner Sep 12 '14 at 17:58
  • 57
    @ThorSummoner In that case, there is git checkout --theirs path/of/file. That way, you don't have to manually look up the correct hash. – Ikke Sep 13 '14 at 19:26
  • 9
    @Ikke That should basically be its own answer (and the accepted answer at that) if you ask me. – ThorSummoner Sep 14 '14 at 02:16
  • "git merge local/master --strategy-option theirs" worked for me – Yasen May 13 '15 at 08:37
  • I get `error: Merging is not possible because you have unmerged files.` – ShadSterling Feb 07 '17 at 19:28
  • Could you update this answer for `Git 2.0+`? Because from 2.0 onwards `git merge` does no longer have `--strategy-option`. There is only `--strategy`, but this option does not have a `theirs` strategy. Choices are `octopus`, `ours`, `recursive` (default?!), `resolve`, `subtree`. – daniel451 May 30 '17 at 19:58
  • @daniel451 Why do you think that option has been removed? It's still available. See: https://git-scm.com/docs/git-merge#git-merge--Xltoptiongt – Ikke Jun 01 '17 at 04:39
  • Nevermind, I just noticed that my zsh-setup apparently lacks auto-completion support for `--strategy-option` and I have overlooked this option.. – daniel451 Jun 01 '17 at 06:19
  • @dvd that's exactly the option I was looking for. I want to initiate the merge as usual, but when resolving the conflicts, I want to be able to resolve individual files with the appropriate strategy. Thank you! – asgs May 07 '18 at 08:24
  • I did with git merge OTHER_BRANCH_NAME --strategy-option theirs – V-SHY Dec 04 '18 at 15:45
  • If you're already in the conflict resolution state, you can cancel the merge by first doing `git merge --abort`, and then using `git merge --strategy-option theirs`. – commscheck Sep 02 '19 at 23:55
  • `git merge --strategy-option theirs BRANCH_THEIRS` still generated conflicts to me ... – mljrg Oct 13 '20 at 13:53
591

If you're already in conflicted state, and you want to just accept all of theirs:

git checkout --theirs .
git add .

If you want to do the opposite:

git checkout --ours .
git add .

This is pretty drastic, so make sure you really want to wipe everything out like this before doing it.

lots-to-learn
  • 6,119
  • 1
  • 7
  • 9
  • 57
    or, don't use the `.` and specify the file(s) in place of the dot that you want to checkout. less "drastic" & exactly what you want to do, presumably. – manroe Dec 16 '15 at 00:56
  • Have I missed something, or don't you have to `git reset` the conflicted files **before** `git checkout`? – Vitor Feb 25 '16 at 19:38
  • 12
    this doesn't work if the file has been removed from the other branch: '' does not have their version – Japster24 Mar 02 '16 at 16:52
  • 4
    Would upvote more if I could, keep coming back to this answer every now and then. – tarikki Sep 14 '16 at 04:04
  • 6
    Use `git add -u` instead to skip files that are not under version control. – Sudipta Basak Oct 27 '16 at 20:56
  • 5
    Hypothetical case, three changes in a file, one conflicting, two without conflict, would this solution apply non conflicting changes and resolve the conflicting change to ours? Or would it take only ours version ignoring non conflicting changes from theirs? – pedromarce Feb 28 '17 at 14:50
  • @Japster @SudiptaBasak So [that `-u` was magic](https://stackoverflow.com/questions/2190409/whats-the-difference-between-git-add-and-git-add-u). Thanks! – ruffin May 26 '17 at 22:35
  • If its Monday morning and you haven't yet had coffee. Running the command above doesn't move the files from a "both modified" state. – DickieBoy Oct 16 '17 at 09:18
  • It's worth mentioning that like most git actions you can apply this to paths, e.g. `git checkout --theirs wp-content/languages/` which will grab just files under that path from the incoming branch, and leave the rest untouched. – Rob Murphy May 29 '18 at 10:31
  • 2
    @pedromarce `git checkout --ours ` takes **all** ours changes including non conflicting. Be careful with that. – Robert Jakubowski Nov 13 '19 at 07:51
  • 1
    Does `--theirs` mean `Incoming change`? While `--ours` mean `Current change`? – tonix May 12 '20 at 14:00
  • @tonix, always interpret git terminology from the perspective of a paranoid Linus Torvalds protecting linux from outside changes. If you apply that mindset, then yes "theirs" means the change being merged in (or merge candidate) and "ours" means the side that will receive the merge (the branch that will be updated). Notice, all of this is strictly based on the orientation of the git merge command (not your larger purpose or a local / origin setup, etc). I hate the "ours/theirs" terminology because it has a technical meaning in the `git merge` which can be opposite of how it sounds. – combinatorist Aug 19 '20 at 15:43
230

OK so, picture the scenario I was just in:

You attempt a merge, or maybe a cherry-pick, and you're stopped with

$ git cherry-pick 1023e24
error: could not apply 1023e24... [Commit Message]
hint: after resolving the conflicts, mark the corrected paths
hint: with 'git add <paths>' or 'git rm <paths>'
hint: and commit the result with 'git commit'

Now, you view the conflicted file and you really don't want to keep your changes. In my case above, the file was conflicted on just a newline my IDE had auto-added. To undo your changes and accept their's, the easiest way is:

git checkout --theirs path/to/the/conflicted_file.php
git add path/to/the/conflicted_file.php

The converse of this (to overwrite the incoming version with your version) is

git checkout --ours path/to/the/conflicted_file.php
git add path/to/the/conflicted_file.php

Surprisingly, I couldn't find this answer very easily on the Net.

Theodore R. Smith
  • 18,715
  • 12
  • 52
  • 81
  • 17
    Note that, if one performs a `git status` between `checkout` and `add`, the file still shows as "both modified". – bishop Mar 25 '16 at 12:56
  • Do you know if there is a way to do this for all files that are in a conflicted state? If so it'd be a nice extension to your answer. – Drew Noakes Mar 06 '18 at 08:42
  • 2
    I do this: `git reset --hard` and then `git pull [remote server name] [branch name] -Xtheirs` (undoes the merge then pulls the new stuff on top of my stuff) - not sure if this what you want. – ssaltman May 22 '18 at 19:17
45

The git pull -X theirs answers may create an ugly merge commit, or issue an

error: Your local changes to the following files would be overwritten by merge:

If you want to simply ignore any local modifications to files from the repo, for example on a client that should always be a mirror of an origin, run this (replace master with the branch you want):

git fetch && git reset --hard origin/master

How does it work? git fetch does git pull but without merge. Then git reset --hard makes your working tree match the last commit. All of your local changes to files in the repo will be discarded, but new local files will be left alone.

Dan Dascalescu
  • 110,650
  • 40
  • 276
  • 363
  • 1
    +1 - `git fetch && git reset --hard {remote}/{branch}` was what solved my problem. I needed to completely ditch my own changes in favour of "theirs" state of a branch, but the `git pull -X theirs` choked on some moved/renamed files. Thanks! – Ivaylo Slavov Feb 05 '18 at 18:28
  • but if I do `git pull` afterwards I go back to conflicting state, may be I shouldn't have git pulled, but why not? – Vivek Shukla Aug 28 '20 at 12:45
43

After git merge, if you get conflicts and you want either your or their

git checkout --theirs .
git checkout --ours .
sanmai
  • 23,569
  • 11
  • 54
  • 73
Mohit Kanojia
  • 561
  • 4
  • 6
  • 2
    How would I do this on a per conflicting chunk basis? The above works on a file level, throwing out any non-conflicting chunks a conflicting file might have. – Jani Apr 23 '20 at 07:34
22

To resolve all conflicts with the version in a particular branch:

git diff --name-only --diff-filter=U | xargs git checkout ${branchName}

So, if you are already in the merging state, and you want to keep the master version of the conflicting files: 

git diff --name-only --diff-filter=U | xargs git checkout master
CodeWizard
  • 92,491
  • 19
  • 110
  • 133
Ariel Alvarez
  • 431
  • 5
  • 11
  • And for people on windows without access to pipe xargs, how does this translate? – tsemer Dec 09 '16 at 16:18
  • Wouldn't it skip your changes completely? Even those which are not in conflict state? – Valentin Heinitz Jan 15 '18 at 12:24
  • This is what I ended up doing. Unfortunately it subsequently requires either a `git cherry-pick --continue` *or* a `git commit --allow-empty` command to commit these changes, and there seems to be no system behind which command is required, which makes automating this a pain. I’m currently solving this by testing for the existence of a `.git/COMMIT_EDITMSG` file but that seems hacky and brittle, and I’m not yet convinced that it always works. – Konrad Rudolph May 07 '19 at 16:41
  • 1
    This is good, means if you manually resolve some (and do `git add`) then you can bulk resolve the rest via this. `git checkout --ours` / `git checkout --theirs` is useful too. – rcoup Mar 25 '20 at 15:21
21

Please not that sometimes this will not work:

git checkout --ours path/to/file

or

git checkout --theirs path/to/file

I did this instead, assuming HEAD is ours and MERGE_HEAD is theirs

git checkout HEAD -- path/to/file

or:

git checkout MERGE_HEAD -- path/to/file

After we do this and we are good:

git add .

If you want to understand more, see wonderful post of torek here : git checkout --ours does not remove files from unmerged files list

Community
  • 1
  • 1
Nicolas D
  • 1,062
  • 13
  • 38
19

VS Code (integrated Git) IDE Users:

If you want to accept all the incoming changes in the conflict file then do the following steps.

1. Go to command palette - Ctrl + Shift + P
2. Select the option - Merge Conflict: Accept All Incoming

Similarly you can do for other options like Accept All Both, Accept All Current etc.,

SridharKritha
  • 5,151
  • 2
  • 34
  • 32
10

If you're already in conflicted state, and do not want to checkout path one by one. You may try

git merge --abort
git pull -X theirs
Lee Chee Kiam
  • 9,693
  • 10
  • 56
  • 76
3

I had a long-running next-version branch with tons of deletions to files that had changed on develop, files that had been added in different places on both branches, etc.

I wanted to take the entire contents of the next-version branch into develop, all in one whopping merge commit.

The combination of the above commands that worked for me was:

git merge -X theirs next-version
# lots of files left that were modified on develop but deleted on next-version
git checkout next-version .
# files removed, now add the deletions to the commit
git add .
# still have files that were added on develop; in my case they are all in web/
git rm -r web

Not a new answer, just combining bits from many answers, partly to reassure that you might need all of these answers.

Gordon
  • 18,882
  • 4
  • 33
  • 72
0

from https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging

This will basically do a fake merge. It will record a new merge commit with both branches as parents, but it will not even look at the branch you’re merging in. It will simply record as the result of the merge the exact code in your current branch.

$ git merge -s ours mundo

Merge made by the 'ours' strategy.

$ git diff HEAD HEAD~

You can see that there is no difference between the branch we were on and the result of the merge.

This can often be useful to basically trick Git into thinking that a branch is already merged when doing a merge later on. For example, say you branched off a release branch and have done some work on it that you will want to merge back into your master branch at some point. In the meantime some bugfix on master needs to be backported into your release branch. You can merge the bugfix branch into the release branch and also merge -s ours the same branch into your master branch (even though the fix is already there) so when you later merge the release branch again, there are no conflicts from the bugfix.

A situation I've found to be useful if I want master to reflect the changes of a new topic branch. I've noticed that -Xtheirs doesn't merge without conflicts in some circumstances... e.g.

$ git merge -Xtheirs topicFoo 

CONFLICT (modify/delete): js/search.js deleted in HEAD and modified in topicFoo. Version topicFoo of js/search.js left in tree.

In this case the solution I found was

$ git checkout topicFoo

from topicFoo, first merge in master using the -s ours strategy, this will create the fake commit that is just the state of topicFoo. $ git merge -s ours master

check the created merge commit

$ git log

now checkout the master branch

$ git checkout master

merge the topic branch back but this time use the -Xtheirs recursive strategy, this will now present you with a master branch with the state of topicFoo.

$ git merge -X theirs topicFoo
Amos Folarin
  • 1,826
  • 18
  • 18