3939

अपनी मास्टर शाखा के भीतर, मैंने 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 undo git-merge

— मैट हगिन्स
स्रोत

3

यदि आपको इतिहास को संरक्षित करने की आवश्यकता है, तो दूसरे शब्दों में एक बदलाव है जिसे किसी ने कभी भी आपसे खींच लिया है या आपने इसे कहीं धकेल दिया है नीचे दिए गए यूरी उशाकोव में समाधान का उपयोग करें!

— सेड्रिक

6

कृपया वर्तमान जीतने वाले उत्तर को अचयनित करें, यह असुरक्षित (जैसा कि कई बताया गया है) हालांकि अभी भी वोट एकत्र कर रहा है। मेरे लिए "एमबीओ" -s सबसे अच्छा दिखता है, हालांकि इसमें कम अंक हैं।

— इंग

5

यदि आपको इतिहास को संरक्षित करने की आवश्यकता है , तो नीचे यूरी के समाधान का उपयोग करें ! (सिर्फ @Sedrik टिप्पणी के लिए एक लिंक जोड़कर)

— cregox

संबंधित: पूर्ववर्ती Git कमिट पर वापस लौटें ।

3

यह सीधे Github से एक महान संसाधन है: पूर्ववत कैसे Git के साथ (लगभग) कुछ भी

— jasonleonhard

4452

git reflogजाँच के साथ कि कौन सा कमिट एक मर्ज है ( git reflogइससे बेहतर विकल्प होगा git log)। तब आप इसका उपयोग करके इसे रीसेट कर सकते हैं:

git reset --hard commit_sha

वहाँ भी एक और तरीका है:

git reset --hard HEAD~1

यह आपको 1 कमिट वापस मिलेगा।

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

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

git reset --hard ORIG_HEAD

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

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

git reset --merge ORIG_HEAD

--merge

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

— मारकिन गिल
स्रोत

129

मुझे नहीं लगता कि यह (हमेशा?) काम होगा - "एक पूर्व मर्ज" सबसे हालिया प्रतिबद्ध होगा जो अन्य शाखा से विलय कर दिया गया था - यह वर्तमान शाखा पर सबसे हालिया प्रतिबद्ध नहीं होगा । सही? (यह सिर्फ git logडिफ़ॉल्ट रूप से दिखाने के लिए क्या चुनता है का एक परिणाम हो सकता है - शायद वहाँ का एक अलग उत्पादन है git logया git reflogइसके लिए इस्तेमाल किया जा सकता है)

— जॉन बाचिर

6

मुझे लगता है कि यह निर्भर करता है कि आप स्क्वैश मर्ज करते हैं या नहीं।

— मार्सिन गिल

29

@ जॉनबचिर सही है। में git logउत्पादन, आप दो माता पिता प्रतिबद्ध को देखने के लिए चाहते हैं। आपकी शाखा में एक नवीनतम प्रतिबद्ध है, जिस शाखा में आप विलीन हो गए हैं उसमें एक नवीनतम प्रतिबद्धता है। git reset --hardजिस शाखा में आप विलय हुए हैं, उस पर आप माता-पिता की प्रतिबद्धता चाहते हैं ।

— जस्टिन

7

@ जॉनबचिर: जब तक "मर्ज" वास्तव में तेजी से आगे नहीं होता है, तब तक यह एक नई प्रतिबद्धता का परिणाम देगा जो लॉग के शीर्ष पर है, और इस प्रतिबद्ध में दो माता-पिता हैं (या 2 से अधिक हैं यदि आप एक ऑक्टोपस करते हैं मर्ज)। यदि आप इस एक मर्ज कमिट को हटा देते हैं, तो मर्ज में आने वाले सभी पुराने कमिट गायब हो जाएंगे, भी। सुरक्षित होने के लिए, हालांकि, रीसेट के बाद गिट आपको बताएगा कि नया सिर कहां है: "HEAD अब 88a04de <प्रतिबद्ध संदेश>" पर है। मैं हमेशा यह देखता हूं कि यह सुनिश्चित करने के लिए कि मैं वहीं समाप्त हो जाऊं जहां मुझे उम्मीद थी। मेरी परियोजना चीजों को यादगार रखने के लिए एक मानक शाखा के नामकरण योजना का उपयोग करती है।

