git गिट में विलय विवादों को कैसे हल करें





15 Answers

शीर्ष पर एक संभावित उपयोग-केस यहां दिया गया है:

आप कुछ बदलाव खींचने जा रहे हैं, लेकिन ओह, आप अद्यतित नहीं हैं:

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.

तो आप अद्यतित हो जाते हैं और पुनः प्रयास करते हैं, लेकिन एक संघर्ष है:

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.

तो आप परिवर्तनों पर नज़र डालने का फैसला करते हैं:

git mergetool

ओह, ओह, अपस्ट्रीम ने कुछ चीजें बदल दीं, लेकिन सिर्फ मेरे परिवर्तनों का उपयोग करने के लिए ... नहीं ... उनके परिवर्तन ...

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

और फिर हम अंतिम बार कोशिश करते हैं

git pull origin master

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

टा-दा!

git git-merge merge-conflict-resolution git-conflict-resolution

क्या गिट में विलय विवादों को हल करने का तरीका समझाने का एक अच्छा तरीका है?




  1. पहचानें कि कौन सी फाइलें संघर्ष में हैं (गिट आपको यह बताना चाहिए)।

  2. प्रत्येक फ़ाइल खोलें और diffs की जांच करें; गिट उन्हें बताता है। उम्मीद है कि यह स्पष्ट होगा कि प्रत्येक ब्लॉक का कौन सा संस्करण रखना है। आपको कोड करने वाले साथी डेवलपर्स के साथ चर्चा करने की आवश्यकता हो सकती है।

  3. एक बार जब आप फ़ाइल git add the_file में संघर्ष को हल कर लेते git add the_file

  4. एक बार जब आप सभी विवादों का समाधान कर लेंगे, तो git rebase --continue या जो भी कमांड गिट ने पूरा किया, जब आपने पूरा किया।




संघर्ष विलय तब होता है जब एक ही समय में एक फ़ाइल में परिवर्तन किए जाते हैं। यहां हल करने का तरीका बताया गया है।

git सीएलआई

जब आप विवादित स्थिति में जाते हैं तो सरल कदम यहां दिए गए हैं:

  1. विवादित फ़ाइलों की सूची नोट करें: git status ( Unmerged paths अनुभाग के तहत)।
  2. प्रत्येक फ़ाइल के लिए अलग-अलग दृष्टिकोणों में से एक द्वारा विवादों को अलग-अलग हल करें:

    • विवादों को हल करने के लिए जीयूआई का प्रयोग करें: git mergetool (सबसे आसान तरीका)।

    • दूरस्थ / अन्य संस्करण को स्वीकार करने के लिए, git checkout --theirs path/file । यह उस फ़ाइल के लिए किए गए किसी भी स्थानीय परिवर्तन को अस्वीकार कर देगा।

    • स्थानीय / हमारे संस्करण को स्वीकार करने के लिए, git checkout --ours path/file

      हालांकि आपको सावधान रहना होगा, क्योंकि रिमोट चेंज के कारण कुछ कारणों से संघर्ष किए गए थे।

      संबंधित: गिट में "हमारा" और "उनका" का सटीक अर्थ क्या है?

    • विवादित फ़ाइलों को मैन्युअल रूप से संपादित करें और <<<<< / >>>>> बीच कोड ब्लॉक देखें, फिर संस्करण को ऊपर या नीचे ===== । देखें: कैसे विवाद प्रस्तुत किए जाते हैं

    • पथ और फ़ाइल नाम विवादों को git add / git rm द्वारा हल किया जा सकता है।

  3. अंत में, git status का उपयोग कर प्रतिबद्ध करने के लिए तैयार फ़ाइलों की समीक्षा करें।

    यदि आपके पास अभी भी Unmerged paths किए Unmerged paths तहत कोई भी फाइल है, और आपने मैन्युअल रूप से संघर्ष को हल किया है, तो गिट को यह पता चले कि आपने इसे हल किया है: git add path/file

  4. यदि सभी विवादों को सफलतापूर्वक हल किया गया था, तो परिवर्तनों को प्रतिबद्ध करें: git commit -a और सामान्य रूप से रिमोट पर धक्का दें।

यह भी देखें: गिटहब में कमांड लाइन से मर्ज विवाद को हल करना

