Résoudre les conflits de fusion Git en faveur de leurs modifications lors d'un pull

Comment résoudre un conflit de fusion git en faveur de modifications retirées?

Fondamentalement, je dois supprimer toutes les modifications conflictuelles d'une arborescence de travail sans avoir à passer par tous les conflits git mergetoolpendant un certain temps en conservant toutes les modifications sans conflit. Faites-le de préférence en tirant, pas après.

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

Ou, tout simplement, pour le référentiel par défaut:

git pull -X theirs

Si vous êtes déjà en conflit ...

git checkout --theirs path/to/file

Vous pouvez utiliser l' option de stratégie récursive "la leur" :

git merge --strategy-option theirs

De l' homme :

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.

Remarque: comme l'indique la page de manuel, l' option de stratégie de fusion "nôtre" est très différente de la stratégie de fusion "nôtre" .

Si vous êtes déjà en état de conflit et que vous souhaitez simplement accepter tous les leurs:

git checkout --theirs .
git add .

Si vous voulez faire le contraire:

git checkout --ours .
git add .

C'est assez drastique, alors assurez-vous vraiment de tout effacer comme ça avant de le faire.

OK, imaginez le scénario dans lequel je venais de:

Vous tentez un merge, ou peut-être un cherry-pick, et vous êtes arrêté avec

$ 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'

Maintenant, vous affichez le fichier en conflit et vous ne voulez vraiment pas conserver vos modifications. Dans mon cas ci-dessus, le fichier était en conflit sur une nouvelle ligne que mon IDE avait ajoutée automatiquement. Pour annuler vos modifications et accepter les leurs, la manière la plus simple est:

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

L'inverse de ceci (pour écraser la version entrante avec votre version) est

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

Étonnamment, je n'ai pas pu trouver cette réponse très facilement sur le Net.

Les git pull -X theirsréponses peuvent créer un vilain commit de fusion ou émettre un

erreur: vos modifications locales dans les fichiers suivants seraient écrasées par la fusion:

Si vous souhaitez simplement ignorer toute modification locale des fichiers du référentiel, par exemple sur un client qui doit toujours être le miroir d'une origine, exécutez ceci (replace master par la branche souhaitée):

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

Comment ça marche? git fetchfait git pullmais sans fusion . Fait ensuite correspondre git reset --hardvotre arbre de travail au dernier commit. Toutes vos modifications locales apportées aux fichiers du référentiel seront ignorées , mais les nouveaux fichiers locaux seront laissés seuls.

Après la fusion de git, si vous rencontrez des conflits et que vous souhaitez que votre ou leur

git checkout --theirs .
git checkout --ours .

Pour résoudre tous les conflits avec la version dans une branche particulière:

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

Donc, si vous êtes déjà dans l'état de fusion et que vous souhaitez conserver la version principale des fichiers en conflit:

git diff --name-only --diff-filter=U | xargs git checkout master

Veuillez noter que parfois cela ne fonctionnera pas :

git checkout - notre chemin / vers / fichier

ou

git checkout - leur chemin / vers / fichier

Je l'ai fait à la place, en supposant que HEAD est à nous et MERGE_HEAD est à eux

git checkout HEAD -- path/to/file

ou:

git checkout MERGE_HEAD -- path/to/file

Après cela, nous sommes bons:

git add .

Si vous voulez en savoir plus, consultez le merveilleux article de torek ici: git checkout --ours ne supprime pas les fichiers de la liste des fichiers non fusionnés

Utilisateurs IDE VS Code (Git intégré):

Si vous souhaitez accepter toutes les modifications entrantes dans le fichier de conflit, procédez comme suit.

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

De même, vous pouvez faire pour d'autres options comme Accepter tous les deux, Accepter tout le courant, etc.,

J'avais une next-versionbranche de longue date avec des tonnes de suppressions de fichiers qui avaient changé develop, des fichiers qui avaient été ajoutés à différents endroits sur les deux branches, etc.

Je voulais prendre tout le contenu de la next-versionbranche dans develop, tout en un gros commit de fusion.

La combinaison des commandes ci-dessus qui a fonctionné pour moi était:

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

Pas une nouvelle réponse, juste en combinant des extraits de nombreuses réponses, en partie pour rassurer que vous pourriez avoir besoin de toutes ces réponses.

Si vous êtes déjà en état de conflit et que vous ne souhaitez pas extraire le chemin un par un. Vous pouvez essayer

git merge --abort
git pull -X theirs

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

Cela fera essentiellement une fausse fusion. Il enregistrera un nouveau commit de fusion avec les deux branches en tant que parents, mais il ne regardera même pas la branche dans laquelle vous fusionnez. Il enregistrera simplement comme résultat de la fusion le code exact dans votre branche actuelle.

$ git merge -s ours mundo

Fusion faite par la stratégie «nôtre».

$ git diff HEAD HEAD~

Vous pouvez voir qu'il n'y a aucune différence entre la branche sur laquelle nous étions et le résultat de la fusion.

Cela peut souvent être utile pour inciter Git à penser qu'une branche est déjà fusionnée lors d'une fusion ultérieure. Par exemple, supposons que vous ayez créé une branche de version et que vous ayez effectué un travail sur celle-ci que vous souhaiterez fusionner à nouveau dans votre branche principale à un moment donné. En attendant, certains correctifs de bogues sur master doivent être rétroportés dans votre branche de publication. Vous pouvez fusionner la branche bugfix dans la branche release et également fusionner la nôtre - la même branche dans votre branche master (même si le correctif est déjà là) donc quand vous fusionnerez plus tard la branche release, il n'y aura aucun conflit depuis le bugfix.

Une situation que j'ai trouvée utile si je veux que master reflète les changements d'une nouvelle branche de sujet. J'ai remarqué que -Xtheirs ne fusionne pas sans conflits dans certaines circonstances ... par exemple

$ 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.

Dans ce cas, la solution que j'ai trouvée était

$ git checkout topicFoo

à partir de topicFoo, fusionnez d'abord dans master en utilisant la stratégie -s our, cela créera le faux commit qui n'est que l'état de topicFoo. $ git merge -s our master

vérifier le commit de fusion créé

$ git log

passez à la caisse principale

$ git checkout master

fusionnez la branche de sujet en arrière, mais cette fois utilisez la stratégie récursive -Xtheirs, cela vous présentera maintenant une branche principale avec l'état de topicFoo.

$ git merge -X theirs topicFoo