— मार्क ई। हसे

44

जो मुझे उपयोगी लगा वह "गिट रिफ्लग" को देखने के लिए और आखिरी प्रतिबद्ध के लिए देखो जो मैंने मास्टर में किया था। फिर करते हैंgit reset --hard <commit_sha>

— मैक्स विलियम्स

1454

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

git reset --hard origin/master

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

— randomguy3
स्रोत

71

@ यह वास्तव में सबसे अच्छा जवाब नहीं है। यह संभव है कि मूल / गुरु आपके स्थानीय गुरु से आगे हो सकता है, जो कुछ कमिट्स द्वारा मर्ज करने के लिए पिछले है, उस स्थिति में यह वांछित परिणाम नहीं दे सकता है

— ध्रुव सागर

15

@ dhruva-sagar हाँ, लेकिन जब तक git नहीं कहता कि आप पीछे हैं, और आप नहीं लाते हैं, आपको ठीक होना चाहिए।

— केल्विन

3

धन्यवाद! यह सही है अगर (और केवल अगर) आपके पास एक दूरस्थ भंडार है।

— टॉम जेएन

2

नहीं, यह इस प्रश्न के लिए एकदम सही नहीं है, "मान" खंड देखें। MBO का जवाब वास्तव में इस मामले को कवर करता है, और यह मामला जहां विलय केवल स्थानीय प्रतिबद्ध नहीं है।

— इंग

2

एक बार फिर, हो सकता है कि यह चेतावनी स्वयं ही उत्तर में चली जाए: हमेशा इतिहास लिखने से बचें!

— cregox

1174

अध्याय 4 को गिट बुक में देखें और लिनुस टोरवाल्ड्स द्वारा मूल पोस्ट ।

एक मर्ज को पूर्ववत् करने के लिए जिसे पहले ही धकेल दिया गया था :

git revert -m 1 commit_hash

यदि आप शाखा को फिर से कर रहे हैं, तो रिवर्ट को वापस करना सुनिश्चित करें, जैसे लिनुस ने कहा।

— यूरी गिनिश
स्रोत

10

@perfectionist ने सहमति व्यक्त की :) एक अन्य प्रश्न के उत्तर की ओर पलायन करने का एक तरीका

— था--

रिवर्ट के बारे में अधिक जानकारी के लिए: लिंक

— assaqqaf

1

यह विश्वास करने के लिए कि इस रिवर्ट ने काम किया है, आप हैश 1 हैश 2 हैश 1 कर सकते हैं जहाँ हैश 1 कमिटेड रिवर्ट है, और हैश 2 वह पुरानी कमिट है जिसकी अवस्था आप वापस पाने की कोशिश कर रहे थे। कोई आउटपुट नहीं == सफलता! मैं कई बार ऐसा करके कई कमिट वापस करने में सक्षम था, सबसे हाल के मर्ज को वापस करके और पीछे की ओर काम करके। git diff ने मुझे दिखाया कि मैं जिस राज्य में चाहता था, मैं समाप्त हो गया।

— रॉबर्ट सिंटन

6

ध्यान दें कि यह वास्तव में मूल पोस्टर के प्रश्न को हल नहीं करता है । मूल पोस्टर पहले से ही इस्तेमाल किया git revert -m 1 <commit>। समस्या यह है कि ऐसा करना उस आकस्मिक मर्ज को मिटाता नहीं है जो उसने किया था (और अभी तक धक्का नहीं दिया है)। मूल पोस्टर की समस्या के लिए हार्ड रीसेट से जुड़े अन्य उत्तर बेहतर हैं।

यह सीधे

— गीथब

986

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

git reset --merge ORIG_HEAD

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

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

— ओडिन्हो - वेलमॉन्ट
स्रोत

17

यदि आपने अपने काम के पेड़ को गंदा कर दिया है, तो git reset --merge ORIG_HEADउन परिवर्तनों को संरक्षित करता है।

— yingted

1

