Jak rozwiązywać konflikty korespondencji seryjnej w Git

czy istnieje dobry sposób, aby wyjaśnić, jak rozwiązywać konflikty korespondencji seryjnej w Git?


spróbuj: git mergetool

otwiera interfejs graficzny, który przechodzi przez każdy konflikt, i można wybrać, jak połączyć. Czasami po to wymaga trochę ręcznej edycji,ale zazwyczaj to wystarczy. Oczywiście, jest o wiele lepiej, niż robić wszystko ręcznie.

zgodnie z komentarzem @JoshGlover:

zespół nie koniecznie otwiera GUI, jeśli nie zaznacz go. Działa git mergetool dla mnie to doprowadziło do vimdiff jest używany. Można ustawić jednym z takich narzędzi do jego użycia:meld,opendiff,kdiff3,tkdiff,xxdiff,tortoisemerge,gvimdiff,diffuse,ecmerge,p4merge,araxis,vimdiff,emerge.

Poniżej przedstawiono przykład procedury, aby skorzystać z vimdiff do rozwiązywania konfliktów korespondencji seryjnej. Na podstawie ten link

Krok 1:: wykonaj następujące polecenia w terminalu

git config merge.tool vimdiff
git config merge.conflictstyle diff3
git config mergetool.prompt false

to zainstaluje vimdiff jako połączenie domyślne narzędzie.

Krok 2:: uruchom następujące polecenie w terminalu

git mergetool

Krok 3:: zobaczysz wyświetlacz vimdiff w następującym formacie:

  +----------------------+
  |       |      |       |
  |LOCAL  |BASE  |REMOTE |
  |       |      |       |
  +----------------------+
  |      MERGED          |
  |                      |
  +----------------------+

te 4 rodzaje

LOCAL-jest to plik z bieżącej gałęzi

BASE-wspólny przodek, jak plik wyglądał w obu zmian

REMOTE-plik, który połączy w swoją gałąź

MERGED-merge result, to jest to, co utrzymuje się w repo

można poruszać się między tymi pojęciami, za pomocą ctrl+w. Można bezpośrednio dostać się do wspólnego składania, za pomocą ctrl+w szedł na j.

dodatkowe informacje na temat nawigacji vimdiff tutaj a tutaj

Krok 4. Możesz zmienić wspólne pojęcie w następujący sposób

jeśli chcesz uzyskać zmiany od Zdalny

:diffg RE  

jeśli chcesz uzyskać zmiany od bazy

:diffg BA  

jeśli chcesz uzyskać zmiany od LOCAL

:diffg LO 

Krok 5:. Zapisz, wyjdź, zabezpieczyć i oczyścić

:wqa zapisz i wyjdź z Vi

git commit -m "message"

git clean usuń zbędne pliki (na przykład *.orig), utworzony narzędzia diff.


oto prawdopodobny wariant wykorzystania, od góry:

masz zamiar wyciągnąć jakieś zmiany, ale ups, jesteś nie na bieżąco:

git fetch origin
git pull origin master

From ssh://[email protected]:22/projectname
 * branch            master     -> FETCH_HEAD
Updating a030c3a..ee25213
error: Entry 'filename.c' not uptodate. Cannot merge.

w ten sposób można uzyskać up-to-date, a następnie ponów próbę, ale jest konflikt:

git add filename.c
git commit -m "made some wild and crazy changes"
git pull origin master

From ssh://[email protected]:22/projectname
 * branch            master     -> FETCH_HEAD
Auto-merging filename.c
CONFLICT (content): Merge conflict in filename.c
Automatic merge failed; fix conflicts and then commit the result.

Więc zdecydujesz się spojrzeć na zmiany:

git mergetool

o mnie, O mój, w górę rzeki zmieniły się niektóre rzeczy, ale po prostu użyć moje zmiany...Nie...ich zmiany...

git checkout --ours filename.c
git checkout --theirs filename.c
git add filename.c
git commit -m "using theirs"

i następnie spróbujemy finał czasu

git pull origin master

From ssh://[email protected]:22/projectname
 * branch            master     -> FETCH_HEAD
Already up-to-date.

ta-da!


uważam, że narzędzia do korespondencji seryjnej rzadko pomagają mi zrozumieć konflikt lub rozdzielczość. Zwykle jestem bardziej pomyślnie patrzę na markery konfliktów w edytorze tekstu i używam git log jako dodatek.

oto kilka wskazówek:

Wskazówka

najlepsze, co znalazłem, to użyj stylu konfliktu korespondencji seryjnej" diff3":

git config merge.conflictstyle diff3

to produkuje uchwyty konfliktów, jak to:

