git - गिट मर्ज को पूर्ववत करें जिसे अभी तक धक्का नहीं दिया गया है




undo git-merge (18)

  1. सबसे पहले, सुनिश्चित करें कि आपने सबकुछ किया है।

  2. फिर अपने कामकाज को पिछले कार्यशील स्थिति में रीसेट करें:

    $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36
    

    या --hard का उपयोग ( यह सभी स्थानीय, प्रतिबद्ध परिवर्तन नहीं हटा देगा! ):

    $ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard
    

    हैश का प्रयोग करें जो आपके गलत तरीके से विलय करने से पहले था।

  3. जांचें कि आप पिछले सही संस्करण के शीर्ष पर फिर से प्रतिबद्ध करना चाहते हैं:

    $ git log 4c3e23f529b581c3cbe95350e84e66e3cb05704f
    
    commit 4c3e23f529b581c3cbe95350e84e66e3cb05704f
    
    ...
    
    commit 16b373a96b0a353f7454b141f7aa6f548c979d0a
    
    ...
    
  4. अपने भंडार के दाएं संस्करण के शीर्ष पर अपने दाएं कामों को लागू करें:

    • चेरी-पिक (कुछ मौजूदा कामों द्वारा पेश किए गए परिवर्तन) का उपयोग करके

          git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7
      
    • या चेरी द्वारा: द्वारा की जाने वाली सीमाओं को चुनकर:

      • सबसे पहले उन्हें विलय करने से पहले सही परिवर्तनों की जांच करना:

        git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
        
      • सबसे पहले उन्हें विलय करने से पहले सही परिवर्तनों की जांच करना:

        git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
        

        जहां यह आपके द्वारा किए गए सही कामों की सीमा है (गलत तरीके से प्रतिबद्ध विलय को छोड़कर)।

मेरी मास्टर शाखा के भीतर, मैंने git merge some-other-branch स्थानीय रूप से git merge some-other-branch किया, लेकिन कभी भी मूल मास्टर में बदलावों को धक्का नहीं दिया। मेरा विलय करने का मतलब नहीं था, इसलिए मैं इसे पूर्ववत करना चाहता हूं। मेरे विलय के बाद git status , मुझे यह संदेश मिल रहा था:

# On branch master
# Your branch is ahead of 'origin/master' by 4 commits.

मैंने पाया कुछ निर्देशों के आधार पर, मैंने दौड़ने की कोशिश की

git revert HEAD -m 1

लेकिन अब मुझे यह संदेश git status साथ मिल रहा है:

# On branch master
# Your branch is ahead of 'origin/master' by 5 commits.

मैं नहीं चाहता कि मेरी शाखा किसी भी काम से आगे बढ़े। मैं उस बिंदु पर कैसे वापस आ सकता हूं?


आधुनिक गिट के साथ, आप यह कर सकते हैं:

git merge --abort

पुराना वाक्यविन्यास:

git reset --merge

पुराना स्कूल:

git reset --hard

लेकिन असल में, यह ध्यान देने योग्य है कि git merge --abort केवल git reset --merge बराबर है - यह भी दिया गया है कि MERGE_HEAD मौजूद है। इसे मर्ज कमांड के लिए गिट सहायता में पढ़ा जा सकता है।

git merge --abort is equivalent to git reset --merge when MERGE_HEAD is present.

असफल विलय के बाद, जब कोई MERGE_HEAD नहीं MERGE_HEAD , तो विफल विलय को git reset --merge MERGE_HEAD साथ पूर्ववत किया जा सकता है, लेकिन जरूरी नहीं कि git merge --abort , इसलिए वे एक ही चीज़ के लिए केवल पुराने और नए वाक्यविन्यास नहीं हैं

व्यक्तिगत रूप से मुझे git reset --merge मिल जाता है - रोजमर्रा के काम में अधिक शक्तिशाली और उपयोगी होता है, इसलिए मैं हमेशा इसका उपयोग करता हूं।