यह एकमात्र सही उत्तर है (मैं यह नहीं कह रहा हूं कि यह सबसे अच्छा उत्तर है - अंतर पर ध्यान दें)। मान लीजिए, मास्टर पर, मैंने t1, t3, और t5 में 3 कमिट किए। मान लीजिए, शाखा 1 पर, मैंने t2, t4 और t6 पर 3 टिप्पणियां कीं (मान लीजिए t1, t2, t3, t4, t5 और t6 कालानुक्रमिक क्रम में हैं)। इसके समान कोई भी आदेश git reset --hard HEAD~5केवल HEAD को रीसेट करेगा (हो सकता है कि दोनों मास्टर और शाखा 1 में कमिट हटा दें)। केवल --mergeविकल्प निकालता है merge।

— मनु मंजुनाथ

@ मैनू --mergeविकल्प वास्तव में मर्ज को दूर नहीं करता है, आप इसका उपयोग कर सकते हैं --hardयह भी अच्छी तरह से काम करेगा। यह ORIG_HEAD का संदर्भ है कि यहाँ सुराग है, इससे पहले कि आप उस बिंदु पर खड़े हों जहां आप एक मर्ज करते हैं। :)

— ओडिन्हो - वेलमॉन्ट

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

— संध्या चतुर्भुज

git reset --hard ORIG_HEADआदेश मेरे लिए पूरी तरह से काम किया है - यह सच है कि मैं भंडार में कोई अन्य परिवर्तन के बाद स्थानीय नहीं किया द्वारा मदद किया गया हो सकता git mergeमैं पूर्ववत करने का प्रयास किया गया था। मर्ज करने से पहले कमांड केवल रिपॉजिटरी की स्थिति को वापस रीसेट करता है। उत्कृष्ट टिप के लिए धन्यवाद!

— 1

391

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

git merge --abort

से man git merge:

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

— ट्रैविस रीडर
स्रोत

8

उनका मर्ज प्रतिबद्ध है, लेकिन धक्का नहीं दिया गया है (शीर्षक देखें), वह पहले ही विलीन हो चुके हैं, आपकी आज्ञा तभी काम करती है जब वह एक मर्ज के बीच में है

— JBoy

135

आपको पिछली प्रतिबद्ध पर रीसेट करना चाहिए। यह काम करना चाहिए:

git reset --hard HEAD^

या फिर HEAD^^उस रिवर्ट कमिट को वापस करने के लिए भी। आप हमेशा एक पूर्ण SHA संदर्भ दे सकते हैं यदि आप सुनिश्चित नहीं हैं कि आपको कितने कदम वापस लेने चाहिए।

समस्या होने पर और आपकी मास्टर शाखा में कोई स्थानीय परिवर्तन नहीं होने पर, आप रीसेट कर सकते हैं origin/master।

— MBO
स्रोत

5

सबसे अच्छा जवाब IMHO, ओपी के अपने एक को शामिल करता है (केवल 1 कदम को वापस लेने के लिए, जो कि क्यू में मामला प्रतीत होता है), साथ ही साथ randomguy3 के शॉर्टकट एक (जो तब काम करता है जब "आपकी मास्टर शाखा में कोई स्थानीय परिवर्तन नहीं था) ")

— प्रवेश करें

4

आप टिप्पणी करते हैं, @Inger और @Konstantin, क्यों? मेरा उत्तर बनने के बाद आप यहां आए, और यह अधिक सही है। बस एक कदम बढ़ रहा है अक्सर गलत होता है, और आपको वास्तव में गिनना होगा कि आपको कितनी दूर जाने की आवश्यकता है। आपके लिए Git पहले से ही सेट ORIG_HEADहै, इसका उपयोग क्यों नहीं करते?

— ओडिन्हो - वेलमॉन्ट

क्या यह स्थानीय परिवर्तनों को भी रीसेट करेगा? #कृपया अद्यतन करें।

— CoDe

यह मेरे लिए पूरी तरह से काम करता है, इस तरह से सिर को रीसेट करना यहां आधे उत्तरों की तुलना में बहुत अधिक समझ में आता है।

— वर्दा एलेंट्री

HEAD ^ HEAD से पहले प्रतिबद्ध है? और ^ ^ दो कमिट पहले है? अनुमान है कि यह तेजी से आगे विलय के साथ काम नहीं करेगा?

— मार्कस लियोन

87

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

git reflog कुछ इस तरह लौट सकते हैं:

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

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

— पर्रिस
स्रोत