DiffMerge

मैंने सफलतापूर्वक DiffMerge उपयोग किया है जो विंडोज, मैकोज़ और लिनक्स / यूनिक्स पर फ़ाइलों की दृष्टि से तुलना और विलय कर सकता है।

यह ग्राफिक रूप से 3 फाइलों के बीच परिवर्तन दिखा सकता है और यह स्वचालित विलय (ऐसा करने के लिए सुरक्षित होने पर) और परिणामी फ़ाइल को संपादित करने पर पूर्ण नियंत्रण की अनुमति देता है।

छवि स्रोत: DiffMerge (लिनक्स स्क्रीनशॉट)

बस इसे डाउनलोड करें और रेपो में चलाएं:

git mergetool -t diffmerge .

मैक ओ एस

मैकोज़ पर आप इसके माध्यम से स्थापित कर सकते हैं:

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

और शायद (अगर प्रदान नहीं किया गया है) तो आपको अपने पाथ में दिए गए अतिरिक्त अतिरिक्त सरल आवरण की आवश्यकता है (उदाहरण के लिए /usr/bin ):

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

फिर आप निम्न कीबोर्ड शॉर्टकट का उपयोग कर सकते हैं:

  • - Alt / ऊपर / नीचे पिछले / अगले परिवर्तनों पर कूदने के लिए।
  • - Alt - बाएं / दाएं से परिवर्तन स्वीकार करने के लिए बाएं / दाएं

वैकल्पिक रूप से आप opendiff ( opendiff टूल्स का हिस्सा) का उपयोग कर सकते हैं जो आपको एक तिहाई फ़ाइल या निर्देशिका बनाने के लिए दो फाइलों या निर्देशिकाओं को एक साथ मर्ज करने देता है।




देखें कि संघर्ष कैसे प्रस्तुत किए जाते हैं या, गिट में, गिट विवाद दस्तावेज को समझने के लिए git merge दस्तावेज मर्ज करते हैं।

साथ ही, संघर्ष खंड को हल करने का तरीका बताता है कि संघर्षों को कैसे हल किया जाए:

एक संघर्ष देखने के बाद, आप दो चीजें कर सकते हैं:

  • विलय न करने का फैसला करें। आपको केवल एकमात्र सफाई-अप इंडेक्स फ़ाइल को HEAD प्रतिबद्ध करने के लिए रीवर्स 2 पर रीसेट करना है और 2. और 3 द्वारा किए गए काम करने वाले पेड़ परिवर्तनों को साफ करना है। git merge --abort इस के लिए उपयोग किया जा सकता है।

  • संघर्षों को हल करें। गिट कामकाजी पेड़ में संघर्ष को चिह्नित करेगा। फ़ाइलों को आकार में संपादित करें और git add उन्हें इंडेक्स में git add । सौदे को सील git commit लिए git commit का प्रयोग करें।

आप कई उपकरणों के साथ संघर्ष के माध्यम से काम कर सकते हैं:

  • एक mergetool का प्रयोग करें। एक ग्राफिकल git mergetool लॉन्च करने के लिए git mergetool जो आपको विलय के माध्यम से काम करेगा।

  • Diffs को देखो। git diff एक तीन-तरफा diff दिखाएगा, दोनों HEAD और MERGE_HEAD संस्करणों में परिवर्तन को हाइलाइट MERGE_HEAD

  • प्रत्येक शाखा से भिन्नता को देखो। git log --merge -p <path> संस्करण के लिए पहले और फिर MERGE_HEAD संस्करण के लिए diffs दिखाएगा।

  • मूल पर देखो। git show :1:filename आम पूर्वजों को git show :2:filename , git show :2:filename HEAD संस्करण दिखाता है, और git show :3:filename MERGE_HEAD संस्करण दिखाता है।

आप विवाद चिह्न मार्करों को मर्ज करने और प्रो गिट बुक सेक्शन बेसिक मर्ज टकराव में उन्हें हल करने के बारे में भी पढ़ सकते हैं।




