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




git-merge merge-conflict-resolution (20)

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

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

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

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

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

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

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


बोनस:

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

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


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

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

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

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


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

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

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


CoolAJ86 का जवाब काफी कुछ सब कुछ बताता है। यदि आपके पास कोड के उसी टुकड़े में दोनों शाखाओं में परिवर्तन हैं तो आपको मैन्युअल विलय करना होगा। फ़ाइल को किसी भी टेक्स्ट एडिटर में संघर्ष में खोलें और आपको निम्न संरचना देखना चाहिए।

(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)

बराबर संकेतों और कोण ब्रैकेट को हटाते समय, विकल्पों में से एक या दोनों के संयोजन को एक तरह से चुनें कि आप नया कोड होना चाहते हैं।

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

आप विलय विवादों को कई तरीकों से ठीक कर सकते हैं जैसे अन्य ने विस्तृत किया है।

मुझे लगता है कि वास्तविक कुंजी यह जानती है कि स्थानीय और रिमोट रिपोजिटरी के साथ परिवर्तन कैसे होते हैं। इसकी कुंजी ट्रैकिंग शाखाओं को समझना है। मैंने पाया है कि मैं ट्रैकिंग शाखा के बारे में सोचता हूं कि मेरे मध्य, वास्तविक फाइल निर्देशिका और रिमोट को मूल के रूप में परिभाषित किया गया है।

इस से बचने में मदद के लिए मैंने व्यक्तिगत रूप से 2 चीजों की आदत में प्रवेश किया है।

के बजाय:

git add .
git commit -m"some msg"

जिसमें दो दोष हैं -

ए) सभी नई / बदली गई फाइलें जुड़ती हैं और इसमें कुछ अवांछित परिवर्तन शामिल हो सकते हैं।
बी) आप पहले फ़ाइल सूची की समीक्षा नहीं करते हैं।

तो इसके बजाय मैं करता हूं:

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

इस तरह आप अधिक जानबूझकर हैं कि कौन सी फाइलें जुड़ती हैं और आप सूची की समीक्षा भी करते हैं और संदेश के लिए संपादक का उपयोग करते समय थोड़ा और सोचते हैं। मुझे लगता है कि जब मैं -m विकल्प के बजाय एक पूर्ण स्क्रीन संपादक का उपयोग करता हूं तो यह मेरे प्रतिबद्ध संदेशों में भी सुधार करता है।

[अद्यतन - जैसे ही समय बीत चुका है मैंने और अधिक स्विच किया है:

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

]

इसके अलावा (और आपकी स्थिति के लिए अधिक प्रासंगिक), मैं इससे बचने की कोशिश करता हूं:

git pull

या

git pull origin master.

क्योंकि पुल एक विलय का तात्पर्य है और यदि आपने स्थानीय रूप से परिवर्तन किया है कि आप विलय नहीं करना चाहते हैं तो आप विलय कोड के साथ आसानी से समाप्त हो सकते हैं और / या कोड के लिए संघर्ष विलय कर सकते हैं जो विलय नहीं किया जाना चाहिए था।

इसके बजाय मैं करने की कोशिश करता हूं

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

आपको यह सहायक भी मिल सकता है:

गिट शाखा, कांटा, fetch, विलय, rebase और क्लोन, मतभेद क्या हैं?


देखें कि संघर्ष कैसे प्रस्तुत किए जाते हैं या, गिट में, गिट विवाद दस्तावेज को समझने के लिए 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 संस्करण दिखाता है।

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


बस, अगर आप अच्छी तरह जानते हैं कि किसी एक संग्रह में परिवर्तन महत्वपूर्ण नहीं है, और दूसरे के पक्ष में सभी परिवर्तनों को हल करना चाहते हैं, तो इसका उपयोग करें:

git checkout . --ours

अपने भंडार के पक्ष में परिवर्तनों को हल करने के लिए, या

git checkout . --theirs

दूसरे या मुख्य भंडार के पक्ष में परिवर्तन को हल करने के लिए।

अन्यथा आपको फ़ाइलों के माध्यम से एक-एक करके कदम उठाने के लिए एक GUI मर्ज टूल का उपयोग करना होगा, मर्ज टूल p4merge , या किसी भी नाम का नाम लिखें जिसे आपने पहले से इंस्टॉल किया है

git mergetool -t p4merge

और एक फ़ाइल को खत्म करने के बाद, आपको सहेजना और बंद करना होगा, इसलिए अगला खुल जाएगा।


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

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

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

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 log --merge साथ प्रतिबद्ध टिप्पणियों को देखकर शुरू करें। फिर git diff आपको संघर्ष दिखाएगा।

उन संघर्षों के लिए जिनमें कुछ पंक्तियों से अधिक शामिल है, बाहरी जीयूआई उपकरण में क्या हो रहा है यह देखना आसान है। मुझे opendiff पसंद है - गिट भी vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff का समर्थन करता है, बॉक्स से बाहर निकलता है और आप दूसरों को इंस्टॉल कर सकते हैं: git config merge.tool "your.tool" आपके चुने हुए टूल को सेट करेगा और फिर git config merge.tool "your.tool" असफल विलय के बाद आपको संदर्भ में अंतर दिखाई देगा।

प्रत्येक बार जब आप किसी विवाद को हल करने के लिए फ़ाइल संपादित करते हैं, तो git add filename इंडेक्स को अपडेट करेगा और आपका diff अब इसे नहीं दिखाएगा। जब सभी विवादों को संभाला जाता है और उनकी फाइलें git add एड होती हैं, तो git commit आपके विलय को पूरा कर लेगी।


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

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 "[email protected]"

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

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

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