आप पिछले चेकआउट को खोजने के लिए git reflog का उपयोग कर सकते हैं। कभी-कभी यह एक अच्छी स्थिति है जिसे आप वापस लौटना चाहते हैं।

वस्तुतः,

$ git reflog
$ git reset --hard [email protected]{0}

आप मर्ज को वापस करने या किसी विशिष्ट प्रतिबद्धता को पुनरारंभ करने के लिए केवल दो आदेशों का उपयोग कर सकते हैं:

  1. git reset --hard commitHash (आपको उस प्रतिबद्धता का उपयोग करना चाहिए जिसे आप पुनरारंभ करना चाहते हैं, उदाहरण के लिए 44a587491e32eafa1638aca7738)
  2. git push origin HEAD --force (नई स्थानीय मास्टर शाखा को मूल / मास्टर को भेजना)

शुभकामनाएँ और आगे बढ़ो!


इस मामले में, आप अपनी शाखा को git reset --hard <branch_name> साथ रीसेट करना git reset --hard <branch_name> । यदि आप उन्हें रीसेट करने से पहले अपने परिवर्तनों को सहेजना चाहते हैं तो एक नई शाखा और git checkout <branch_name> बनाना सुनिश्चित करें।

आप git reset --hard <commit_id> साथ राज्य को एक विशिष्ट प्रतिबद्धता में रीसेट कर सकते हैं - git reset --hard <commit_id> साथ ही।

यदि परिवर्तनों को धक्का दिया गया है तो आप इसके बजाय git revert <branch_name> उपयोग कर सकते हैं। अन्य परिदृश्यों में गिट रिवर्ट और गिट चेकआउट का उपयोग कैसे करें, यह जांचना सुनिश्चित करें।


इस सवाल को भी मिल गया मूल मिलान (यानी, उत्पत्ति से पहले कोई काम नहीं करता) पर वापस लौटना चाहते हैं। आगे की खोज में पाया गया कि वास्तव में एक reset कमांड है:

git reset --hard @{u}

नोट: @{u} origin/master लिए लघुरूप है। (और, ज़ाहिर है, आपको काम करने के लिए उस रिमोट रिपोजिटरी की आवश्यकता है।)


नए गिट संस्करणों के साथ, यदि आपने अभी तक विलय नहीं किया है और आपके पास विलय विवाद है , तो आप बस ऐसा कर सकते हैं:

git merge --abort

man git merge :

[यह] विलय के परिणामस्वरूप विवादों के परिणामस्वरूप ही चलाया जा सकता है। git merge --abort विलय प्रक्रिया को रोक देगा और पूर्व विलय राज्य का पुनर्निर्माण करने का प्रयास करेगा।


मान लें कि आपका स्थानीय मास्टर मूल / मास्टर से आगे नहीं था, आपको ऐसा करने में सक्षम होना चाहिए

git reset --hard origin/master

तब आपकी स्थानीय master शाखा origin/master समान दिखनी चाहिए।


मैं इस समस्या को एक कमांड के साथ हल करने में सक्षम था जिसमें एक प्रतिबद्ध आईडी को शामिल करने में शामिल नहीं है।

git reset --hard remotes/origin/HEAD

स्वीकृत उत्तर मेरे लिए काम नहीं करता था, लेकिन इस आदेश ने उन परिणामों को हासिल किया जो मैं ढूंढ रहा था।


यदि आप कमांड लाइन समाधान चाहते हैं, तो मैं बस एमबीओ के जवाब के साथ जाने का सुझाव देता हूं।

यदि आप एक नौसिखिया हैं, तो आप ग्राफिकल दृष्टिकोण पसंद कर सकते हैं:

  1. gitk को gitk (कमांड लाइन से, या यदि आपके पास है तो फ़ाइल ब्राउज़र में राइट क्लिक करें)
  2. आप वहां आसानी से विलय प्रतिबद्धता को देख सकते हैं - दो माता-पिता के साथ शीर्ष से पहला नोड
  3. पहले / बाएं माता-पिता के लिंक का पालन करें (विलय से पहले आपकी वर्तमान शाखा में से एक, आमतौर पर मेरे लिए लाल)
  4. चयनित प्रतिबद्धता पर, "यहां शाखा रीसेट करें" पर राइट-क्लिक करें, वहां हार्ड रीसेट चुनें

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

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