गिट में विवाद विवादों को ठीक करने के लिए कृपया निम्नलिखित चरणों का पालन करें:

  1. गिट स्थिति की जांच करें: गिट स्थिति

  2. पैचसेट प्राप्त करें: गिट फ़ेच (अपने गिट प्रतिबद्ध से दाएं पैच को चेकआउट करें)

  3. एक स्थानीय शाखा चेकआउट करें (यहां मेरे उदाहरण में temp1): गिट चेकआउट -बी temp1

  4. मास्टर से हाल की सामग्री खींचें: गिट पुल --rebase मूल मास्टर

  5. Mergetool शुरू करें और संघर्ष की जांच करें और उन्हें ठीक करें ... और अपनी वर्तमान शाखा के साथ रिमोट शाखा में परिवर्तन की जांच करें: git mergetool

  6. स्थिति फिर से जांचें: गिट स्थिति

  7. स्थानीय रूप से mergetool द्वारा बनाई गई अवांछित फ़ाइलों को हटाएं, आमतौर पर mergetool * .orig एक्सटेंशन के साथ अतिरिक्त फ़ाइल बनाता है। कृपया उस फ़ाइल को हटाएं क्योंकि यह केवल डुप्लिकेट है और स्थानीय रूप से परिवर्तनों को ठीक करता है और आपकी फ़ाइलों का सही संस्करण जोड़ता है। गिट जोड़ें #your_changed_correct_files

  8. स्थिति फिर से जांचें: गिट स्थिति

  9. एक ही प्रतिबद्ध आईडी में परिवर्तनों को प्रतिबद्ध करें (यह एक नया अलग पैच सेट से बचाता है): गिट प्रतिबद्ध - भेजें

  10. मास्टर शाखा में पुश करें: गिट पुश (अपने गिट भंडार में)




मैं या तो मेरा या उनका संस्करण पूरी तरह से चाहता हूं, या व्यक्तिगत परिवर्तनों की समीक्षा करना चाहता हूं और उनमें से प्रत्येक के लिए निर्णय लेना चाहता हूं।

पूरी तरह से मेरे या उनके संस्करण को स्वीकार करें :

मेरा संस्करण स्वीकार करें (स्थानीय, हमारा):

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

उनके संस्करण को स्वीकार करें (रिमोट, उनके):

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

यदि आप सभी संघर्ष फ़ाइलों के लिए करना चाहते हैं:

git merge --strategy-option ours

या

git merge --strategy-option theirs

सभी परिवर्तनों की समीक्षा करें और उन्हें व्यक्तिगत रूप से स्वीकार करें

  1. git mergetool
  2. परिवर्तनों की समीक्षा करें और उनमें से प्रत्येक के लिए संस्करण स्वीकार करें।
  3. git add <filename>
  4. git commit -m "merged bla bla"

डिफ़ॉल्ट mergetool कमांड लाइन में काम करता है। कमांड लाइन मेरेटूल का उपयोग कैसे करें एक अलग सवाल होना चाहिए।

आप इसके लिए दृश्य उपकरण भी इंस्टॉल कर सकते हैं, उदाहरण के लिए meld चलाएं

git mergetool -t meld

यह स्थानीय संस्करण (हमारा), "आधार" या "विलय" संस्करण (विलय का वर्तमान परिणाम) और दूरस्थ संस्करण (उनके) को खोल देगा। जब आप समाप्त कर लें तो मर्ज किए गए संस्करण को सहेजें, git mergetool -t meld जब तक आपको "कोई फाइल विलय करने की आवश्यकता नहीं है" तब तक मिल जाए, फिर चरण 3 और 4 पर जाएं।




बोनस:

उपरोक्त उत्तरों में पुल / फ़ेच / मर्ज करने की बात करते हुए, मैं एक दिलचस्प और उत्पादक चाल साझा करना चाहता हूं,

git pull --rebase

यह उपरोक्त आदेश मेरे गिट जीवन में सबसे उपयोगी कमांड है जो बहुत समय बचाता है।

रिमोट सर्वर में अपने नए प्रतिबद्ध परिवर्तन को धक्का देने से पहले, git pull --rebase को git pull और मैन्युअल merge और यह स्वचालित रूप से नवीनतम रिमोट सर्वर परिवर्तनों (एक fetch + विलय के साथ) को सिंक करेगा और आपके स्थानीय नवीनतम प्रतिबद्धता को गिट में शीर्ष पर रखेगा लॉग इन करें। मैन्युअल पुल / विलय के बारे में चिंता करने की आवश्यकता नहीं है।