<<<<<<<
Changes made on the branch that is being merged into. In most cases,
this is the branch that I have currently checked out (i.e. HEAD).
|||||||
The common ancestor version.
=======
Changes made on the branch that is being merged in. This is often a 
feature/topic branch.
>>>>>>>

środkowej części jest to, że wyglądał wspólny przodek. Jest to przydatne, ponieważ można porównać go z górnej i dolnej wersji, aby uzyskać lepsze wyobrażenie o tym, że została zmieniona na każdej gałęzi, co daje lepsze wyobrażenie o celu każdej zmiany.

jeśli konflikt tylko kilka wierszy, to zazwyczaj sprawia, że konflikt jest bardzo oczywiste. (Wiedzieć, jak rozwiązać konflikt, to zupełnie inna sprawa; trzeba wiedzieć, nad czym pracują inni ludzie. Jeśli niepokoi cię, lepiej po prostu nazwać to człowiek w swoim pokoju, aby mogli zobaczyć, co oglądasz.)

jeśli konflikt jest dłuższa, to będę wycinać i wklejać każdy z trzech rozdziałów w trzech oddzielnych pliku, takich jak "mój", "ogólny" i "ich".

następnie mogę uruchomić następujące polecenia, aby zobaczyć dwa różne kawałki, które spowodowały konflikt:

diff common mine
diff common theirs

to nie to samo, co wykorzystywać narzędzie do korespondencji seryjnej, tak jak narzędzie korespondencji seryjnej będzie obejmować wszystkie неконфликтные kawałki diff. Uważam, że rozpraszać.

Wskazówka Dwa

ktoś już wspominał o tym, ale zrozumienie intencji za każdym wyróżnieniem, jak zwykle, bardzo przydatne dla zrozumienia, skąd powstał konflikt i jak z nim sobie poradzić.

git log --merge -p <name of file>

To pokazuje wszystkie commity, które dotyczą tego pliku między wspólnego przodka i dwoma głowami, które łączą. (W ten sposób, że nie obejmuje zmiany, które już istnieją w obu gałęziach do korespondencji seryjnej.) To pozwala ignorować różnice skąpiec oczywiście, że to nie jest czynnikiem twojego obecnego konfliktu.

Wskazówka Trzeci

Sprawdź swoje zmiany za pomocą automatycznych narzędzi.

jeśli masz automatyczne testy, uruchom je. Jeśli masz Линта wykonaj to. Jeśli to zbiorczy projekt, utwórz go przed zatwierdzeniem itp. We wszystkich przypadkach trzeba przeprowadzić mały test, aby upewnić się, że wasze zmiany nic nie złamał. (Cholera, nawet fuzja bez konfliktów może zakłócić pracy kod.)

Wskazówka Cztery!--9-->

plan do przodu; komunikować się z kolegami.

planowanie do przodu i świadomość tego, nad czym pracują inni, może pomóc w zapobieganiu konfliktów scalania i/lub pomóc rozwiązać ich wcześniej, na razie szczegóły nie są jeszcze świeże w pamięci.

na przykład, jeśli wiesz, że i inne osoby pracujące nad różnymi рефакторингами, które będą miały wpływ na jeden i ten sam zestaw plików, należy wcześniej porozmawiać ze sobą i uzyskać lepsze wyobrażenie o tym, jakie typy każdy z was wprowadza swoje zmiany. Można zaoszczędzić sporo czasu i wysiłku, jeśli będziesz wykonywać zaplanowane zmiany są szeregowo, a nie równolegle.

do najważniejszych рефакторингов, które przekraczają duży pasek kodu, należy zdecydowanie rozważyć możliwość pracy kolejno: wszystkie przestają pracować nad tym obszarem kodu, podczas gdy jedna osoba wykonuje pełna refaktoryzacja.

jeśli nie możesz pracować szeregowo (z powodu presji czasu, być może), to komunikat o oczekiwanych konfliktach korespondencji seryjnej przynajmniej pomoże ci rozwiązać problem wcześniej, na razie szczegóły nie są jeszcze świeże w pamięci. Na przykład, jeśli pracownik wykonuje katastrofalną serię commits w ciągu jednego tygodnia, można wybrać połączenie/relokacja w tej gałęzi pracowników, jeden lub dwa razy dziennie w ciągu tego tygodnia. Tak więc, jeśli znajdziesz konflikty fuzji/relokacji, można je rozwiązać szybciej, niż jeśli możesz poczekać kilka tygodni, aby połączyć wszystkie razem w jeden duży kawałek.

Wskazówka Piąty

jeśli nie jesteś pewien w połączeniu, nie podnosi go.

