गिट मर्ज संघर्ष को कैसे ठीक करें: संपूर्ण चरण-दर-चरण मार्गदर्शिका 2026

A मर्ज संघर्ष तब होता है जब Git स्वचालित रूप से परिवर्तनों को संयोजित नहीं कर सकता क्योंकि दो शाखाओं ने समान पंक्तियों को अलग-अलग तरीके से संशोधित किया है। यह सहयोग का एक सामान्य हिस्सा है – कोई त्रुटि नहीं, बस Git आपसे निर्णय लेने के लिए कह रहा है। यहां बताया गया है कि विवादों को आत्मविश्वास से कैसे हल किया जाए।

विलय संघर्ष का कारण क्या है

जब आप मर्ज करते हैं (या रीबेस करते हैं, या खींचते हैं) और दोनों शाखाओं ने फ़ाइल के एक ही हिस्से को अलग-अलग बदल दिया है, तो Git यह तय नहीं कर सकता कि कौन सा परिवर्तन रखा जाए – इसलिए यह रुक जाता है और आपसे पूछता है। आप देखेंगे:

$ git merge feature-branch
Auto-merging app.js
CONFLICT (content): Merge conflict in app.js
Automatic merge failed; fix conflicts and then commit the result.

संघर्ष मार्करों को समझना

<<<<<<< HEAD
const greeting = "Hello from main branch";
=======
const greeting = "Hi from feature branch";
>>>>>>> feature-branch

// The markers mean:
// <<<<<<< HEAD          → your current branch's version (above =======)
// =======              → divider
// >>>>>>> feature-branch → the incoming branch's version (below =======)

चरण-दर-चरण समाधान

# 1. See which files have conflicts
git status
# Unmerged paths:
#   both modified:   app.js

# 2. Open each conflicted file and find the conflict markers

# 3. Edit the file to the desired final state - choose one version,
#    combine both, or write something new. REMOVE the markers.

# Before (with markers):
<<<<<<< HEAD
const greeting = "Hello from main branch";
=======
const greeting = "Hi from feature branch";
>>>>>>> feature-branch

# After (resolved - you decided):
const greeting = "Hi from feature branch";

# 4. Stage the resolved file
git add app.js

# 5. Complete the merge
git commit           # opens editor with a default merge message, or:
git commit -m "Merge feature-branch, resolve greeting conflict"

अनेक झगड़ों का समाधान

# A file (or several) may have multiple conflict sections.
# Find them all:
grep -n "<<<<<<<" app.js       # find conflict markers

# Resolve each section, then verify none remain:
grep -rn "<<<<<<<\|=======\|>>>>>>>" .
# Should return nothing when all conflicts are resolved

# Then stage all resolved files and commit
git add .
git commit

मर्ज टूल का उपयोग करना

# Configure and use a visual merge tool (easier for complex conflicts)
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Launch the tool for conflicts
git mergetool
# VS Code (or your tool) shows current/incoming/result panes for easy resolution

# VS Code also has built-in conflict resolution - it shows
# "Accept Current / Accept Incoming / Accept Both" buttons inline

मर्ज को निरस्त करना

# If you want to cancel the merge and start over
git merge --abort
# Returns your branch to the state before the merge - nothing changed

# For a conflicted rebase:
git rebase --abort

# For a conflicted pull:
git merge --abort   # (a pull is a fetch + merge)

रीबेस के दौरान संघर्षों का समाधान

# Rebase conflicts are resolved similarly, but per-commit:
git rebase main
# CONFLICT in app.js

# 1. Resolve the conflict in the file
# 2. Stage it
git add app.js
# 3. Continue the rebase (NOT commit)
git rebase --continue
# Repeat if more commits have conflicts

संघर्षों को रोकना

• बार-बार खींचें: मुख्य शाखा के साथ वर्तमान रहने से मतभेद और टकराव कम हो जाते हैं
• छोटी, केंद्रित प्रतिबद्धताएँ बनाएं: बड़े व्यापक परिवर्तनों की तुलना में विलय करना आसान है
• अपनी टीम के साथ संवाद करें: ओवरलैपिंग परिवर्तनों से बचने के लिए समन्वय करें कि कौन क्या काम कर रहा है
• अक्सर मर्ज/रीबेस: शाखाओं को हफ्तों तक अलग-अलग रहने देने के बजाय नियमित रूप से परिवर्तनों को एकीकृत करें
• शाखाएँ अल्पकालिक रखें: लंबे समय तक चलने वाली शाखाएं संघर्ष जमा करती हैं

अक्सर पूछे जाने वाले प्रश्न