संघर्ष के मामले में, बस उपयोग करें

git mergetool
git add conflict_file
git rebase --continue

यहां विवरण प्राप्त करें: http://gitolite.com/git-pull--rebase




3 कदम हैं:

  1. खोजें कि कौन सी फाइलें कमांड द्वारा विवाद का कारण बनती हैं

    git status
    
  2. फाइलों की जांच करें, जिसमें आपको चिह्नित संघर्ष मिलेगा

    <<<<<<<<head
    blablabla
    
  3. इसे जिस तरह से आप चाहते हैं उसे बदलें, फिर कमांड के साथ प्रतिबद्ध करें

    git add solved_conflicts_files
    git commit -m 'merge msg'
    



12 दिसंबर 2016 तक, आप शाखाओं को मर्ज कर सकते हैं और github.com पर संघर्ष हल कर सकते हैं

इस प्रकार, यदि आप पुराने उत्तरों से यहां दी गई कमांड लाइन या किसी तीसरे पक्ष के टूल का उपयोग नहीं करना चाहते हैं, तो गिटहब के मूल उपकरण के साथ जाएं।

यह ब्लॉग पोस्ट विस्तार से बताता है, लेकिन मूल बातें यह है कि यूआई के माध्यम से दो शाखाओं को 'विलय' करने पर, अब आप एक 'समाधान विवाद' विकल्प देखेंगे जो आपको एक विलय विवादों से निपटने की अनुमति देने वाले संपादक को ले जाएगा।




मैं हमेशा संघर्ष से बचने के लिए नीचे दिए गए चरणों का पालन करता हूं।

  • गिट चेकआउट मास्टर (मास्टर शाखा में आएं)
  • गिट पुल (नवीनतम कोड प्राप्त करने के लिए अपने मास्टर को अपडेट करें)
  • गिट चेकआउट -बी mybranch (एक नई शाखा चेकआउट करें और उस शाखा पर काम करना शुरू करें ताकि आपका मास्टर हमेशा ट्रंक के शीर्ष पर बने रहे।)
  • गिट जोड़ें और गिट प्रतिबद्ध और गिट पुश (आपके परिवर्तन के बाद आपकी स्थानीय शाखा पर)
  • गिट चेकआउट मास्टर (अपने मास्टर पर वापस आएं।)

अब आप वही कर सकते हैं और जितनी चाहें उतनी स्थानीय शाखाएं बनाए रख सकते हैं और साथ ही साथ काम करते समय मेरी शाखा में गिट चेकआउट कर सकते हैं।




विभिन्न स्थितियों में संघर्ष विलय हो सकता है:

  • "गिट fetch" चलाते समय और फिर "गिट विलय"
  • "गिट फ़ेच" चलाते समय और फिर "गिट रिबेस"
  • "गिट पुल" चलाते समय (जो वास्तव में उपर्युक्त शर्तों में से एक के बराबर है)
  • "गिट स्टैश पॉप" चलाते समय
  • जब आप गिट पैच लगा रहे हैं (जो कि फ़ाइलों को स्थानांतरित करने के लिए निर्यात किया जाता है, उदाहरण के लिए, ईमेल द्वारा)

आपको विलय को स्थापित करने के लिए गिट के साथ संगत एक मर्ज टूल इंस्टॉल करने की आवश्यकता है। मैं व्यक्तिगत रूप से KDiff3 का उपयोग करता हूं, और मुझे यह अच्छा और आसान लगता है। आप यहां अपने विंडोज संस्करण को डाउनलोड कर सकते हैं:

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

बीटीडब्ल्यू अगर आप गिट एक्सटेंशन इंस्टॉल करते हैं तो Kdiff3 को स्थापित करने के लिए अपने सेटअप विज़ार्ड में एक विकल्प है।

फिर Kdiff को इसके 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

(Kdiff exe फ़ाइल के वास्तविक पथ के साथ पथ को प्रतिस्थापित करना याद रखें।)

फिर हर बार जब आप मर्ज विवाद में आते हैं तो आपको बस यह आदेश चलाने की आवश्यकता होती है:

$git mergetool

