पाठ का अंश

मर्ज संघर्ष: घबराएं नहीं — समझें और हल करें

मर्ज संघर्ष नए लोगों को डराते हैं, लेकिन इस खंड के बाद आप उन्हें शांति से सामना करेंगे। हम समझेंगे कि संघर्ष क्यों होते हैं (Git मन नहीं पढ़ सकता — वह नहीं जानता कि किसका बदलाव अधिक महत्वपूर्ण है), संघर्ष चिह्नों को कैसे पढ़ें और सही समाधान कैसे चुनें। हम दो दृष्टिकोण दिखाएंगे: मैन्युअल समाधान और मर्ज उपकरणों का उपयोग।

मर्ज संघर्ष संघर्ष चिह्न संघर्ष समाधान
इस पाठ में आप क्या सीखेंगे
  • आप मर्ज संघर्षों की प्रकृति समझ जाएंगे और उनसे डरना छोड़ देंगे — वे पूर्वानुमानित हो जाएंगे।
  • आप Git चिह्नों को सही ढंग से पढ़कर स्वयं मैन्युअल रूप से संघर्ष हल कर पाएंगे।
  • आप अपने संपादक में मर्ज उपकरण को दृश्य संघर्ष समाधान के लिए कॉन्फ़िगर करना सीखेंगे।

पाठ की शुरुआत

मर्ज संघर्ष के तीन प्रकार

  • सामग्री संघर्ष: समान पंक्तियों में बदलाव
  • नाम परिवर्तन: फ़ाइल का नाम बदला और संपादित किया
  • हटाना: एक शाखा में फ़ाइल हटा दी गई, दूसरी में संशोधित
  • नाम परिवर्तन Git के लिए सबसे मुश्किल होते हैं
  • संदिग्ध संघर्षों पर फ़ाइल का इतिहास जाँचें

कल्पना करें कि आप एक महत्वपूर्ण प्रोजेक्ट पर काम कर रहे हैं, और अचानक Git संघर्ष की सूचना देता है। समाधान का पहला कदम उसके प्रकार को समझना है। सामग्री संघर्ष तब होते हैं जब बदलाव विभिन्न शाखाओं में समान पंक्तियों को प्रभावित करते हैं। नाम परिवर्तन के मामले में मुश्किल होती है: एक डेवलपर फ़ाइल का नाम बदलता है, जबकि दूसरा उसी समय उसकी सामग्री संपादित करता है। तीसरा प्रकार हटाना है, जब एक शाखा में फ़ाइल गायब हो जाती है, लेकिन दूसरी में जीवित रहती है। नाम परिवर्तन सबसे अधिक जटिलताएँ पैदा करते हैं, क्योंकि Git हमेशा नाम बदलने के बाद फ़ाइल के इतिहास को सही ढंग से ट्रैक नहीं करता है। इसलिए संदिग्ध संघर्षों पर हमेशा फ़ाइलों के परिवर्तन इतिहास की जाँच करें।

जटिल संघर्ष की शारीरिक रचना

  • <<<<<<< चिह्न आपके बदलाव दिखाते हैं
  • ======= आपके और दूसरे के संस्करण को अलग करता है
  • >>>>>>> संघर्ष ब्लॉक के अंत को चिह्नित करता है
  • git status सभी समस्या फ़ाइलें दिखाएगा
  • git diff — बदलावों की विस्तृत तुलना

मान लीजिए आप feature शाखा को main में मर्ज कर रहे हैं और संघर्ष का संदेश देखते हैं। समस्या फ़ाइलें खोलें — आपको विशेष चिह्न दिखाई देंगे। 7 < HEAD और 7 = के बीच का सब कुछ आपके बदलाव हैं। 7 = और 7 > feature के बीच — मर्ज की जा रही शाखा से बदलाव। git status का उपयोग करके सभी संघर्षित फ़ाइलें देखें, और git diff का उपयोग विस्तृत अंतर देखने के लिए करें। याद रखें: चिह्न कोई त्रुटि नहीं, बल्कि संकेत हैं कि कहाँ निर्णय लेना है।