połączenie może być przytłaczające, zwłaszcza, gdy istnieje wiele konfliktu plików, a markery konfliktów obejmują setki wierszy. Często przy ocenie projektów oprogramowania nie zawierać wystarczająco dużo czasu dla takich kosztów, jak przetwarzanie surowego korespondencji seryjnej, dlatego wydaje się, że spędzić kilka godzin na przesłuchanie każdego konfliktu-prawdziwy problem.

w dłuższej perspektywie, planowanie do przodu i być na bieżąco z tym, że inni pracują nad najlepsze narzędzia do przewidywania przyszłych konfliktów scalania i przygotowania do ich prawidłowego rozstrzygnięcia w krótszym czasie.


  1. określ, jakie pliki znajdują się w konflikcie (Git musi ci to powiedzieć).

  2. otwórz każdy plik i poznać różnice; git ogranicza ich. Mam nadzieję, że będzie oczywiste, z jakiej wersji każdego bloku zapisz. Być może trzeba będzie omówić to z innymi deweloperami, którzy popełnili kod.

  3. jak tylko mogę konflikt w pliku git add the_file.

  4. jak tylko mogę konflikty, zrobić git rebase --continue czy to, że zespół Git powiedział zrobić, gdy skończysz.


sprawdź odpowiedzi w kwestii przepełnienia stosu przerwa w korespondencji seryjnej w Git szczególnie odpowiedź Karola Bailey który pokazuje, jak przeglądać różne wersje pliku z problemami, np.

# Common base version of the file.
git show :1:some_file.cpp

# 'Ours' version of the file.
git show :2:some_file.cpp

# 'Theirs' version of the file.
git show :3:some_file.cpp

konflikty fuzji zdarzają się, gdy zmian dokonuje się w pliku jednocześnie. To, jak go rozwiązać.

git CLI

oto proste kroki, Co zrobić, gdy znajdziesz się w конфликтное stan:

  1. zwróć uwagę na listę konfliktu plików z:git status (z ).
  2. zezwól na konflikty oddzielnie dla każdego pliku w jednym z następujących metod:

    • użyj GUI do rozwiązania konflikty: git mergetool (najprostszy sposób).

    • aby podjąć zdalną / inną wersję, użyj:git checkout --theirs path/file. To odrzuci wszelkie lokalne zmiany, które zrobiłeś dla tego pliku.

    • aby wziąć lokalnej / naszą wersję, użyj:git checkout --ours path/file

      jednak trzeba być ostrożnym, ponieważ usunięte zmiany, które konflikty zostały wykonane z jakiegoś powodu.

      na temat: jakie jest dokładne znaczenie słów "nasze " i" ich " w drań?

    • edytuj sprzeczne pliki ręcznie i znajdź blok kodu między <<<<</>>>>> następnie wybierz wersję od góry lub od dołu =====. Zobacz:jak przedstawiono konflikty.

    • konflikty ścieżki i nazwy pliku mogą być rozwiązane za pomocą git add/git rm.

  3. wreszcie, należy przejrzeć pliki, gotowe do zatwierdzenia za pomocą:git status.

    jeśli masz jeszcze jakieś pliki pod Unmerged paths i zdecydujesz się konflikt ręcznie, a następnie poinformowanie Git, że zdecydowałeś się go:git add path/file.

  4. jeśli wszystkie konflikty zostały pomyślnie rozwiązane, zatwierdź zmiany za pomocą:git commit -a i naciśnij na pilota, jak zwykle.

Przeczytaj także: rozwiązanie konfliktu fuzji z wiersza polecenia na GitHub

DiffMerge

Ja z powodzeniem używałem DiffMerge który może wizualnie porównywać i łączyć pliki w systemie Windows, macOS i Linux/Unix.

on graficznie może wyświetlać zmiany między 3 plików i pozwala na automatyczne połączenie (kiedy to bezpiecznie zrobić) i pełną kontrolę nad edycją pliku wynikowego.

DiffMerge

obraz: DiffMerge (zrzut ekranu w systemie Linux)

wystarczy go pobrać i uruchomić w repo jak:

git mergetool -t diffmerge .

macOS

na macOS można ustawić poprzez:

brew install caskroom/cask/brew-cask
brew cask install diffmerge

i prawdopodobnie (jeśli nie przewidziano), potrzebna jest następna informacja prosta owinąć, umieszczony na drodze (np./usr/bin):

#!/bin/sh
DIFFMERGE_PATH=/Applications/DiffMerge.app
DIFFMERGE_EXE=${DIFFMERGE_PATH}/Contents/MacOS/DiffMerge
exec ${DIFFMERGE_EXE} --nosplash "[email protected]"

następnie możesz skorzystać z następujących kombinacji klawiszy:

  • -Alt -/w dół przejść do poprzedniego/następnego zmiana.
  • -Alt -lewy/prawo akceptować zmiany, z lewej lub z prawej strony