शानदार जवाब, धन्यवाद! मर्ज को पूर्ववत् करने की आवश्यकता है, लेकिन अन्य उत्तरों ने इसे और अधिक गड़बड़ कर दिया, reflogएसएचए पाने के लिए और इसे git resetकाम करने के लिए पास किया।

— १०:१० पर लंकिमार्ट

51

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

git merge --abort

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

git reset --merge

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

git reset --hard

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

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

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

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

— मार्टिन जी
स्रोत

मेरे लिए बहुत अच्छा काम किया। हर दूसरा पद कहता है कि यह बहुत जटिल है, लेकिन इसने वही किया जो अपेक्षित है। मुझे लगता है कि यह केवल इसलिए काम किया क्योंकि संघर्ष थे, जो मूल प्रश्न का उत्तर नहीं देते हैं।

— जेरेमी

यह उत्तर ओपी की स्थिति पर ध्यान केंद्रित नहीं करता है, और महत्वपूर्ण संदर्भ छोड़ देता है।

— बेन व्हीलर

37

ठीक है, मुझे यहां दिए गए अन्य लोगों के जवाब करीब थे, लेकिन यह काम नहीं किया। यहाँ मैंने क्या किया है।

यह कर रहा हूं...

git reset --hard HEAD^
git status

... मुझे निम्न दर्जा दिया।

# On branch master
# Your branch and 'origin/master' have diverged,
# and have 3 and 3 different commit(s) each, respectively.

फिर मुझे git resetकई बार एक ही कमांड में टाइप करना पड़ा । हर बार जब मैंने ऐसा किया, तो संदेश नीचे के रूप में एक के बाद एक बदल सकता है।

> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 3 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 2 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch and 'origin/master' have diverged,
# and have 1 and 3 different commit(s) each, respectively.
> git reset --hard HEAD^
HEAD is now at [...truncated...]
> git status
# On branch master
# Your branch is behind 'origin/master' by 3 commits, and can be fast-forwarded.

इस बिंदु पर, मैंने देखा कि स्थिति संदेश बदल गया है, इसलिए मैंने एक करने की कोशिश की git pull, और वह काम करने लगा:

> git pull
Updating 2df6af4..12bbd2f
Fast forward
 app/views/truncated |    9 ++++++---
 app/views/truncated |   13 +++++++++++++
 app/views/truncated |    2 +-
 3 files changed, 20 insertions(+), 4 deletions(-)
> git status
# On branch master

इतनी लंबी कहानी छोटी है, मेरी आज्ञा यह है:

git reset --hard HEAD^
git reset --hard HEAD^
git reset --hard HEAD^
git reset --hard HEAD^
git pull

— मैट हगिन्स
स्रोत

19

या आप का उपयोग किया है हो सकता हैHEAD^^^^

— Hasen

17

शायद भी रीसेट origin/master;)

— has

23

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

वस्तुतः,

$ git reflog
$ git reset --hard HEAD@{0}

— stephjang
स्रोत

1

धन्यवाद! आपने मेरे काम का आधा दिन बचा लिया। हालाँकि मैं किसी भी कमांड के साथ रीफ्लो मोड से बाहर नहीं निकल सका।

— कटारजीना

1

@Katarzyna "q" कुंजी का उपयोग करने के लिए बाहर निकलें से बाहर निकलें

— Amjed Baig

21

यदि आप विलय के बीच में हैं तो आप इसे हमेशा निरस्त कर सकते हैं git merge --abort

— llioor
स्रोत

2

धन्यवाद भाई और मैं उस डरावने सामान का सही उत्तर देने वाला था। भाग्यशाली मैं नीचे स्क्रॉल मैं केवल मर्ज सिर को हटाना चाहता

— हूं

15

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

git reset --hard remotes/origin/HEAD

स्वीकृत उत्तर मेरे लिए काम नहीं करता था, लेकिन इस कमांड ने उन परिणामों को प्राप्त किया जिनकी मुझे तलाश थी।

— राल्फ रिटोच
स्रोत

बिल्कुल सही! यह शाखा के HEAD में आपके परिवर्तनों को हल करता है! एक

— कार्लोस जिनाटो

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

— मैट पेंग्ली

@MattPengelly यह विधि काफी हद तक अविभाजित है और आमतौर पर यह काम करती है कि आपकी शाखा का विलय होने से पहले दूरस्थ शाखा के साथ तालमेल हो जाए। क्या आपकी शाखा को दूरस्थ शाखा के साथ सिंक हुए महीनों हो गए हैं?

