Subukan: git mergetool

Binubuksan nito ang graphical na interface na tumatakbo sa bawat conflict, at maaari mong piliin kung paano pagsamahin. Minsan ito ay nangangai>

Ayon sa komento ng @JoshGlover:

Ang utos ay hindi kinakai>git mergetool para sa akin ay humantong sa paggamit ng vimdiff . Maaari mong i-install ang isa sa mga sumusunod na tool upang gamitin ito sa halip: meld , opendiff , kdiff3 , tkdiff , xxdiff , tortoisemerge , gvimdiff , diffuse , ecmerge , p4merge , araxis , vimdiff , emerge .

Nasa ibaba ang isang halimbawa ng pamamaraan para sa paggamit ng vimdiff upang malutas ang pagsasalungat ng pagsamahin. Sa pamamagitan ng link na ito

Hakbang 1 : Patakbuhin ang sumusunod na mga utos sa iyong terminal

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

Itatakda nito ang vimdiff bi>

Hakbang 2 : Patakbuhin ang sumusunod na command sa terminal

 git mergetool 

Hakbang 3 : Makakakita ka ng isang vimdiff display sa sumusunod na format.

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

Ang mga 4 na uri na ito

Ang LOKAL ay ang file mula sa kasalukuyang sangay.

BASE - isang karaniwang ninuno, kung paano ang file ay tumingin bago ang parehong mga pagbabago

REMOTE - isang file na sinu-link mo sa iyong sangay

MERGED - ang resulta ng pagsama-sama, ito ang nakaimbak sa repo

Maaari kang mag-navigate sa pagitan ng mga pananaw na ito gamit ang ctrl+w Maaari kang pumunta nang direkta sa MERGED view gamit ang ctrl+w and j .

Higit pang impormasyon tungkol sa vimdiff navigation dito at dito.

Hakbang 4 Maaari mong i-edit ang MERGED gaya ng mga sumusunod.

Kung nais mong makatanggap ng mga pagbabago mula sa REMOTE

 :diffg RE 

Kung gusto mong makatanggap ng mga pagbabago mula sa BASE

 :diffg BA 

Kung nais mong makatanggap ng mga pagbabago mula sa LOCAL

 :diffg LO 

Hakbang 5 I- save, lumabas, i-lock at i-clear

:wqa save at lumabas vi

git commit -m "message"

git clean Tanggalin ang mga hindi kinakai>

Narito ang isang maaaring mangyari precedent, mula sa itaas:

Magagawa mo ang i>

 git fetch origin git pull origin master From ssh://gitosis@example.com:22/projectname * branch master -> FETCH_HEAD Updating a030c3a..ee25213 error: Entry 'filename.c' not uptodate. Cannot merge. 

Kaya, nag-a-update ka at subukang muli, ngunit mayroon kang isang salungatan:

 git add filename.c git commit -m "made some wild and crazy changes" git pull origin master From ssh://gitosis@example.com: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. 

Kaya nagpasya kang tingnan ang mga pagbabago:

 git mergetool 

Oh, ako, oh, ako, sa itaas ng agos ay nagbago ng i>

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

At pagkatapos ay subukan namin ang huling oras.

 git pull origin master From ssh://gitosis@example.com:22/projectname * branch master -> FETCH_HEAD Already up-to-date. 

Ta-da!

Nakita ko na ang mga kasangkapan sa pagsamahin ay bihirang makatulong sa akin na maunawaan ang salungatan o resolusyon. Karaniwan akong mukhang matagumpay sa mga marker ng labanan sa isang text editor at gumagamit ng git log bi>

Narito ang i>

Konseho isa

Ang pinakamainam na nakita ko ay ang paggamit ng estilo ng diff3 ng pagsalungat sa pagsali:

git config merge.conflictstyle diff3

Lumilikha ito ng mga marker ng labanan tulad nito:

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

Ang gitnang bahagi ay kung paano ang karaniwang ninuno ay tumingin. Ito ay kapaki-pakinabang dahil maaari mong ihambing ito sa itaas at mas mababang mga bersyon upang mas mahusay na maunawaan kung ano ang nabago sa bawat branch, na nagbibigay sa iyo ng isang mas mahusay na ideya kung ano ang layunin ng bawat pagbabago.

