Rozwiąż konflikty scalania Git na korzyść ich zmian podczas ściągania

Jak rozwiązać konflikt scalania git na korzyść wycofanych zmian?

Zasadniczo muszę usunąć wszystkie sprzeczne zmiany z działającego drzewa bez konieczności przechodzenia przez wszystkie konflikty z git mergetoolzachowaniem wszystkich zmian wolnych od konfliktów. Najlepiej robić to podczas ciągnięcia, a nie później.

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

Lub po prostu dla domyślnego repozytorium:

git pull -X theirs

Jeśli jesteś już w stanie konfliktu ...

git checkout --theirs path/to/file

Można użyć „ich” Strategia rekurencyjną opcji :

git merge --strategy-option theirs

Od mężczyzny :

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.

Uwaga: ponieważ strona mężczyzna mówi, w „nasze” scalanie opcja strategia jest bardzo różni się od „nasze” seryjnej strategii .

Jeśli jesteś już w stanie konfliktu i chcesz po prostu zaakceptować wszystkie :

git checkout --theirs .
git add .

Jeśli chcesz zrobić odwrotnie:

git checkout --ours .
git add .

Jest to dość drastyczne, więc upewnij się, że naprawdę chcesz wyczyścić wszystko w ten sposób, zanim to zrobisz.

OK, więc wyobraź sobie scenariusz, w którym właśnie byłem:

Próbujesz merge, a może i cherry-pick, i jesteś zatrzymany

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

Teraz widzisz plik będący w konflikcie i naprawdę nie chcesz zachować swoich zmian. W moim przypadku powyżej plik był w konflikcie tylko w nowej linii, którą moje IDE dodało automatycznie. Aby cofnąć zmiany i zaakceptować ich, najprostszym sposobem jest:

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

W przeciwieństwie do tego (aby zastąpić wersję przychodzącą wersją):

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

Zaskakujące, że nie mogłem znaleźć tej odpowiedzi bardzo łatwo w sieci.

W git pull -X theirsodpowiedzi mogą tworzyć brzydkie scalającej, lub wydania

błąd: lokalne zmiany następujących plików zostaną zastąpione przez scalenie:

Jeśli chcesz po prostu zignorować wszelkie lokalne modyfikacje plików z repozytorium, na przykład na kliencie, który zawsze powinien być kopią lustrzaną źródła, uruchom to (zamień masterna gałąź, którą chcesz):

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

Jak to działa? git fetchrobi, git pullale bez łączenia . Następnie git reset --harddopasowuje działające drzewo do ostatniego zatwierdzenia. Wszystkie lokalne zmiany w plikach w repozytorium zostaną odrzucone , ale nowe pliki lokalne pozostaną same.

Po połączeniu git, jeśli masz konflikty i chcesz albo swoje, albo ich

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

Aby rozwiązać wszystkie konflikty z wersją w określonej gałęzi:

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

Tak więc, jeśli jesteś już w stanie scalenia i chcesz zachować wersję główną plików w konflikcie:

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

Proszę nie, że czasami to nie zadziała :

git checkout - nasza ścieżka / do / pliku

lub

git checkout - ich ścieżka / do / pliku

Zrobiłem to zamiast tego, zakładając, że HEAD należy do nas, a MERGE_HEAD należy do nich

git checkout HEAD -- path/to/file

lub:

git checkout MERGE_HEAD -- path/to/file

Gdy to zrobimy i będziemy dobrze:

git add .

Jeśli chcesz dowiedzieć się więcej, zobacz wspaniały wpis torek tutaj: git checkout - nasze pliki nie usuwają plików z listy nie połączonych plików

Użytkownicy IDE Code (zintegrowany Git):

Jeśli chcesz zaakceptować wszystkie nadchodzące zmiany w pliku konfliktu, wykonaj następujące czynności.

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

Podobnie możesz zrobić dla innych opcji, takich jak Akceptuj wszystkie oba, Akceptuj wszystkie bieżące itp.,

Miałem długo działającą next-versiongałąź z mnóstwem usunięć plików, które się zmieniły develop, plików dodanych w różnych miejscach obu gałęzi itp.

Chciałem wziąć całą zawartość next-versionoddziału develop, wszystko w jednym wielkim zatwierdzeniu scalania.

Kombinacja powyższych poleceń, która działała dla mnie, była:

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

Nie nowa odpowiedź, po prostu łączenie fragmentów z wielu odpowiedzi, częściowo po to, aby upewnić się, że możesz potrzebować wszystkich tych odpowiedzi.

Jeśli jesteś już w stanie konfliktu i nie chcesz pobierać ścieżki pojedynczo. Możesz spróbować

git merge --abort
git pull -X theirs

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

Zasadniczo spowoduje to fałszywe scalenie. Będzie rejestrować nowy zatwierdzenie scalania z oboma oddziałami jako rodzicami, ale nawet nie spojrzy na gałąź, w której się scalasz. Po prostu zapisze w wyniku scalenia dokładny kod w bieżącej gałęzi.

$ git merge -s ours mundo

Scalenie wykonane przez strategię „naszą”.

$ git diff HEAD HEAD~

Widać, że nie ma różnicy między gałęzią, w której byliśmy, a wynikiem połączenia.

Często może to być przydatne, aby Git pomyślał, że gałąź jest już scalona podczas późniejszego scalania. Załóżmy na przykład, że rozgałęziłeś gałąź wydania i zrobiłeś nad nią trochę pracy, którą w pewnym momencie będziesz chciał z powrotem połączyć z gałęzią master. W międzyczasie niektóre poprawki na masterie muszą zostać przeniesione do twojej gałęzi wydania. Możesz scalić gałąź poprawki błędów z gałęzią wydania, a także scalić naszą gałąź z gałęzią master (nawet jeśli poprawka już istnieje), więc kiedy później ponownie scalisz gałąź wydania, nie będzie żadnych konfliktów z poprawką.

Sytuacja okazała się przydatna, jeśli chcę, aby master odzwierciedlał zmiany w nowej gałęzi tematów. Zauważyłem, że -Xtheirs nie łączą się bez konfliktów w niektórych okolicznościach ... np

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

W tym przypadku znalazłem rozwiązanie

$ git checkout topicFoo

from topicFoo, pierwsze scalenie w master przy użyciu strategii -s nasza, spowoduje to utworzenie fałszywego zatwierdzenia, które jest stanem topicFoo. $ git merge - nasz mistrz

sprawdź utworzone zatwierdzenie scalania

$ git log

teraz sprawdź gałąź master

$ git checkout master

połącz gałąź tematów z powrotem, ale tym razem skorzystaj ze strategii rekurencyjnej -Xtheirs, teraz zobaczysz gałąź główną ze stanem topicFoo.

$ git merge -X theirs topicFoo