— राल्फ रिटोच

@MattPengelly यह इस बात पर भी निर्भर करता है कि HEAD किस शाखा को इंगित करता है। मैं अपनी परियोजनाओं में से एक पर gitflow का उपयोग कर रहा हूं, और भले ही मैं विकसित शाखा पर हूं, फिर भी रिमोट / मूल / HEAD को मूल / मास्टर को इंगित किया जाता है, इसलिए यदि मुझे मर्ज को पूर्ववत करने की आवश्यकता है, तो मुझे शायद रीमोट करने के लिए रीसेट करना होगा / उत्पत्ति / विकास

— राल्फ रिटोच

14

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

$ git checkout -f

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

— Idealmind
स्रोत

इस की कोशिश की और यह वास्तव में मेरी स्थानीय शाखा आगे है कि हिट की संख्या में वृद्धि हुई है।

— बार्कले

14

इस सवाल के साथ भी मूल (यानी, मूल के आगे नहीं शुरू होता है) मैच के लिए वापस देख रहे हैं। आगे शोध, पाया resetकि इसके लिए एक आदेश है:

git reset --hard @{u}

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

— लिएन
स्रोत

14

आपको अपना HEAD बदलना होगा, नॉट योर योर बेशक git HEAD…।

तो उत्तर देने से पहले आइए कुछ पृष्ठभूमि जोड़ते हैं, यह बताते हुए कि यह क्या है HEAD।

`First of all what is HEAD?`

HEADबस वर्तमान शाखा पर वर्तमान प्रतिबद्ध (नवीनतम) के लिए एक संदर्भ है। किसी भी समय
केवल एक ही हो सकता है HEAD। (छोड़करgit worktree )

की सामग्री HEADअंदर संग्रहीत की जाती है .git/HEADऔर इसमें वर्तमान प्रतिबद्ध के 40 बाइट्स SHA-1 होते हैं।

`detached HEAD`

यदि आप नवीनतम कमिट पर नहीं हैं - इसका अर्थ है कि HEADइतिहास में एक पूर्व कमिट की ओर इशारा करना detached HEAD।

कमांड लाइन पर, यह शाखा नाम के बजाय इस प्रकार दिखाई देगा - क्योंकि HEADवर्तमान शाखा के सिरे की ओर इशारा नहीं है

एक अलग सिर से उबरने के बारे में कुछ विकल्प:

`git checkout`

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

यह वांछित प्रतिबद्धता की ओर इशारा करते हुए नई शाखा की जाँच करेगा।
यह कमांड किसी दिए गए कमिट को चेकआउट करेगा।
इस बिंदु पर, आप एक शाखा बना सकते हैं और इस बिंदु से काम करना शुरू कर सकते हैं।

# Checkout a given commit. 
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# create a new branch forked to the given commit
git checkout -b <branch name>

`git reflog`

आप हमेशा के reflogरूप में अच्छी तरह से उपयोग कर सकते हैं ।
git reflogकिसी भी परिवर्तन को प्रदर्शित करेगा जो अपडेट किया गया था HEADऔर वांछित रिफ्लग प्रविष्टि की जाँच करके इस कमेटी को HEADवापस सेट कर देगा ।

हर बार जब संशोधित किया जाता है तो एक नई प्रविष्टि होगी reflog

git reflog
git checkout HEAD@{...}

यह आपको आपकी इच्छित कमिट पर वापस मिल जाएगा

`git reset --hard <commit_id>`

"HEAD" को अपने HEAD में इच्छित स्थान पर वापस ले जाएं।

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts if you've modified things which were
# changed since the commit you reset to.

नोट: ( जीआईटी 2.7 के बाद से )
आप भी इसका उपयोग कर सकते हैं git rebase --no-autostash।

`git revert <sha-1>`

दी गई प्रतिबद्ध या प्रतिबद्ध सीमा को "पूर्ववत करें"।
रीसेट कमांड दिए गए कमिट में किए गए किसी भी बदलाव को "पूर्ववत" करेगा।
पूर्ववत पैच के साथ एक नई प्रतिबद्धता होगी, जबकि मूल प्रतिबद्धता इतिहास में भी रहेगी।