प्रश्न: संघर्ष चिह्नकों का क्या अर्थ है?
A: <<<<<<< HEAD आपकी वर्तमान शाखा का संस्करण प्रारंभ होता है,======= इसे आने वाले संस्करण से विभाजित करता है, और>>>>>>> branch-name आने वाले संस्करण को समाप्त करता है। फ़ाइल को अपनी इच्छित अंतिम स्थिति में संपादित करें और सभी तीन मार्कर हटा दें, फिर चरणबद्ध करें और प्रतिबद्ध करें।

प्रश्न: मैं कैसे चुनूं कि कौन सा संस्करण रखना है?
उत्तर: समझें कि प्रत्येक परिवर्तन क्या करता है, फिर निर्णय लें: अपना रखें, उनका रखें, दोनों को मिलाएं, या कुछ नया लिखें। कोई स्वचालित “सही” उत्तर नहीं है – यह इस पर निर्भर करता है कि कोड को क्या करना चाहिए। जब अनिश्चित हो, तो उस व्यक्ति से पूछें जिसने दूसरा परिवर्तन किया है। सही अंतिम स्थिति में संपादित करें.

प्रश्न: मुझसे समाधान करने में गलती हुई। मैं फिर से कैसे शुरू करूँ?
उ: यदि आपने अभी तक प्रतिबद्ध नहीं किया है, तो दौड़ेंgit merge --abort (याgit rebase --abort) रद्द करने और पूर्व-विलय स्थिति में लौटने के लिए। फिर मर्ज दोबारा शुरू करें. यदि आपने पहले ही कोई ख़राब समाधान कर दिया है, तो आप मर्ज कमिट को वापस या रीसेट कर सकते हैं।

प्रश्न: मुझे कैसे पता चलेगा कि सभी विवादों का समाधान हो गया है?
ए: भागोgit status (कोई भी असंबद्ध पथ शेष नहीं है) और बचे हुए मार्करों की खोज करें:grep -rn "<<<<<<<" . कुछ भी नहीं लौटाना चाहिए. फ़ाइलों में बचे हुए विरोध मार्कर बग का कारण बनते हैं, इसलिए प्रतिबद्ध होने से पहले हमेशा सत्यापित करें कि कोई भी शेष नहीं है।

प्रश्न: रीबेस के दौरान मुझे बार-बार वही विरोध क्यों मिलता रहता है?
ए: रिबेस आपके कमिट्स को एक समय में लागू करता है, इसलिए एक ही कोड को छूने वाले कई कमिट्स में टकराव दोबारा हो सकता है। प्रत्येक को हल करें,git add, औरgit rebase --continue. यदि यह वास्तव में दोहराव वाला है, तोgit rerereपर विचार करें (रिकॉर्ड किए गए रिज़ॉल्यूशन का पुन: उपयोग करें) या पुन: आधार देने के बजाय विलय करना।

निष्कर्ष

मर्ज संघर्ष सहयोग का एक सामान्य हिस्सा है, त्रुटियाँ नहीं – Git आपको यह तय करने के लिए कह रहा है कि कब दो शाखाओं ने एक ही कोड को अलग-अलग तरीके से बदल दिया। समाधान प्रक्रिया: के साथ विवादित फ़ाइलें खोजें , उन्हें खोलें और विरोध मार्करों (git status) का पता लगाएं, मार्करों को हटाकर अपनी इच्छित अंतिम स्थिति में संपादित करें, फिर<<<<<<< HEAD / ======= / >>>>>>> औरgit add. जटिल विवादों के लिए विज़ुअल मर्ज टूल (वीएस कोड) का उपयोग करें, औरgit commit यदि आवश्यक हो तो फिर से शुरू करना। रिबेस के दौरान, प्रति-प्रतिबद्ध समाधान करें औरgit merge --abortका उपयोग करें . बार-बार खींचकर, छोटी-छोटी प्रतिबद्धताएँ बनाकर और शाखाओं को अल्पकालिक रखकर संघर्षों को रोकें। एक बार जब आप मार्करों और प्रक्रिया को समझ लेते हैं, तो संघर्ष नियमित हो जाते हैं – बस गिट एक निर्णय मांगता है जिसे लेने के लिए आप तैयार हैं।git rebase --continueका उपयोग करें . बार-बार खींचकर, छोटी-छोटी प्रतिबद्धताएँ बनाकर और शाखाओं को अल्पकालिक रखकर संघर्षों को रोकें। एक बार जब आप मार्करों और प्रक्रिया को समझ लेते हैं, तो संघर्ष नियमित हो जाते हैं – बस गिट एक निर्णय मांगता है जिसे लेने के लिए आप तैयार हैं।