फिर यह Kdiff3 खोलता है, और पहले विलय विवादों को स्वचालित रूप से हल करने का प्रयास करता है। अधिकांश संघर्षों को स्वचालित रूप से हल किया जाएगा और आपको बाकी को मैन्युअल रूप से ठीक करने की आवश्यकता है।

यहां बताया गया है कि केडीएफ 3 कैसा दिखता है:

फिर एक बार पूरा हो जाने के बाद, फ़ाइल को सहेजें और यह विवाद के साथ अगली फाइल पर जाता है और जब तक सभी संघर्ष हल नहीं हो जाते हैं तब तक आप वही काम करते हैं।

यह जांचने के लिए कि क्या सबकुछ सफलतापूर्वक विलय हो गया है, बस फिर से mergetool कमांड चलाएं, आपको यह परिणाम प्राप्त करना चाहिए:

$git mergetool
No files need merging



गिट fetch
गिट चेकआउट अपने शाखा
गिट रिबेस मास्टर

इस चरण में आप अपने पसंदीदा आईडीई का उपयोग करके संघर्ष को ठीक करने का प्रयास करेंगे

आप फ़ाइल में संघर्ष को ठीक करने के लिए हो चेक करने के लिए इस लिंक का अनुसरण कर सकते हैं
https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

गिट
गिट रीबेज जोड़ें - कॉन्टिन्यू
गिट प्रतिबद्ध - सेंड
गिट पुश उत्पत्ति हेड: रेफरी / ड्राफ्ट / मास्टर (ड्राफ्ट की तरह धक्का)

अब हर चीज ठीक है और आपको अपनी प्रतिबद्धता गेटिट में मिल जाएगी

मुझे आशा है कि इससे इस मुद्दे से संबंधित हर किसी की मदद मिलेगी।




उन लोगों के लिए जो विजुअल स्टूडियो (मेरे मामले में 2015) का उपयोग कर रहे हैं

  1. वीएस में अपनी परियोजना बंद करें। विशेष रूप से बड़ी परियोजनाओं में वीआई यूआई का उपयोग करते हुए विलय करते समय बाहर निकलता है।

  2. कमांड प्रॉम्प्ट में विलय करें।

    गिट चेकआउट target_branch

    गिट मर्ज स्रोत_ब्रैंच

  3. फिर वीएस में प्रोजेक्ट खोलें और टीम एक्सप्लोरर -> शाखा पर जाएं। अब एक संदेश है जो कहते हैं कि मर्ज लंबित है और विवादित फाइलें संदेश के ठीक नीचे सूचीबद्ध हैं।

  4. विवादित फ़ाइल पर क्लिक करें और आपके पास मर्ज करने, तुलना करने, स्रोत लेने, लक्ष्य लेने का विकल्प होगा। वीएस में विलय उपकरण का उपयोग करना बहुत आसान है।




मैं नीचे की प्रक्रिया का पालन करता हूं।

विलय संघर्ष को ठीक करने की प्रक्रिया:

  1. सबसे पहले, गंतव्य शाखा से नवीनतम खींचें जिसमें आप विलय करना चाहते हैं git pull origin develop

  2. जैसे ही आप गंतव्य से नवीनतम प्राप्त करते हैं, अब उन अतिरिक्त वर्णों को हटाकर आईडीई में मैन्युअल रूप से संघर्ष को हल करें।

  3. एक है git addGit कतार में इन संपादित फ़ाइलें जोड़ने के लिए इतना है कि यह हो सकता है commitऔर pushएक ही शाखा में आप पर काम कर रहे हैं।

  4. जैसा git addकि किया गया है, git commitपरिवर्तन करने के लिए एक करें।

  5. अब परिवर्तनों को अपनी कार्यरत शाखा में दबाएं git push origin HEAD

यह है और यदि आप बिटबकेट या गिटहब का उपयोग कर रहे हैं तो आप इसे अपने पुल अनुरोध में हल करेंगे।




git checkout branch1

git fetch origin

git rebase -p origin/mainbranch

यदि मर्ज विवाद हैं, तो उन्हें ठीक करें। फिर, चलकर रीबेस प्रक्रिया जारी रखें:git rebase –-continue

फिक्सिंग के बाद आप अपनी स्थानीय शाखा को दूरस्थ शाखा में प्रतिबद्ध और धक्का दे सकते हैं

git push origin branch1



Related