jako alternatywy można użyć opendiff (część narzędzi Xcode), która pozwala połączyć dwie pliku lub katalogu razem, aby stworzyć trzeci plik lub katalog.


jeśli robisz częste małe zmiany, zacznij od przejrzenia komentarzy zatwierdzenia z git log --merge. Wtedy git diff pokaże konfliktów.

do konfliktów, które zawierają więcej niż kilka wierszy, łatwiej zobaczyć, co dzieje się w zewnętrznym narzędziu GUI. Podoba mi się opendiff -- Git obsługuje również vimdiff, gvimdiff, kdiff3, tkdiff, łączą się, xxdiff, emerge out of the box, i można ustawić inne: git config merge.tool "your.tool" zainstaluje wybrany przez siebie instrument, a następnie git mergetool po nieudanej fuzji pokaż różnice w kontekście.

za każdym razem, gdy edytujesz plik, aby rozwiązać konflikt, git add filename zaktualizuje indeks, i twój diff więcej nie pokaże. Gdy wszystkie konflikty przetwarzane i ich pliki zostały git add-ed,git commit zakończy połączenie.


zobacz Jak Przedstawiono Konflikty lub Git,git merge dokumentacja, aby zrozumieć, co to są markery konfliktów korespondencji seryjnej.

a jak rozwiązywać konflikty sekcja wyjaśnia, jak rozwiązywać konflikty:

, widząc konflikt, można zrobić dwie rzeczy:

  • nie zdecydowała się zlewać. Jedyne czyszczenia, które są potrzebne, to skasowanie indeksu w pliku HEAD popełnić zwrotny 2. i oczyścić obszar drzewo zmian 2. i 3.;git merge --abort można użyć do tego.

  • rozwiązywać konflikty. Git będzie świętować konflikty w pracy drzewie. Edytuj pliki w formie i git add ich w indeksie. Używać git commit aby przypieczętować umowę.

możesz pracować przez konflikt z szeregiem narzędzi:

  • użyj mergetool. git mergetool do uruchomienia graficznego mergetool, który będzie prace nad scaleniem.

  • spójrz na różnice. git diff pokaże trójstronne diff, podkreślając zmiany od obu HEAD a MERGE_HEAD wersji.

  • spójrz na różnice od każdej gałęzi. git log --merge -p <path> pokaże różnice najpierw do HEAD wersja, a potem MERGE_HEAD wersja.

  • oglądaj na oryginały. git show :1:filename pokazuje wspólnego przodka, git show :2:filename zawiera HEAD wersja i git show :3:filename zawiera MERGE_HEAD wersja.

można również przeczytać o znacznikach konfliktów scalania i o tym, jak je rozwiązywać w Pro Git rozdział książki Główne Konflikty Fuzji.


Emacs użytkownicy, którzy chcą rozwiązywać konflikty fuzji pół-ręcznie:

git diff --name-status --diff-filter=U

pokazuje wszystkie pliki, które wymagają rozwiązywania konfliktów.

otwórz każdy z tych plików pojedynczo lub wszystkie na raz:

emacs $(git diff --name-only --diff-filter=U)

podczas wizyty bufora, wymaga edycji w Emacs, wprowadź

ALT+x vc-resolve-conflicts

To otworzy trzy bufora (mój, je i bufor wyjściowy). Przejdź przez naciśnięcie N (dalej region), 'p' (przewidywanie dziedzinie). Kliknij 'a' i "b", aby skopiować mój lub ich region bufor wyjściowy, odpowiednio. I / lub edytować bufor wyjściowy bezpośrednio.

kiedy skończysz: naciśnij "q". Emacs pyta, czy Chcesz zapisać ten bufor: tak. Po zakończeniu bufora oznaczyć jako rozwiązany, uruchamiając z териминала:

git add FILENAME

kiedy skończysz ze wszystkimi buforami typu

git commit

w celu zakończenia połączenia.


proszę, wykonaj następujące czynności, aby rozwiązać konflikty korespondencji seryjnej w Git:

  1. sprawdź stan Git: status git

  2. zobacz zestaw łatek: git fetch (sprawdź odpowiedni patch z git commit)

  3. sprawdzanie lokalnej gałęzi (temp1 w moim przykładzie tutaj): git checkout-b temp1

  4. ciągnąć niedawny zawartość od mistrza: git pull --rebase origin master

  5. uruchom mergetool i sprawdź konflikty i popraw je...i sprawdź zmiany w zdalnej gałęzi z bieżącą gałęzią: git mergetool

  6. sprawdź stan jeszcze raz: status git

  7. usuwanie niepożądanych plików, lokalnie utworzonych mergetool, zwykle mergetool tworzy dodatkowy plik z *.rozszerzenie oryg. Usuń ten plik, tak jak to tylko duplikat i popraw zmiany lokalnie i dodaj odpowiednią wersję swoich plików. git add #your_changed_correct_files

  8. sprawdź stan jeszcze raz: status git

  9. aby zatwierdzić wprowadzone zmiany w tym samym identyfikatorze zatwierdzenia (pozwala to uniknąć nowego oddzielnego zestawu poprawek): commits --zmiany

  10. kliknij w gałęzi master: git push (w repozytorium Git)