#!/bin/bash
# संघर्ष_विश्लेषण.sh

echo "टेस्ट रिपॉजिटरी बना रहे हैं"
mkdir conflict-demo && cd conflict-demo
git init

echo "फ़ाइल बना रहे हैं और main में पहला कमिट"
echo 'Line 1' > file.txt
echo 'Line 2' >> file.txt
git add . && git commit -m 'Initial commit'

echo "feature शाखा बना रहे हैं और पहली पंक्ति बदल रहे हैं"
git checkout -b feature
sed -i 's/Line 1/Line 1 modified in feature/' file.txt
git commit -am 'Modify line 1 in feature'

echo "main पर वापस आ रहे हैं और उसी पंक्ति को बदल रहे हैं"
git checkout main
sed -i 's/Line 1/Line 1 modified in main/' file.txt
git commit -am 'Modify line 1 in main'

echo "शाखाओं को मर्ज करने का प्रयास कर रहे हैं"
git merge feature || echo 'संघर्ष!'

echo "\nस्थिति देख रहे हैं:"
git status --short

echo "\nसंघर्षित फ़ाइल दिखा रहे हैं:"
cat file.txt

संघर्ष समाधान की रणनीतियाँ

  • मैन्युअल संपादन: चिह्न हटाएँ, आवश्यक भाग रखें
  • GUI टूल: meld, kdiff3 दृश्य तुलना के लिए
  • --ours/--theirs: अपना या दूसरे का संस्करण स्वीकार करें
  • rebase के दौरान प्रत्येक कमिट के लिए संघर्ष हल करें
  • समाधान के बाद git add और git commit न भूलें

जब संघर्ष का पता चलता है, तो आपके पास कई रास्ते होते हैं। आप फ़ाइल को मैन्युअल खोलकर संपादित कर सकते हैं, चिह्न हटाकर और आवश्यक कोड रखकर। दृश्य प्रकार के लिए meld या kdiff3 जैसे टूल उपयुक्त हैं — वे फ़ाइल के तीन संस्करण एक साथ दिखाते हैं। यदि आप अपने बदलावों के प्रति आश्वस्त हैं, तो git checkout --ours का उपयोग करके अपना संस्करण रखें, या --theirs का उपयोग करके दूसरे का। खासकर rebase के दौरान सतर्क रहें: यहाँ प्रत्येक कमिट पर संघर्ष हो सकता है जिसे रीबेस किया जा रहा है।

#!/bin/bash
# समाधान_रणनीतियाँ.sh

echo "तरीका 1: मैन्युअल समाधान"
echo 'फ़ाइल संपादित करें, संघर्ष चिह्न हटाएँ'
echo 'फिर निष्पादित करें: git add file.txt'

echo "\nतरीका 2: हमारा संस्करण स्वीकार करें"
git checkout --ours file.txt

echo "\nतरीका 3: उनका संस्करण स्वीकार करें"
git checkout --theirs file.txt

echo "\nतरीका 4: मर्ज टूल का उपयोग करें"
echo 'git mergetool --tool=meld'

echo "\nतरीका चुनने के बाद मर्ज पूरा करें:"
echo 'git commit -m "मर्ज संघर्ष हल करें"'

पूरा पाठ सदस्यता के साथ उपलब्ध है

पूर्ण संस्करण में 34 और स्लाइड्स हैं।

वीडियो, सभी स्लाइड्स, नोट्स, टेस्ट, AI ट्यूटर और इंटरव्यू लॉगिन करने और सदस्यता लेने के बाद खुलेंगे।

लॉग इन या रजिस्टर करें सदस्यता लें