git checkout develop
git branch -D master
git branch -t master origin/master

देखा! मास्टर मूल के समान चरण में है, और आपका गलत विलय राज्य मिटा दिया गया है।


यदि आपने अभी तक इसे प्रतिबद्ध नहीं किया है, तो आप केवल उपयोग कर सकते हैं

$ git checkout -f

यह मर्ज (और जो कुछ भी आपने किया था) पूर्ववत कर देगा।


यह अजीब बात है कि सबसे सरल आदेश गायब था। अधिकांश उत्तर काम करते हैं, लेकिन आपके द्वारा किए गए विलय को पूर्ववत करते हुए, यह आसान और सुरक्षित तरीका है :

git reset --merge ORIG_HEAD

रेफरी ORIG_HEAD मर्ज से पहले मूल प्रतिबद्धता को इंगित करेगा।

( --merge विकल्प में मर्ज के साथ कुछ लेना देना नहीं है। यह git reset --hard ORIG_HEAD तरह है - git reset --hard ORIG_HEAD , लेकिन सुरक्षित है क्योंकि यह git reset --hard ORIG_HEAD परिवर्तनों को स्पर्श नहीं करता है।)


सबसे आसान जवाब ओडिंहो - वेलमोंट द्वारा दिया गया है

सबसे पहले git reset --merge ORIG_HEAD

परिवर्तनों को धक्का देने के बाद रीसेट करने वाले लोगों के लिए, ऐसा करें (क्योंकि यह किसी भी गिट रीसेट विलय प्रश्नों के लिए पहली पोस्ट देखी गई है)

git push origin HEAD --force

यह इस तरह से रीसेट हो जाएगा कि आपको खींचने के बाद फिर से मर्ज किए गए परिवर्तन नहीं मिलेंगे।


सिर्फ एक अतिरिक्त विकल्प देखने के लिए, मैं अधिकतर यहां वर्णित शाखाकरण मॉडल का पालन कर रहा हूं: http://nvie.com/posts/a-successful-git-branching-model/ और जैसे विलय हो रहा है --no-ff (कोई तेज़ आगे नहीं) आमतौर पर।

मैंने बस इस पृष्ठ को पढ़ा क्योंकि मैं अपनी रिलीज शाखा के बजाय गलती से एक परीक्षण शाखा विलय कर रहा था, जिसमें तैनाती के लिए मास्टर (वेबसाइट, मास्टर लाइव है)। परीक्षण शाखा में दो अन्य शाखाएं विलय हो गई हैं और लगभग छः काम करती हैं।

तो पूरी प्रतिबद्धता को वापस करने के लिए मुझे बस एक git reset --hard HEAD^ आवश्यकता थी - git reset --hard HEAD^ और यह पूरे विलय को वापस कर दिया। चूंकि विलयों को तेजी से अग्रेषित नहीं किया गया था क्योंकि विलय एक ब्लॉक था और एक कदम पीछे "शाखा विलय नहीं हुई" है।


हाल ही में, मैं इसके साथ मदद करने के लिए git reflog का उपयोग कर रहा हूं। यह ज्यादातर तभी काम करता है जब विलय बस हुआ, और यह आपकी मशीन पर था।

git reflog कुछ ऐसा वापस कर सकता है:

fbb0c0f [email protected]{0}: commit (merge): Merge branch 'master' into my-branch
43b6032 [email protected]{1}: checkout: moving from master to my-branch
e3753a7 [email protected]{2}: rebase finished: returning to refs/heads/master
e3753a7 [email protected]{3}: pull --rebase: checkout e3753a71d92b032034dcb299d2df2edc09b5830e
b41ea52 [email protected]{4}: reset: moving to HEAD^
8400a0f [email protected]{5}: rebase: aborting