स्टैक ओवरफ़्लो प्रश्न में उत्तरों को देखें गिट में विलय को छोड़कर, विशेष रूप से चार्ल्स बेली का जवाब जो दिखाता है कि फ़ाइल के विभिन्न संस्करणों को समस्याओं के साथ कैसे देखना है, उदाहरण के लिए,

# 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

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

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

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

    गिट चेकआउट target_branch

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

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

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


कोशिश करें: git mergetool

यह एक जीयूआई खोलता है जो आपको प्रत्येक संघर्ष के माध्यम से कदम देता है, और आप यह चुनने के लिए चुनते हैं कि कैसे विलय करना है। कभी-कभी इसे बाद में थोड़ा संपादन करने की आवश्यकता होती है, लेकिन आम तौर पर यह स्वयं ही पर्याप्त है। यह निश्चित रूप से हाथ से पूरी चीज करने से काफी बेहतर है।

@JoshGlover टिप्पणी के अनुसार:

आदेश तब तक एक जीयूआई नहीं खोलता जब तक आप एक स्थापित नहीं करते। मेरे लिए git mergetool चल रहा है जिसके परिणामस्वरूप vimdiff इस्तेमाल किया जा रहा है। आप इसके बजाय इसका उपयोग करने के लिए निम्न में से एक टूल इंस्टॉल कर सकते हैं: meld , opendiff , kdiff3 , tkdiff , xxdiff , tortoisemerge , gvimdiff , ecmerge , p4merge , araxis , araxis , vimdiff , emerge

हल विलय विवादों के लिए vimdiff का उपयोग करने के लिए नमूना प्रक्रिया नीचे दी गई है। इस लिंक के आधार पर

चरण 1 : अपने टर्मिनल में निम्न आदेश चलाएं

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

यह vimdiff को डिफ़ॉल्ट मर्ज टूल के रूप में सेट करेगा।

चरण 2 : टर्मिनल में निम्न आदेश चलाएं

git mergetool

चरण 3 : आपको निम्न प्रारूप में एक विमडिफ डिस्प्ले दिखाई देगा

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

ये 4 विचार हैं

स्थानीय - यह वर्तमान शाखा से फाइल है

आधार - सामान्य पूर्वज, दोनों परिवर्तनों से पहले फ़ाइल को कैसे देखा जाता था

रिमोट - फाइल जो आप अपनी शाखा में विलय कर रहे हैं

मर्ज किया गया - परिणाम विलय करें, यह रेपो में सहेजा जाता है

आप ctrl+w का उपयोग करके इन विचारों के बीच नेविगेट कर सकते हैं। आप jtrl के बाद ctrl+w का उपयोग करके सीधे मर्ज किए गए दृश्य तक पहुंच सकते हैं।

here और here vimdiff नेविगेशन के बारे में अधिक जानकारी

चरण 4 । आप निम्नलिखित तरीके से मर्ज किए गए दृश्य को संपादित कर सकते हैं

यदि आप रिमोट से परिवर्तन प्राप्त करना चाहते हैं

:diffg RE  

यदि आप BASE से परिवर्तन प्राप्त करना चाहते हैं

:diffg BA  

यदि आप स्थानीय से परिवर्तन प्राप्त करना चाहते हैं

:diffg LO 

चरण 5 । सहेजें, बाहर निकलें, प्रतिबद्ध करें और साफ़ करें

:wqa बचाओ और बाहर निकलें

git commit -m "message"

git clean डिफ टूल द्वारा बनाई गई अतिरिक्त फ़ाइलों को निकालें (जैसे * .orig)।


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

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

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


यदि आप IntelliJ का उपयोग IDE के रूप में कर रहे हैं तो माता-पिता को अपनी शाखा में विलय करने का प्रयास करें

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

यह इस तरह के सभी संघर्ष दिखाएगा

A_MBPro: परीक्षण anu $ git विलय मूल / ऑटो-विलयिंग src / test / java / com /.../ TestClass.java CONFLICT (सामग्री): src / test / java / com /.../ TestClass.java में विवाद विलय करें

अब ध्यान दें कि फ़ाइल TestClass.java intelliJ में लाल रंग में दिखाया गया है इसके अलावा गिट स्थिति भी दिखाई देगी

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

IntelliJ में फ़ाइल खोलें, इसमें अनुभाग होंगे

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

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

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

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

टी एल; डॉ

वीएम के लिए fugitive नामक इस महान प्लगइन के साथ टोपोप आया । एक बार इंस्टॉल हो जाने पर आप उन :Gstatusफ़ाइलों की जांच करने के लिए दौड़ सकते हैं जिनमें विवाद है और :Gdiff3 तरीकों से गिट खोलने के लिए गेट खोलें।

एक बार 3-तरीकों में विलय करने के बाद, भाग्यशाली आपको निम्न शाखाओं में विलय कर रहे किसी भी शाखा के परिवर्तन प्राप्त करने देगा:

  • :diffget //2, मूल ( HEAD ) शाखा से परिवर्तन प्राप्त करें :
  • :diffget //3 , विलय शाखा से परिवर्तन प्राप्त करें:

एक बार जब आप फ़ाइल विलय कर लेते हैं, :Gwriteतो मर्ज किए गए बफर में टाइप करें । विमकास्ट ने इस कदम को विस्तार से समझाते हुए एक महान video जारी किया ।


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

  • "गिट 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

विवादों को हल करने का एक सुरक्षित तरीका git-mediate का उपयोग करना है (यहां सुझाए गए सामान्य समाधान काफी त्रुटि प्रवण इम्हो हैं)।

इसका उपयोग कैसे करें इसका त्वरित परिचय के लिए इस पोस्ट को देखें ।


git checkout branch1

git fetch origin

git rebase -p origin/mainbranch

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

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

git push origin branch1




git-conflict-resolution