po prostu, jeśli dobrze wiesz, że zmiany w jednym z repozytoriów nie są ważne, i chcesz zezwolić na wszystkie zmiany na korzyść innego, użyj:

git checkout . --ours

zezwól na zmiany na korzyść magazyn lub

git checkout . --theirs

zezwól na zmiany na korzyść więcej lub główne repozytorium.

czy trzeba wykorzystywać narzędzie do korespondencji seryjnej GUI do przechodzenia plików jeden po drugim, powiedzmy, narzędzie scalania p4merge, lub napisz dowolną nazwę, która jest już zainstalowana

git mergetool -t p4merge

i po zakończeniu pliku, będziesz musiał zapisać i zamknąć, tak, że następny pojawi.


Ja albo chcę swoją lub ich wersji w całości, czy chcę zobaczyć poszczególne zmiany i rozwiązania dla każdego z nich.

w pełni zaakceptować moją lub ich wersji:

weź moją wersję (lokalną, naszą):

git checkout --ours -- <filename>
git add <filename>              # Marks conflict as resolved
git commit -m "merged bla bla"  # An "empty" commit

weź je w wersji zdalnej, ich):

git checkout --theirs -- <filename>
git add <filename>
git commit -m "merged bla bla"

jeśli chcesz zrobić dla wszystkich plików konfliktów run:

git merge --strategy-option ours

lub

git merge --strategy-option theirs

przejrzyj wszystkie zmiany i należy je indywidualnie

  1. git mergetool
  2. przejrzyj zmiany i zapoznać się dowolną wersję dla każdego z nich.
  3. git add <filename>
  4. git commit -m "merged bla bla"

domyślny mergetool działa wiersz polecenia. Jak korzystać z wiersza polecenia mergetool musi być osobna kwestia.

można również ustawić narzędzie wizualne do tego, na przykład,meld pracować

git mergetool -t meld

będzie otwórz lokalną wersję (naszą), "podstawowe" lub "połączoną" wersję (aktualny wynik fuzji) i usuniętych wersji (ich). Zapisz połączoną wersję, po zakończeniu uruchom git mergetool -t meld ponownie, aż pojawi się "brak plików nie trzeba połączenie", a następnie przejdź do kroku 3. i 4.


można rozwiązać konflikty fuzji kilka sposobów, jak opisano bardziej szczegółowo w innych.

myślę, że prawdziwym kluczem wie, jak zmiany zachodzą z lokalnych i zdalnych repozytoriach. Kluczem jest zrozumienie gałęzi śledzenia. Odkryłem, że myślę o gałęzie śledzenia jak o "brakujące części w środku" pomiędzy moim lokalnym, aktualnym katalogiem plików i zdalnym, który jest zdefiniowany jako origin.

Ja osobiście wszedł w nawyk 2 rzeczy, aby pomóc uniknąć temu.

zamiast:

git add .
git commit -m"some msg"

, który ma dwie wady -

a) wszystkie nowe/zmienione pliki są dodawane, a to może obejmować niektóre niechciane zmiany.
b) nie można najpierw wyświetlić listę plików.

więc zamiast tego robię:

git add file,file2,file3...
git commit # Then type the files in the editor and save-quit.

w ten sposób można bardziej świadomie o tym, które pliki są dodawane, można także wyświetlić listę i pomyśleć trochę więcej, za pomocą edytora wiadomości. Uważam, że jest to również poprawia moją utrwalenie wiadomości, gdy używam pełnoekranowy edytor, a nie .

[aktualizuj - czas minął, przeszedłem więcej na:

git status # Make sure I know whats going on
git add .
git commit # Then use the editor

]

poza tym (i bardziej właściwe w danej sytuacji), staram się unikać:

git pull

lub

git pull origin master.

bo pull oznacza scalanie, i jeśli masz zmiany lokalnie, które nie chcą się łączyć, można łatwo uzyskać wspólny kod i / lub konflikty korespondencji seryjnej do kodu, który nie powinien być zlany.

zamiast tego staram się zrobić

git checkout master
git fetch   
git rebase --hard origin/master # or whatever branch I want.

można również znaleźć przydatne:

gałąź git, widelec, zbieranie, łączenie, relokacja i klonowanie, jakie są różnice?


bonus:

mówiąc o pull / fetch / merge w powyższych odpowiedziach, chciałbym podzielić się ciekawym i wydajne reklamowym,

git pull --rebase

ta drużyna wyżej-najbardziej przydatne zespół w moim życiu git, który uratował wiele czasu.

przed kliknięciem twoje ostatnio dokonane zmiany na zdalny serwer, spróbuj git pull --rebase a git pull i instrukcje merge i automatycznie synchronizuje ostatnie zmiany zdalnego serwera (z próbką + merge)i umieści swoją lokalną ostatnie zatwierdzenie górze w dzienniku git. Nie musisz się martwić o ręcznym ciągnięciu / fuzji.

w przypadku konfliktu, wystarczy użyć

git mergetool
git add conflict_file
git rebase --continue

znajdź szczegóły na stronie:http://gitolite.com/git-pull--rebase


odpowiedź CoolAJ86 streszcza prawie wszystko. Jeśli masz zmiany w obu gałęziach w jednym i tym samym fragmencie kodu, trzeba będzie wykonać ręczne scalanie. Otwórz plik w konflikcie w dowolnym edytorze tekstu, a zobaczysz następującą strukturę.

(Code not in Conflict)
>>>>>>>>>>>
(first alternative for conflict starts here)
Multiple code lines here
===========
(second alternative for conflict starts here)
Multiple code lines here too    
<<<<<<<<<<<
(Code not in conflict here)

Wybierz jedną z opcji lub kombinacji obu tak, jak chcesz, aby nowy kod został, usuwając równe znaki i nawiasy.

git commit -a -m "commit message"
git push origin master

git log --merge -p [[--] path]

wygląda na to, że nie zawsze działa na mnie i zwykle kończy się wyświetleniem każdego zatwierdzenia, która różniła się pomiędzy dwiema gałęziami, dzieje się tak nawet przy użyciu -- oddzielić drogę od drużyny.

co mam zrobić, aby obejść ten problem, to otworzyć dwie zespołowe wiersze i jeden

git log ..$MERGED_IN_BRANCH --pretty=full -p [path]

inne

git log $MERGED_IN_BRANCH.. --pretty=full -p [path]

wymiana $MERGED_IN_BRANCH z gałęzią połączyłem się i [path] z plikiem, który jest w konflikcie. Ten zespół będzie rejestrować wszystkie commity, w formie patcha, między (..) dwa zatwierdzenia. Jeśli zostawisz jedną stronę pustą, jak w zespołach powyżej, git automatycznie użyje HEAD (gałąź, w której łączą się w tym przypadku).

to pozwoli ci zobaczyć, jakie zmiany weszły w plik w dwóch gałęziach, po tym, jak się rozstali. Zwykle jest to ułatwia rozwiązywanie konfliktów.


według stanu na dzień 12 grudnia 2016 roku, można połączyć oddziały i rozwiązywać konflikty na github.com

w ten sposób, jeśli nie chcesz korzystać z wiersza polecenia lub wszystkie narzędzia innych firm, które są oferowane tutaj ze starych odpowiedzi, idź z rodziną narzędzia GitHub.

ten blog szczegółowo wyjaśnia, ale podstawy w tym, że po "fuzji" dwóch gałęzi przez interfejs zobaczysz opcję "zezwalaj na konflikty", która przeniesie cię do edytora co pozwala mieć do czynienia z tymi konfliktami korespondencji seryjnej.

enter image description here


masz 3 kroki:

  1. znajdź pliki, które powodują konflikty w zespole,

    git status
    
  2. Sprawdź pliki, w których znajdziesz konflikty, oznaczone jako

    <<<<<<<<head
    blablabla
    
  3. zmień go tak, jak chcesz, a następnie zamocować za pomocą polecenia

    git add solved_conflicts_files
    git commit -m 'merge msg'
    

za pomocą patience

jestem zaskoczony, że nikt nie mówi o rozwiązaniu konfliktu za pomocą patience Z rekurencyjnej strategii fuzji. Dla dużego konfliktu fuzji użyj patience dało dobre rezultaty dla mnie. Pomysł w tym, że on próbuje dopasować bloki, a nie poszczególne linie.