Kung ang kontrahan ay binubuo lamang ng i>

Kung mas matagal ang labanan, pinutol at idikit ko ang bawat isa sa tatlong seksyon sa tatlong hiwalay na mga file, tulad ng "minahan", "karaniwang", at "kanila".

Pagkatapos ay maaari kong patakbuhin ang mga sumusunod na utos upang makita ang dalawang sitwasyon na naging dahilan ng labanan:

 diff common mine diff common theirs 

Hindi ito kapareho ng paggamit ng tool na sumanib, dahil ang kasangkapang merge ay magsasama ng lahat ng di-magkasalungat na diff-hunks. Nakita ko ito nakagagambala.

Tip dalawang

May nabanggit na ito, ngunit ang pag-unawa sa layunin sa bawat salitang diff ay kadalasan ay kapaki-pakinabang para sa pag-unawa kung saan nagmula ang conflict at kung paano ito haharapin.

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

Ito ay nagpapakita ng lahat ng mga gumawa na nababahala ang file na ito sa pagitan ng isang karaniwang ninuno at dalawang ulo na pagsasama mo. (Samakatuwid, hindi ito kasama ang mga kalakal na umiiral na sa parehong mga sanga bago ang pagsasama.) Ito ay tumutulong upang huwag pansinin ang mga pagkakaiba na malinaw na hindi isang salik sa iyong kasalukuyang labanan.

Tip tatlong

Suriin ang iyong mga pagbabago sa mga automated na tool.

Kung mayroon kang mga awtomatikong pagsusuri, patakbuhin ang mga ito. Kung mayroon kang isang lint , patakbuhin ito. Kung ito ay isang proyekto sa pagtatayo, dapat itong maitayo bago mo makumpleto ito, atbp. Sa lahat ng mga kaso, kai>

Tip apat

Magplano nang maaga; makipag-usap sa mga kasamahan.

Ang pagpaplano nang maaga at ang pagkaunawa na ang iba ay nagtatrabaho ay maaaring makatulong na maiwasan ang mga pagsalungat sa pagsama-sama at / o makatulong na malutas ang mga ito nang mas maaga - habang ang mga detalye ay may kaugnayan pa rin.

Halimbawa, kung alam mo na ikaw at ang ibang tao ay nagtatrabaho sa iba't ibang mga refactorings na makakaapekto sa parehong hanay ng mga file, dapat kang makipag-usap sa isa't isa nang maaga at mas mahusay na maunawaan kung anong mga uri ng mga pagbabago ang ginagawa mo. Maaari kang mag-save ng maraming oras at pagsisikap kung isasagawa mo ang nakaplanong pagbabago sa pagliko, at hindi kahanay.

Para sa mga malalaking refactorings na tumatawid sa isang malaking piraso ng code, dapat mong sineseryoso isaa>

