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



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.

टा-दा!

Question

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




I follow the below process.

The process to fix merge conflict:

  1. First, pull the latest from the destination branch to which you want to merge git pull origin develop

  2. As you get the latest from the destination, now resolve the conflict manually in IDE by deleting those extra characters.

  3. Do a git add to add these edited files to the git queue so that it can be commit and push to the same branch you are working on.

  4. As git add is done, do a git commit to commit the changes.

  5. Now push the changes to your working branch by git push origin HEAD

This is it and you will see it resolved in your pull request if you are using Bitbucket or GitHub.




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

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

  2. पैचसेट प्राप्त करें: गिट fetch (अपने गिट प्रतिबद्ध से सही पैच चेकआउट)

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

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

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

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

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

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

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

  10. मास्टर शाखा में पुश करें: गिट पुश (आपके गिट रिपोजिटरी में)




गिट fetch
git checkout your branch
git rebase master

In this step you will try to fix the conflict using your prefer IDE

You can follow this link to check ho to fix the conflict in the file
https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/

git add
git rebase --continue
git commit --amend
git push origin HEAD:refs/drafts/master (push like a drafts)

Now every thing is fine and you will find your commit in gerrit

I hope that this will help every one concerning this issue.




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

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 टूल्स का हिस्सा) का उपयोग कर सकते हैं जो आपको एक तिहाई फ़ाइल या निर्देशिका बनाने के लिए दो फाइलों या निर्देशिकाओं को एक साथ मर्ज करने देता है।




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

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

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

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




धैर्य का उपयोग करना

मुझे आश्चर्य है कि विलय रिकर्सिव रणनीति के साथ धैर्य का उपयोग करके संघर्ष को हल करने के बारे में कोई और बात नहीं की गई। बड़े विलय संघर्ष के लिए, patience का उपयोग करके मेरे लिए अच्छे परिणाम दिए गए। विचार यह है कि यह व्यक्तिगत लाइनों के बजाय ब्लॉक से मिलान करने का प्रयास करेगा।

उदाहरण के लिए यदि आप अपने प्रोग्राम का इंडेंटेशन बदलते हैं, तो डिफ़ॉल्ट गिट मर्ज रणनीति कभी-कभी एकल ब्रेसिज़ से मेल खाती है { जो विभिन्न कार्यों से संबंधित है। यह धैर्य से बचा है।

git merge -s recursive -X patience other-branch

दस्तावेज़ीकरण से:

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.

आम पूर्वजों के साथ तुलना

यदि आपके पास विलय संघर्ष है और आप देखना चाहते हैं कि उनकी शाखा को संशोधित करते समय दूसरों को क्या दिमाग में था, तो कभी-कभी आम तौर पर आम पूर्वजों (हमारी शाखा के बजाय) के साथ उनकी शाखा की तुलना करना कभी-कभी आसान होता है। इसके लिए आप merge-base उपयोग कर सकते हैं:

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

आमतौर पर, आप केवल एक विशेष फ़ाइल के लिए परिवर्तन देखना चाहते हैं:

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



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

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

इस से बचने में मदद के लिए मैंने व्यक्तिगत रूप से 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 और क्लोन, मतभेद क्या हैं?




There are 3 steps:

  1. Find which files cause conflicts by command
    git status
  1. Check the files, in which you would find the conflicts marked like

    <<<<<<<<head blablabla

  2. Change the way you want it ,then with commands

    git add solved_conflicts_files
    git commit -m 'merge msg'



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

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

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

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 पर जाएं।




  1. create a new feature branch from target branch
  2. patch in the changes from conflicting feature branch
  3. resolve conflicts in diff tool as you apply patch
  4. commit/review clean pull request
  5. Delete the branch that has a conflict.

This has always been faster and easier for me than using GiT. It is especially beneficial if changes mess up a pull request and your IDE doesn't handle GiT merges very well.




यदि आप शाखा (परीक्षा) से मास्टर तक विलय करना चाहते हैं, तो आप इन चरणों का पालन कर सकते हैं:

चरण 1: शाखा में जाओ

git checkout test

चरण 2: git pull --rebase origin master

चरण 3: यदि कुछ संघर्ष हैं, तो इन फ़ाइलों को संशोधित करने के लिए जाएं।

चरण 4: इन परिवर्तनों को जोड़ें

git add #your_changes_files

चरण 5: git rebase --continue

चरण 6: यदि अभी भी संघर्ष है, तो फिर चरण 3 पर वापस जाएं। यदि कोई संघर्ष नहीं है, तो निम्न कार्य करें: git push origin +test

चरण 7: और फिर परीक्षण और मास्टर के बीच कोई संघर्ष नहीं है। आप सीधे मर्ज का उपयोग कर सकते हैं।




If you are using intelliJ as IDE Try to merge parent to your branch by

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

It will show all conflicts like this

A_MBPro:test anu$ git merge origin/ Auto-merging src/test/java/com/.../TestClass.java CONFLICT (content): Merge conflict in src/test/java/com/.../TestClass.java

Now note that the file TestClass.java is shown in red in intelliJ Also git status will show

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

Open the file in intelliJ, it will have sections with

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

where HEAD is changes on your local branch and origin/ is changes from the remote branch. Here keep the stuff that you need and remove the stuff you don't need.After that the normal steps should do. That is

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



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

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

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




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

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




Related