# add new commit with the undo of the original one.
# the <sha-1> can be any commit(s) or commit range
git revert <sha-1>

यह स्कीमा दिखाता है कि कौन सी कमांड क्या करती है।
जैसा कि आप देख सकते हैं वहाँ reset && checkoutसंशोधित करें HEAD।

— CodeWizard
स्रोत

यह खजाना है

— सिंह

12

सबसे सरल उत्तर ओडिन्हो - वेलमॉन्ट द्वारा दिया गया है

पहले करो git reset --merge ORIG_HEAD

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

git push origin HEAD --force

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

— हर्ष
स्रोत

10

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

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

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

— डेमियन बायरन
स्रोत

10

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

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

गुड लक और आगे बढ़ो!

— माथियस अब्रेउ
स्रोत

10

इसे कई तरीके से किया जा सकता है।

1) एबोर्ट मर्ज

यदि आप एक बुरे मर्ज के बीच में हैं (गलती से गलत शाखा के साथ किया गया है), और नीचे के रूप में नवीनतम शाखा में वापस जाने के लिए मर्ज से बचना चाहते थे:

git merge --abort

2) दूरस्थ शाखा में हेड को रीसेट करें

यदि आप दूरस्थ विकास शाखा से काम कर रहे हैं, तो आप नीचे के रूप में दूरस्थ शाखा पर अंतिम वचन के लिए HEAD रीसेट कर सकते हैं:

git reset --hard origin/develop

3) वर्तमान शाखा को हटा दें, और दूरस्थ रिपॉजिटरी से फिर से चेकआउट करें

ध्यान में रखते हुए, आप स्थानीय रेपो में विकसित शाखा पर काम कर रहे हैं, जो रिमोट / डेवलपमेंट शाखा के साथ सिंक करता है, आप नीचे दिए अनुसार कर सकते हैं:

git checkout master 
##to delete one branch, you need to be on another branch, otherwise you will fall with the branch :) 

git branch -D develop
git checkout -b develop origin/develop

— अमित कनेरिया
स्रोत

वह "1) एबॉर्ट मर्ज" काफी सुंदर था। Upvoting।

— कोडटॉइल

1

सावधान रहे! git मर्ज --abort "मर्ज के बाद ही चलाया जा सकता है, जिसके परिणामस्वरूप मर्ज हो गया है। git मर्ज --abort मर्ज प्रक्रिया को निरस्त कर देगा और प्री-मर्ज स्थिति को फिर से संगठित करने का प्रयास करेगा"

— पेड्रो गार्सिया

8

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

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

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

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

— स्टीफ़न
स्रोत

1

नोट: यह न केवल मर्ज को पूर्ववत् करता है, बल्कि किसी भी स्थानीय कमिट को भी करता है जो कि नवीनतम पुश टू ऑरिजन के बाद से बनाया गया था।

— मार्टिज़न हेमेल्स

4

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

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

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

— Inger
स्रोत

4

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

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

समाधान:

चलो आप मर्ज करना चाहते कहना devमें feature-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

इसे देखें (समय पर वापस जाएँ):
```
git checkout e5f6g7h8
```
वहां से एक नई शाखा बनाएं और इसे देखें:
```
git checkout -b feature-1
```

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

सम्मिलित करें: git merge dev
अपने मर्ज संघर्ष को ठीक करें।
प्रतिबद्ध: git commit
जब आप परिणामों से संतुष्ट हों, तो पुरानी शाखा को हटा दें: git branch --delete feature-1

— pyb
स्रोत

2

बस नई शाखा बनाएं, फिर चेरी-पिक को वांछित करें।

इसके सेवर और सरल तो ऊपर वर्णित कई जवाबों में वर्णित हैं

— देवी
स्रोत

1

मैं इस सुझाव से सहमत हूं, खासकर यदि आप सूचीबद्ध कमांड के साथ पूरी तरह से सहज नहीं हैं। यह अधिक "शौचालय" के साथ धीमा हो सकता है, लेकिन अगर यह बहुत ऊपर नहीं आता है और आप अपना काम खोने से चिंतित हैं, तो यह प्रयास के लायक है।

— ग्रेग

1