पाठ की सामग्री सूची

  1. मर्ज संघर्ष के तीन प्रकार
  2. जटिल संघर्ष की शारीरिक रचना
  3. संघर्ष समाधान की रणनीतियाँ
  4. रोकथाम और सर्वोत्तम अभ्यास
  5. Git में बहु-पंक्ति संघर्ष कैसे पढ़ें
  6. संदर्भ चिह्नों की व्याख्या
  7. नेस्टेड संघर्ष: समाधान रणनीतियाँ
  8. स्वचालन और उन्नत उपकरण
  9. चयन रणनीति: HEAD या शाखा?
  10. सबसे कम आश्चर्य का सिद्धांत
  11. सिमैंटिक संघर्ष: अदृश्य शत्रु
  12. उपकरण और स्वचालन
  13. उपकरण का चयन: कब क्या उपयोग करें
  14. VS Code: सेटिंग और उन्नत सुविधाएँ
  15. Beyond Compare: जटिल संघर्षों के लिए परिदृश्य
  16. Git फ्लो और ऑटोमेशन में एकीकरण
  17. .gitattributes के माध्यम से मर्ज को स्वचालित करना
  18. अपना स्वयं का मर्ज ड्राइवर लिखना
  19. Git rerere — आपका निजी सहायक
  20. उन्नत स्वचालन रणनीतियाँ
  21. बड़ी टीमों के लिए वर्कफ़्लो डिज़ाइन करना
  22. संघर्ष रोकथाम के उपकरण के रूप में कोड रिव्यू
  23. लंबे समय तक चलने वाली फीचर ब्रांचों के साथ काम करने की रणनीतियाँ
  24. संघर्ष समाधान के लिए उपकरण और स्वचालन
  25. बिना विश्लेषण के बदलाव स्वीकारने के खतरे
  26. संघर्ष समाधान की सुरक्षित रणनीतियाँ
  27. मर्ज के बाद परीक्षण: क्या जाँचें
  28. CI/CD एकीकरण और निवारक उपाय
  29. Rebase और merge के संघर्षों में क्या अंतर है?
  30. --rebase-merges के साथ काम करना
  31. क्रमिक संघर्ष समाधान की रणनीतियाँ
  32. रीबेस की उन्नत तकनीकें और डीबगिंग
  33. CI/CD गुणवत्ता नियंत्रण प्रणाली के रूप में
  34. GitHub Actions: संघर्ष जाँच
  35. Danger-JS: स्मार्ट जाँच स्वचालन
  36. CI/CD में स्वचालित संघर्ष समाधान
  37. संघर्ष: घबराहट से आत्मविश्वास की ओर

इस व्याख्यान से जुड़े लेख

इस कोर्स के सभी पाठ

  1. परिचय: शुरुआत से आत्मविश्वासी डेवलपर तक Git
  2. गिट की आवश्यकता क्यों है — और इसके बिना नौकरी क्यों नहीं मिलती
  3. Git की स्थापना और प्रारंभिक सेटअप: पहली बार चलाने की तैयारी
  4. पहला रिपॉजिटरी: git init, git add, git commit और इंडेक्स का जादू
  5. इतिहास पढ़ना: log, diff, show और पिछले बदलावों में नेविगेशन
  6. शाखाएँ: आपके कोड की समानांतर दुनिया
  7. गलतियाँ सुधारना: restore, reset, revert — सही और खतरनाक तरीके
  8. GitHub और दूरस्थ भंडार: आपका कोड क्लाउड में
  9. टीम वर्क: फ़ोर्क, फ़ीचर ब्रांच और पुल रिक्वेस्ट
  10. मर्ज संघर्ष: घबराएं नहीं — समझें और हल करें
  11. वास्तविक टीमों में Git प्रक्रियाएँ: कौन सा वर्कफ़्लो चुनें
  12. उन्नत उपकरण: rebase, stash, cherry-pick और टैग
  13. अंतिम प्रोजेक्ट: वास्तविक टीम डेवलपमेंट का अनुकरण