Kung hindi ka maaaring gumana nang tuloy-tuloy (marahil dahil sa pansamanta>

Tip limang

Kung hindi ka sigurado tungkol sa pagsama-sama, huwag pilitin ito.

Ang pagsasama ay maaaring napakalaki, lalo na kung maraming mga magkakasalungat na mga file, at ang mga marker ng labanan ay umaabot ng daan-daang mga linya. Kadalasan, kapag sinusuri ang mga proyekto ng software, hindi namin kasama ang sapat na oras para sa mga surcharge, tulad ng pagproseso ng isang mabaliw pagsama-sama, kaya nararamdaman tulad ng tunay na paglaban upang gumastos ng i>

Sa kalaunan, ang pagpaplano nang maaga at ang pagsasakatuparan na ang iba ay nagtatrabaho ay ang mga pinakamahusay na kasangkapan para sa paghula ng mga pagsasalungaling pagsama-sama at paghahanda para sa tamang solusyon sa mas kaunting oras.

• Tukuyin kung aling mga file ay nasa kontrahan (Dapat sabihin sa iyo ito ng Git).

• Buksan ang bawat file at matutunan ang mga pagkakaiba; Git demarcates sa kanila. Umaasa ako na magiging halata kung aling bersyon ng bawat bloke ang dapat panatilihin. Maaari mong talakayin ito sa iba pang mga developer na nakumpleto ang code.

• Sa sandaling nalutas mo ang kontrahan sa git add the_file file git add the_file .

• Sa oras na malutas mo ang lahat ng mga salungatan, patakbuhin ang git rebase --continue o anumang utos na sinabi ni Git kapag natapos na.

Suriin ang mga sagot sa tanong ng Abort Git Cancellation , lalo na ang Sagot ni Charles Bailey , na nagpapakita kung paano tingnan ang iba't ibang mga bersyon ng isang file ng problema, halimbawa

  100 

Nangyayari ang pagsasama ng pagkakasalungat kapag ang mga pagbabago ay ginawa sa isang file sa parehong oras. Narito kung paano malutas ito.

git CLI

Narito ang mga simpleng hakbang na kai>

• Pansinin ang listahan ng mga magkakasalungat na file: git status (sa seksyon ng Mga hindi Unmerged paths ).

• Isaayos ang mga salungatan para sa bawat file gamit ang isa sa mga sumusunod na pamamaraan:

  • Gamitin ang GUI upang malutas ang mga kontrahan: git mergetool (ang pinakamadaling paraan).

  • Upang tanggapin ang isang remote / iba pang bersyon, gamitin ang: git checkout --theirs path/file . Itatanggi nito ang anumang mga lokal na pagbabago na iyong ginawa sa file na ito.

  • Upang tanggapin ang lokal / aming bersyon, gamitin ang: git checkout --ours path/file

    ^{Gayunpaman, dapat kang maging maingat, dahil nawala ang mga natanggal na pagbabago dahil sa i>}

    Kaugnay: Ano ang eksaktong kahulugan ng "atin" at "kanila" sa git?

  • I-edit nang manu-mano ang mga magkakasalungat na file at hanapin ang block ng code sa pagitan ng <<<<< / >>>>> , pagkatapos ay piliin ang bersyon sa itaas o sa ibaba ===== . Tingnan: Paano ipinakikita ang mga salungatan .

  • Maaaring malutas ang mga salungat sa pangalan ng path at file na may git add / git rm .

• Panghuli, suriin ang mga file na handa nang gumawa ng paggamit: git status .

  Kung mayroon ka pa ring mga file sa ilalim ng mga Unmerged paths , at malutas mo ang labanan nang manu-mano, pagkatapos ay ipaalam sa Git na malutas mo ito: git add path/file .

• Kung matagumpay na nalutas ang lahat ng mga salungatan, kopyahin ang mga pagbabago: git commit -a at mag-click sa tinanggal na bi>

Tingnan din ang: Paglutas ng pagsasalungat sa pagsama mula sa command line sa GitHub

DiffMerge

Matagumpay kong ginamit ang DiffMerge , na maaaring makatarungan na ihambing at pagsamahin ang mga file sa Windows, macOS at Linux / Unix.

Ito ay graphically nagpapakita ng mga pagbabago sa pagitan ng 3 mga file at nagbibigay-daan sa awtomatikong merging (kapag ito ay ligtas) at ganap na kontrol sa pag-edit ng mga nagresultang file.

2019

Kung gumawa ka ng mga madalas na maliit na gumawa, magsimula sa pamamagitan ng pagtingin sa mga komento ng commit sa git log --merge . Pagkatapos git diff ay magpapakita sa iyo ng mga salungatan.

Para sa mga salungatan na kinapapalooban ng maraming linya, mas madaling makita kung ano ang nangyayari sa panlabas na tool ng GUI. Gusto ko ng opendiff - Sinusuportahan din ng Git ang vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff, lumabas sa kahon, at maaari mong i-install ang iba: git config merge.tool "your.tool" i-install ang iyong piniling tool at pagkatapos git mergetool pagkatapos ng hindi matagumpay Ang pagsasama ay magpapakita sa iyo ng mga pagkakaiba sa konteksto.

Sa bawat oras na mag-edit ka ng isang file upang malutas ang isang salungatan, git add filename ang mga index, at ang iyong diff ay hindi na ipapakita ito. Kapag ang lahat ng mga salungatan ay naproseso at ang kani>git add ed, ang git commit ay makukumpleto ang pagsasama.

Tingnan kung Paano Inihahatid ang mga Salungat o sa Git, ang git merge dokumentasyon, upang maunawaan kung ano ang mga marker ng kontrahan sa pag-aaway.

Bi>Paano lutasin ang seksyon ng mga kontrahan ay nagpapaliwanag kung paano malutas ang mga salungatan:

Matapos tingnan ang kontrahan, maaari mong gawin ang dalawang bagay:

• Magpasiya na huwag magsama. Ang tanging mga cleaner na kai>HEAD para sa kabaligtaran na transform 2. at para sa pag-clear ng mga pagbabago sa pagtatrabaho sa village na ginawa sa 2. at 3; git merge --abort ay maaaring gamitin para sa mga ito.

• Lutasin ang mga kontrahan. Itatala ng Git ang mga kontrahan sa puno ng trabaho. I-edit ang mga file sa form at git add ito sa index. Gamitin git commit upang seal ng isang pakikitungo.

Maaari kang magtrabaho nang labag sa i>

• Gamitin ang mergetool. git mergetool upang magpatakbo ng isang graphical mergetool na gagana sa pamamagitan ng isang sumanib.

• Tingnan ang mga pagkakaiba. git diff nagpapakita ng isang tatlong panig na diff, na nagpapakita ng mga pagbabago mula sa parehong mga MERGE_HEAD ng HEAD at MERGE_HEAD .

• Tingnan ang mga pagkakaiba sa pagitan ng bawat sangay. git log --merge -p <path> ay magpapakita ng diff muna para sa bersyon ng HEAD at pagkatapos ay ang bersyon ng MERGE_HEAD .

• Tingnan ang mga orihinal. git show :1:filename nagpapakita ng karaniwang ninuno, git show :2:filename nagpapakita ng bersyon ng HEAD , at git show :3:filename nagpapakita ng bersyon ng MERGE_HEAD .

Maaari mo ring basahin ang tungkol sa tatak ng pagsasalungat ng pagsamahin at kung paano malutas ang mga ito sa seksyon ng Pro Git Main Merge Conflicts.

Para sa mga Emacs, ang mga gumagamit na gustong lutasin ang mga di-manu-manong pagsasalungat ng mga manu-manong pagsasama:

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

Nagpapakita ng lahat ng mga file na nangangai>

Buksan ang bawat isa sa mga file nang isa-isa o lahat nang sabay-sabay:

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

Kapag bumibisita sa isang buffer na nangangai>

 ALT+x vc-resolve-conflicts 

Bubuksan nito ang tatlong buffers (minahan, sila at ang output buffer). Mag-navigate sa pamamagitan ng pagpindot sa "n" (susunod na lugar), "p" (lugar ng prediksyon). Pindutin ang "a" at "b" upang kopyahin ang aking o ang iyong lugar sa output buffer, ayon sa pagkakabanggit. At / o i-edit ang output buffer nang direkta.

Kapag natapos: pindutin ang "q". Hinihiling sa iyo ng Emacs kung gusto mong i-save ang buffer na ito: oo. Kapag nakumpleto na ang buffer, markahan ito bi>

 git add FILENAME 

Ang pagkakaroon ng tapos na nagtatrabaho sa lahat ng mga uri ng mga buffers

 git commit 

upang makumpleto ang sumanib.

Nais kong alinman sa aking bersyon o ang kani>

Ganap na tanggapin ang aking o ang kani> :

Tanggapin ang aking bersyon (lokal, aming):

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

Tanggapin ang kani>

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

Kung gusto mong gawin para sa lahat ng mga magkakasalungat na file, patakbuhin ang:

 git merge --strategy-option ours 

o

 git merge --strategy-option theirs 

Repasuhin ang lahat ng mga pagbabago at tanggapin ang mga ito nang isa-isa.

1. git mergetool
2. Suriin ang mga pagbabago at tanggapin ang anumang bersyon para sa bawat isa sa kanila.
3. git add <filename>
4. git commit -m "merged bla bla"

Bi>mergetool sa command line . Kung paano gamitin ang linya ng command ng mergetool ay dapat na isang hiwalay na isyu.

Maaari ka ring mag-install ng visual tool para dito, halimbawa, meld at patakbuhin

 git mergetool -t meld 

Ang lokal (ating), "pangunahing" o "pinag-isang" na bersyon (ang kasalukuyang resulta ng pagsasama) at ang mga remote (s) ay bubuksan. I-save ang pinagsamang bersyon kapag tapos na, patakbuhin ang git mergetool -t meld hanggang sa makuha mo ang "Hindi mo na kai>

Mangyaring kumpletuhin ang sumusunod na mga hakbang upang ayusin ang pagsasalungat ng pagsamahin sa git:

1. Suriin ang Status ng Git : Katayuan ng Git

2. Kunin ang patch na set: git fetch (lagyan ng tsek ang tamang patch mula sa iyong git commit)

3. I-extract ang lokal na branch (sa aking halimbawa, temp1): git checkout -b temp1

4. I-extract ang kamakai>git pull --rebase origin master

5. Patakbuhin ang mergetool, suriin ang mga kontrahan at ayusin ang mga ito ... at suriin ang mga pagbabago sa remote branch gamit ang iyong kasalukuyang sangay: git mergetool

6. Suriin muli ang status: git status

7. Tanggalin ang mga hindi kinakai>git idagdag ang #your_changed_correct_files

8. Suriin muli ang status: git status

9. Ipagpatuloy ang mga pagbabago sa parehong tagatukoy (iniiwasan nito ang isang bagong hiwalay na hanay ng mga pag-aayos): git commit - pinapalitan

10. Push to master branch: git push (sa iyong Git repository)

Maglagay lamang, kung alam mong mabuti na ang mga pagbabago sa isa sa mga repository ay hindi mahalaga, at nais mong pahintulutan ang lahat ng mga pagbabago sa pabor ng iba, gamitin ang:

 git checkout . --ours 

payagan ang mga pagbabago sa pabor sa iyong imbakan , o

 git checkout . --theirs 

payagan ang mga pagbabago sa pabor sa isa o pangunahing repository .

O kai>p4merge sa mga file, sabihin, ang p4merge merge, o isulat ang anumang pangalan na iyong naitakda.

 git mergetool -t p4merge 

at pagkatapos makumpleto ang file ay kai>

Maaari mong ayusin ang pagsasalungat ng pagsamahin sa maraming paraan, tulad ng detalyado ng iba.

Sa tingin ko ang tunay na susi ay ang pag-alam kung paano nagbabago ang mga pagbabago sa mga lokal at remote na repository. Ang susi dito ay nauunawaan ang mga sangay ng pagsubaybay. Natagpuan ko na sa tingin ko ang sangay ng pagsubaybay bi>

Ako mismo ay gumamit ng dalawang bagay upang makatulong na maiwasan ito.

Sa halip na:

 git add . git commit -m"some msg" 

Ano ang dalawang kaku>

a) Ang lahat ng mga bagong / binagong mga file ay idinagdag at maaaring maglaman ng i> b) Hindi mo muna makita ang listahan ng mga file.

Kaya sa halip:

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

Sa ganitong paraan, ikaw ay higit na sadyang tinatalakay kung aling mga file ang idinagdag, at maaari mo ring mag-scroll sa listahan at sa tingin ng kaunti pa gamit ang editor para sa mensahe. Nalaman ko na pinapabuti rin nito ang aking mga mensahe ng gumawa kapag ginamit ko ang full-screen editor, sa halip na -m opsyon.

[I-update - sa paglipas ng panahon, lumipat ako nang higit pa sa:

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

]

Gayundin (at mas naaangkop para sa iyong sitwasyon), sinisikap kong maiwasan:

 git pull 

o

 git pull origin master.