मुझे लगता है कि आप यह कर सकते हैं कि पहचान की गई हैश git rebase -i [hash] [branch_name] कहाँ [hash]है, हालाँकि आप बहुत पहले से रिवाइंड करना चाहते हैं (या फिर बहुत से कमिट्स जो आप जाना चाहते हैं) और फिर एडिटर में कमिट्स के लिए लाइन्स डिलीट कर दें जो आप नहीं चाहते । फ़ाइल सहेजें। बाहर जाएं। प्रार्थना करना। और यह फिर से होना चाहिए। आपको ए करना पड़ सकता है git reset --hard, लेकिन यह इस बिंदु पर अच्छा होना चाहिए। यदि आप उन्हें अपने इतिहास में नहीं रखना चाहते हैं, तो आप इसका उपयोग एक स्टैक से बाहर निकालने के लिए भी कर सकते हैं, लेकिन यह आपकी रिपॉजिटरी को ऐसी स्थिति में छोड़ सकता है जो आप नहीं चाहते हैं।

— tychoish
स्रोत

1

यदि आपने मर्ज किया है:

git reset HEAD~1
# Make sure what you are reverting is in fact the merge files
git add .
git reset --hard

— डोरियन
स्रोत

1

सबसे पहले, सुनिश्चित करें कि आपने सब कुछ किया है।
फिर अपनी रिपोजिटरी को पिछली कार्यशील स्थिति में रीसेट करें:
```
$ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36
```
या --hard( यह सभी स्थानीय हटा देगा, प्रतिबद्ध परिवर्तन नहीं! ):
```
$ git reset f836e4c1fa51524658b9f026eb5efa24afaf3a36 --hard
```
उस हैश का उपयोग करें जो आपकी गलत तरीके से मर्ज किए जाने से पहले था।
जाँच करें कि आप कौन से पिछले संस्करण के शीर्ष पर फिर से कमिट करना चाहते हैं:
```
$ git log 4c3e23f529b581c3cbe95350e84e66e3cb05704f

commit 4c3e23f529b581c3cbe95350e84e66e3cb05704f

...

commit 16b373a96b0a353f7454b141f7aa6f548c979d0a

...
```
अपने रिपॉजिटरी के दाहिने संस्करण के शीर्ष पर अपना सही कमिट लागू करें:
- चेरी-पिक (कुछ मौजूदा कमिट द्वारा पेश किए गए परिवर्तन) का उपयोग करके
```
    git cherry-pick ec59ab844cf504e462f011c8cc7e5667ebb2e9c7
```
- या चेरी द्वारा कमिट की सीमा को उठाकर:
  - उन्हें विलय करने से पहले सही परिवर्तनों की जाँच करें:
```
git diff 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
```
  - उन्हें विलय करने से पहले सही परिवर्तनों की जाँच करें:
```
git cherry-pick 5216b24822ea1c48069f648449997879bb49c070..4c3e23f529b581c3cbe95350e84e66e3cb05704f
```
    जहां यह आपके द्वारा किए गए सही कमिट की सीमा है (गलत तरीके से किए गए मर्ज को छोड़कर)।

— kenorb
स्रोत

1

git stash
git branch -d the_local_branch
git checkout -t <name of remote>
git stash apply

यह मेरे लिए काम किया .. !!

— शिव कुमार
स्रोत

0

यदि आपको लगता है कि आपको मर्ज के तुरंत बाद वापस जाने की आवश्यकता है और मर्ज के प्रयास के बाद आपने कुछ और नहीं किया है, तो आप बस इस आदेश को जारी कर सकते हैं git reset --hard HEAD@{1}:।

अनिवार्य रूप से, आपका मर्ज shaइंगित करेगा HEAD@{0}कि क्या मर्ज के बाद और कुछ नहीं किया गया था और इसलिए मर्ज HEAD@{1}से पहले पिछला बिंदु होगा।

— Dut A.
स्रोत

0

सबसे सरल मौका के सबसे सरल, यहाँ कहे गए चीज़ों की तुलना में बहुत सरल:

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

— लुइस
स्रोत

0

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

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

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

— नीशा ज़ोरिक
स्रोत

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

First of all what is HEAD?

detached HEAD

एक अलग सिर से उबरने के बारे में कुछ विकल्प:

git checkout

git reflog

git reset --hard <commit_id>

git revert <sha-1>