पहली पंक्ति इंगित करती है कि एक विलय हुआ। दूसरी पंक्ति मेरे विलय से पहले समय है। मैं बस इस शाखा को विलय से पहले ट्रैक करने के लिए मजबूर करने के लिए git reset --hard 43b6032 पर git reset --hard 43b6032 और git reset --hard 43b6032 करता git reset --hard 43b6032


git reflog चेक के साथ जो प्रतिबद्धता विलय से पहले एक है (गिट लॉग से गिट रीफ्लॉग बेहतर विकल्प होगा)। फिर आप इसे रीसेट कर सकते हैं:

git reset --hard commit_sha

एक और तरीका भी है

git reset --hard HEAD~1

आपको वापस 1 प्रतिबद्ध मिलेगा।

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

जैसा कि @ वेल्मोंट ने अपने जवाब में नीचे दिया है, इस प्रत्यक्ष मामले में:

git reset --hard ORIG_HEAD

बेहतर परिणाम प्राप्त कर सकते हैं, क्योंकि यह आपके परिवर्तनों को संरक्षित रखना चाहिए। ORIG_HEAD विलय होने से पहले सीधे एक प्रतिबद्धता को इंगित करेगा, इसलिए आपको इसके लिए शिकार करने की आवश्यकता नहीं है।

एक और युक्ति है - के बजाय --merge स्विच का --hard क्योंकि यह अनावश्यक रूप से फ़ाइलों को रीसेट नहीं करता है:

--merge

इंडेक्स को रीसेट करता है और काम करने वाले पेड़ में फ़ाइलों को अपडेट करता है जो <प्रतिबद्ध> और HEAD के बीच अलग होते हैं, लेकिन इंडेक्स और वर्किंग पेड़ के बीच अलग-अलग होते हैं (यानी जिनके पास बदलाव नहीं किए गए हैं)।


रणनीति: जहां से सबकुछ अच्छा था वहां से एक नई शाखा बनाएं।

तर्क: विलय को वापस करना मुश्किल है। कई कारकों के आधार पर बहुत सारे समाधान हैं जैसे कि आपने अपना विलय किया है या आपके विलय के बाद से नया काम किया है या नहीं। इसके अलावा आपको अपने मामले में इन समाधानों को अनुकूलित करने के लिए अभी भी गिट की अपेक्षाकृत गहरी समझ की आवश्यकता है। यदि आप कुछ निर्देशों का अंधाधुंध पालन करते हैं, तो आप "रिक्त विलय" के साथ समाप्त हो सकते हैं जहां कुछ भी विलय नहीं किया जाएगा, और आगे विलय करने के प्रयासों से गिट आपको "पहले से ही अद्यतित" बताएगा।

उपाय:

मान लें कि आप feature-1 में dev को मर्ज करना चाहते हैं।

  1. उस संशोधन को ढूंढें जिसे आप मर्ज प्राप्त करना चाहते हैं:

    git log --oneline feature-1
    a1b2c3d4 Merge branch 'dev' into 'feature-1' <-- the merge you want to undo
    e5f6g7h8 Fix NPE in the Zero Point Module <-- the one before the merge, you probably want this one
    
  2. इसे देखें (समय पर वापस जाएं):

    git checkout e5f6g7h8
    
  3. वहां से एक नई शाखा बनाएं और इसे देखें:

    git checkout -b feature-1
    

अब आप अपने मर्ज को पुनरारंभ कर सकते हैं:

  1. मर्ज करें: git merge dev

  2. अपने विलय संघर्ष को ठीक करें।

  3. प्रतिबद्धता: git commit

  4. जब आप परिणामों से संतुष्ट होते हैं, तो पुरानी शाखा हटाएं: git branch --delete feature-1





git-merge