jeśli zmienić wcięcie programu, na przykład, strategia fuzji Git domyślnie czasami odpowiada na jednym rysunku nawiasów { który należy do różnych funkcji. Ten unikaj patience:

git merge -s recursive -X patience other-branch

z dokumentacji:

With this option, merge-recursive spends a little extra time to avoid 
mismerges that sometimes occur due to unimportant matching lines 
(e.g., braces from distinct functions). Use this when the branches to 
be merged have diverged wildly.

porównanie z wspólnym przodkiem

jeśli masz konflikt scalania i chcesz zobaczyć, co inni mieli na uwadze przy zmianie swojej gałęzi, czasami łatwiej jest porównać ich gałąź bezpośrednio ze wspólnym przodkiem (zamiast naszej gałęzi). W tym celu można użyć merge-base:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch>

zwykle chcesz zobaczyć zmiany tylko dla konkretnego plik:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file>

zawsze starałem się poniższymi krokami, aby uniknąć konfliktów.

  • git checkout master (przyjdź mistrz-oddział)
  • git pull (zaktualizuj kreatora, aby uzyskać najnowszy kod)
  • git checkout - b mybranch (Sprawdź nowy wątek a i zacznij pracować nad tą gałęzią, aby twój mistrz był zawsze na wierzchu tułowia.)
  • git add . I git commit i git push (w lokalnej gałęzi po twoich zmian)
  • git checkout master (powrót do twego Pana.)

teraz możesz zrobić to samo i zachować jak najwięcej lokalnych oddziałów, ile chcesz, i pracować jednocześnie, gdy jest to konieczne.


jeśli chcesz połączyć z gałęzi (test) w master, można wykonać następujące czynności:

Krok 1: Przejdź do gałęzi

git checkout test

Krok 2: git pull --rebase origin master

Krok 3: Jeśli istnieją pewne konflikty, przejdź do tych plików, aby go zmienić.

Krok 4: Dodaj te zmiany

git add #your_changes_files

Krok 5: git rebase --continue

Krok 6: jeśli konflikt nadal istnieje, wróć do kroku 3 ponownie. Jeśli nie ma konfliktu, wykonaj następujące czynności:git push origin +test

Krok 7: I wtedy nie ma konfliktu między zadaniami i mistrzem. Można użyć merge bezpośrednio.


konflikty korespondencji seryjnej mogą wystąpić w różnych sytuacjach:

  • po uruchomieniu "git fetch", a następnie"git merge"
  • po uruchomieniu "git fetch", a następnie"git rebase"
  • po uruchomieniu "git pull" (który w rzeczywistości jest równy jednemu z wyżej wymienionych warunków)
  • po uruchomieniu "git stash pop"
  • po zastosowaniu poprawek git (mocowania, które są eksportowane pliki do wysłania, na przykład, za pomocą e-mail)

trzeba zainstalować narzędzie do korespondencji seryjnej, który jest kompatybilny z Git do rozstrzygania konfliktów. Ja osobiście używam KDiff3, i znalazłem go przyjemne i wygodne. Można go pobrać wersję Windows tutaj:

https://sourceforge.net/projects/kdiff3/files/

BTW jeśli instalujesz dany Git, w kreatorze instalacji jest opcja dla zabudowy Kdiff3.

a następnie ustaw git configs do użytku Kdiff jako mergetool:

$ git config --global --add merge.tool kdiff3
$ git config --global --add mergetool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add mergetool.kdiff3.trustExitCode false

$ git config --global --add diff.guitool kdiff3
$ git config --global --add difftool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add difftool.kdiff3.trustExitCode false

(pamiętaj, aby zastąpić drogę faktycznym poprzez plik exe Kdiff.)

za każdym razem, gdy masz do czynienia z konfliktem korespondencji seryjnej, trzeba tylko uruchomić to polecenie:

$git mergetool

następnie otwiera Kdiff3 i najpierw próbuje rozwiązywać konflikty fuzji automatycznie. Większość konfliktów są dozwolone spontanicznie, i trzeba naprawić reszta ręcznie.

oto, co wygląda Kdiff3 na przykład:

Enter image description here

następnie, kiedy skończysz, zapisz plik i przechodzi do następnego pliku z konfliktem i robisz to samo jeszcze raz, aż wszystkie konflikty zostaną rozwiązane.

aby sprawdzić, czy wszystko jest połączone z powodzeniem, po prostu uruchom polecenie mergetool jeszcze raz, musisz uzyskać ten wynik:

$git mergetool
No files need merging

To są odpowiedzi, aby dodać alternatywę dla tych użytkowników VIM, jak ja, które wolą robić w Edytorze.


TL; DR

enter image description here


Tpope wpadł na ten świetny plugin do VIM pod nazwą uciekinier. Po zainstalowaniu możesz uruchomić :Gstatus aby sprawdzić, czy pliki, które mają konflikt i :Gdiff aby otworzyć Git 3 sposoby korespondencji seryjnej.

razem w 3-drodze fuzji, uciekinier pozwoli ci uzyskać zmiany w każdej z gałęzi, które można połączyć w następujący sposób:

  • :diffget //2, zobacz zmiany od oryginału (rozdział oddział):
  • :diffget //3, zobacz zmiany od seryjnej gałęzie:

po zakończeniu scalania pliku, typu :Gwrite w wielkiej buforze. Vimcasts wydali świetny wideo szczegółowo wyjaśniając te kroki.


git fetch
git checkout twój oddział
PIP relokacji kreator

na tym etapie można próbować rozwiązać konflikt za pomocą preferowany IDE

możesz przejść na ten link, aby sprawdzić, ho, aby rozwiązać konflikt w file
https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

git add
PIP relokacji -- mów dalej!--2--> git commit --amend
git push origin HEAD: refs / robocze / master (kliknij, jako wersje robocze)

teraz wszystko jest w porządku, a znajdziesz swoje umocowanie w gerrit

Mam nadzieję, że to pomoże każdemu w tej sprawie.


spróbuj Visual Studio do edycji, jeśli jeszcze nie. To, co robi, to po próbie połączenie(i przeniesiony w konflikty korespondencji seryjnej).VS code automatycznie wykrywa konflikty korespondencji seryjnej.

To może pomóc bardzo dobrze, pokazując, jakie zmiany wprowadzono w oryginalny i czy należy podjąć incoming lub

current change(co oznacza, że oryginał przed scaleniem)'?.

to pomogło mi i to może pracować dla ciebie !

PS: To będzie działać tylko jeśli skonfigurowałeś git za pomocą kodu i kodu Visual Studio.


dla każdego, kto korzysta z Visual Studio (2015 w moim przypadku)

  1. zamknij swój projekt w VS. Zwłaszcza w dużych projektach VS ma tendencję do się martwić w połączeniu z użyciem interfejsu użytkownika.

  2. scalić w wierszu polecenia.

    git checkout target_branch

    PIP fuzji имя_ветки

  3. następnie otwórz projekt w VS i przejdź w programie Team Explorer -> Branch. Teraz jest komunikat, w którym czytamy, że Merge oczekujące i sprzeczne pliki są wymienione bezpośrednio pod wiadomością.

  4. kliknij skonfliktowany plik, i masz możliwość połączyć, porównaj ceny, wziąć źródło, wziąć na cel. Narzędzie korespondencji seryjnej w VS jest bardzo łatwy w obsłudze.


jeśli używasz intelliJ jako IDE Spróbuj połączyć parent z twojej gałęzią

git checkout <localbranch>
git merge origin/<remotebranch>

pokaże wszystkie konflikty, jak to

A_MBPro: test ANU$ git merge origin / automatyczne scalenie src / test / java / pl/.../TestClass klasy.konflikt java (zawartość): konflikt w korespondencji seryjnej src / test / java / pl/.../TestClass klasy.java

teraz zwróć uwagę, że plik TestClass.java jest wyświetlana na czerwono w intelliJ Również status git pokaże

Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified:   src/test/java/com/.../TestClass.java

otwórz plik w intelliJ, będzie miał partycje

  <<<<<<< HEAD
    public void testMethod() {
    }
    =======
    public void testMethod() { ...
    }
    >>>>>>> origin/<remotebranch>

gdzie głowa zmienia się na lokalny oddział i pochodzenia/ zmiany ze zdalnej oddziału. Tutaj należy przechowywać to, czego potrzebujesz, i usuń to, że nie trzeba.Po tym powinny być wykonane zwykłe czynności. Czyli

   git add TestClass.java
   git commit -m "commit message"
   git push

stosuję się do następującego procesu.

proces poprawki konfliktu korespondencji seryjnej:

  1. po pierwsze, wyciągnąć ostatnią z gałęzi docelowej, do której chcesz się połączyć git pull origin develop

  2. jak masz najnowszą z powołania, teraz mogę konflikt ręcznie w IDE, usuwając te dodatkowe znaki.

  3. git add aby dodać te zmodyfikowane pliki w kolejności git, aby mogła być commit a push w ten sam oddział, nad którym pracujesz.

  4. As git add gotowe, dodać git commit w celu zatwierdzenia zmian.

  5. kliknij teraz zmiany w środowisku gałęzi git push origin HEAD

to on, a zobaczysz, że jest dozwolone w zapytaniu pull, jeśli używasz Bitbucket lub GitHub.


bardziej bezpieczny sposób rozwiązywania konfliktów-użyć git-mediate (ogólne rozwiązania oferowane tutaj, dość podatne na błędy imho).

zobacz ten post do szybkiego wejścia o tym, jak go używać.


git checkout branch1

git fetch origin

git rebase -p origin/mainbranch

Jeśli istnieją konflikty korespondencji seryjnej, je naprawić. Następnie kontynuować proces relokacji, wykonując:git rebase –-continue

po zatwierdzeniu można zablokować i nacisnąć swoją lokalną gałąź na zdalną gałąź

git push origin branch1