गलत Git शाखा के लिए कमिटिंग कैसे तय करें?

Question

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

Answer 1

यदि आपने अभी तक अपने परिवर्तनों को आगे नहीं बढ़ाया है, तो आप एक सॉफ्ट रीसेट भी कर सकते हैं:

git reset --soft HEAD^

यह कमिट करेगा, लेकिन प्रतिबद्ध बदलावों को वापस अपने सूचकांक में डाल देगा। यह मानते हुए कि शाखाएं एक-दूसरे के संबंध में अपेक्षाकृत अद्यतित हैं, git आपको दूसरी शाखा में एक चेकआउट करने देगा, जिसके द्वारा आप बस प्रतिबद्ध कर सकते हैं:

git checkout branch
git commit

नुकसान यह है कि आपको अपने प्रतिबद्ध संदेश को फिर से दर्ज करने की आवश्यकता है।

Comments

ध्यान दें कि नरम रीसेट आपके परिवर्तनों को चरणबद्ध और प्रतिबद्ध करने के लिए तैयार छोड़ देता है। जब मेरी आईडीई ने सॉफ्ट रीसेट के बाद संशोधित स्थिति में फाइल नहीं दिखाई तो मुझे थोड़ा भ्रम हुआ।

— mtjhax

सही फिक्स, वास्तव में एक युगल ने हिट किया था ताकि HE ^ ^ और bam सब ग्रेवी हो जाए

— पाब्लो

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

— Kirby

zsh उपयोगकर्ता: आपको ऐसा लग सकता है कि आपको भागने की जरूरत है जैसे:git reset --soft HEAD\^

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

यदि आप एक और मिलता है? अपने विंडोज कमांड लाइन में, HEAD ^ को घेरने के लिए कोट्स का उपयोग करें: git reset --soft "HEAD ^"

— नैट कुक

Answer 2

विषय पर 4 साल की देरी, लेकिन यह किसी के लिए उपयोगी हो सकता है।

यदि आप मास्टर करने से पहले एक नई शाखा बनाना भूल गए हैं और सभी को प्रतिबद्ध किया है, तो चाहे आप कितने भी काम करें, निम्नलिखित कार्य आसान हैं:

git stash                       # skip if all changes are committed
git branch my_feature
git reset --hard origin/master
git checkout my_feature
git stash pop                   # skip if all changes were committed

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

Comments

जवाब के लिए धन्यवाद। अब मैं एगिट का उपयोग कर रहा हूं और मैं सोच रहा हूं कि क्या मैं निम्नलिखित काम करके उसी काम को पूरा कर सकता हूं: 1) 'my_feature' के लिए वर्तमान 'मास्टर' का नाम बदलें। 2) 'मूल / मास्टर' से स्थानीय 'मास्टर' को फिर से बनाना। मुझे यकीन नहीं है कि एगिट इन ऑपरेशनों के लिए क्या कर रहा है, लेकिन यह एक व्यवहार्य समाधान लगता है

— mjj1409

मर्ज क्यों? आप सीधे शाखा बना सकते हैं master, फिर रीसेट कर सकते हैंmaster कर सकते हैं origin/master।

— कैसरसोल

यह सबसे दिलचस्प हिस्सा है: आपको कई प्रतिबद्धताओं की आवश्यकता नहीं है, क्योंकि origin/masterपहले से ही आप जिस पर रीसेट करना चाहते हैं , वह पहले से ही है! हालांकि टिप का श्रेय इस पृष्ठ को है: github.com/blog/…

— caesarsol

यह स्वीकृत उत्तर होना चाहिए। सरल, स्पष्ट, सीधा, कमिट की संख्या की परवाह किए बिना काम करता है और केवल बुनियादी गिट कार्यक्षमता का उपयोग करता है। मैंने ये कदम TortoiseGit के साथ किया। धन्यवाद! :)

— इयान ग्रिंगर

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

— पाउल्जोन32

Answer 3

यदि आपके पास एक साफ (अन-संशोधित) कामकाजी प्रति है

एक कमबैक करने के लिए (सुनिश्चित करें कि आप अगले चरण के लिए कमिट का हैश नोट करते हैं):

git reset --hard HEAD^

एक अलग शाखा में उस कमिट को खींचने के लिए:

git checkout other-branch
git cherry-pick COMMIT-HASH

यदि आपने बदलाव या अनियंत्रित परिवर्तन किए हैं

यह भी ध्यान दें कि आपके द्वारा किए जा सकने वाले किसी भी अनियोजित और संशोधित परिवर्तनोंgit reset --hard को मार देगा , इसलिए यदि आपके पास वे हैं जो आप पसंद कर सकते हैं:

git reset HEAD^
git checkout .

Comments

git rev-parse BRANCH_NAMEशा को पाने के लिए।

— विल्हेमटेल

यदि आप पहले हैश को नोट करना भूल जाते हैं, तो उपयोग करें git reflog show <branch>!

— कैस्केबेल

@ जेफ्रोमी मैं वहां एक मिनट के लिए डर गया था।

— इयान हंटर

एक अतिरिक्त सुरक्षित भावना के लिए, सही शाखा पर पहले चेरी-पिक प्रदर्शन करें और उसके बाद ही गलत शाखा को रीसेट करें।

— उम्र मोइज

इसके अलावा, अनियंत्रित परिवर्तनों के मामले में, कोई भी git stashरीसेट करने से पहले और git stash popबाद में उन्हें पुनर्स्थापित करने के लिए उपयोग कर सकता है, इसलिए --hardभाग से डरने की कोई आवश्यकता नहीं है

— क्लेमेंस क्लेन-रोबेनहैर

Answer 4

यदि आपने पहले से ही अपने बदलावों को आगे बढ़ाया है, तो आपको HEAD को रीसेट करने के बाद अपने अगले पुश को लागू करने की आवश्यकता होगी।

git reset --hard HEAD^
git merge COMMIT_SHA1
git push --force

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

बस मामले में, विंडोज पर (विंडोज कमांड लाइन का उपयोग करते हुए, बैश नहीं) यह वास्तव ^^^^में एक के बजाय चार है , इसलिए यह है

git reset --hard HEAD^^^^

Comments

ध्यान दें कि आपको उस शाखा को धक्का नहीं देना चाहिए जो अन्य लोग तब तक उपयोग कर रहे हैं जब तक कि वे बिल्कुल आवश्यक न हों - अन्यथा वे तब तक धक्का नहीं दे पाएंगे जब तक कि वे फिर से काम न करें। यदि आप git का उपयोग करने वाले एकमात्र डेवलपर हैं, हालांकि, यह ठीक है।

— ब्लेयर होलोवे

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

— माइकल मेयोर

यदि आपका एक से अधिक प्रतिबद्ध है, तो आप अपनी आवश्यकता के अनुसार निर्दिष्ट कर सकते हैं: git reset --hard COMMIT_HASH git push --force

— डेविड क्रैम्बलट

Answer 5

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

यदि आप सिर्फ गलत शाखा के लिए प्रतिबद्ध हैं, और तब से कुछ भी नहीं बदला है, और रेपो को धक्का नहीं दिया है, तो आप निम्नलिखित कार्य कर सकते हैं:

// rewind master to point to the commit just before your most recent commit.
// this takes all changes in your most recent commit, and turns them into unstaged changes. 
git reset HEAD~1 

// temporarily save your unstaged changes as a commit that's not attached to any branch using git stash
// all temporary commits created with git stash are put into a stack of temporary commits.
git stash

// create other-branch (if the other branch doesn't already exist)
git branch other-branch

// checkout the other branch you should have committed to.
git checkout other-branch

// take the temporary commit you created, and apply all of those changes to the new branch. 
//This also deletes the temporary commit from the stack of temp commits.
git stash pop

// add the changes you want with git add...

// re-commit your changes onto other-branch
git commit -m "some message..."

नोट: उपरोक्त उदाहरण में, मैं 1 रीसेट कर रहा था git रीसेट HEAD ~ 1 के साथ। लेकिन अगर आप n कमिट्स को रिवाइंड करना चाहते हैं, तो आप HEAD ~ n को रीसेट कर सकते हैं।

इसके अलावा, यदि आपने गलत शाखा के लिए प्रतिबद्ध किया है, और यह भी समाप्त कर दिया है कि गलत शाखा के लिए प्रतिबद्ध होने से पहले आपको कुछ और कोड लिखना है, तो आप अपने इन-प्रोग्रेस कार्य को बचाने के लिए गिट स्टैश का उपयोग कर सकते हैं:

// save the not-ready-to-commit work you're in the middle of
git stash 

// rewind n commits
git reset HEAD~n 

// stash the committed changes as a single temp commit onto the stack. 
git stash 

// create other-branch (if it doesn't already exist)
git branch other-branch

// checkout the other branch you should have committed to.
git checkout other-branch

// apply all the committed changes to the new branch
git stash pop

// add the changes you want with git add...

// re-commit your changes onto the new branch as a single commit.
git commit -m "some message..."

// pop the changes you were in the middle of and continue coding
git stash pop

नोट: मैंने इस वेबसाइट को एक संदर्भ के रूप में इस्तेमाल किया https://www.clearvision-cm.com/blog/what-to-do-when-you-commit-to-the-wrong-git-branch/

Comments

मेरे साथ भी ऐसा ही हुआ है, मैंने मास्टर में कुछ बदलाव किए हैं, लेकिन मुझे नई शाखा में काम करना चाहिए था और पीआर भेजना चाहिए था, मैंने git checkout -b new_branchवहाँ से बस एक अधिकार कर लिया, कमेंट्स बरकरार थे, बस धकेले गए, और एक पीआर बनाया, didn ' t फिर से कमिट करना है

— निश्चल गौतम

Answer 6

इसलिए यदि आपका परिदृश्य यह है कि आप प्रतिबद्ध हैं, masterलेकिन करने के लिए प्रतिबद्ध है another-branch(जो पहले से मौजूद हो सकता है या नहीं भी हो सकता है) लेकिन आपने अभी तक धक्का नहीं दिया है, तो इसे ठीक करना बहुत आसान है।

// if your branch doesn't exist, then add the -b argument 
git checkout -b another-branch
git branch --force master origin/master

अब आपके सभी काम masterचालू होंगे another-branch।

प्यार से शोक: http://haacked.com/archive/2015/06/29/git-migrate/

Comments

सबसे सीधा तरीका लगता है! यकीन नहीं होता कि इतना कम प्यार और अपोजिट

— keligijus

यह मेरे लिए काम नहीं कर रहा था। another-branchपहले से मौजूद है। इस मामले में, मैंने उन कमिट्स को nuked किया जिन्हें मैंने मास्टर करने के लिए बनाया था और उन्हें नहीं डाला another-branch।

— गिजेल सेरेट

Answer 7

पर विस्तार करने के लिए इस सवाल का जवाब, मामले में आप से स्थानांतरित करने, जैसे कई करता है developकरने के लिए new_branch:

git checkout develop # You're probably there already
git reflog # Find LAST_GOOD, FIRST_NEW, LAST_NEW hashes
git checkout new_branch
git cherry-pick FIRST_NEW^..LAST_NEW # ^.. includes FIRST_NEW
git reflog # Confirm that your commits are safely home in their new branch!
git checkout develop
git reset --hard LAST_GOOD # develop is now back where it started

Comments

मेरे पास वापस जाने के लिए तीन कमिट थे, और यह प्रश्न प्रतीत होता है कि मेरी गांड को आग से बाहर निकाला गया था। धन्यवाद!

— होल्डनवेब

Answer 8

यदि आप इस समस्या में भाग लेते हैं और आपके पास Visual Studio है, तो आप निम्न कार्य कर सकते हैं:

अपनी शाखा पर राइट-क्लिक करें और चुनें View History:

आप जिस पर वापस जाना चाहते हैं, उस पर राइट-क्लिक करें। और आवश्यकतानुसार रिवर्ट या रीसेट करें।

Answer 9

गलत शाखा पर कई लोगों के लिए

यदि आपके लिए, यह सिर्फ 1 कमिट है, तो बहुत सारे अन्य आसान रीसेटिंग समाधान उपलब्ध हैं। मेरे लिए, मेरे पास masterइसके बजाय गलती से किए गए 10 कमिट थे, चलो इसे कॉल करें branch_xyz, और मैं प्रतिबद्ध इतिहास को खोना नहीं चाहता था।

आप क्या कर सकते हैं, और जो मुझे बचाया था वह इस जवाब को एक संदर्भ के रूप में उपयोग कर रहा था , एक 4 कदम प्रक्रिया का उपयोग करके, जो है -

1. से एक नई अस्थायी शाखा बनाएँ master
2. मूल रूप से आवागमन के लिए अभिप्रेत शाखा में विलय, यानी branch_xyz
3. पूर्ववत करें master
4. अस्थायी शाखा हटाएं।

यहाँ विवरण में उपरोक्त चरण हैं -

1. एक नई शाखा बनाएँ master(जहाँ मैंने गलती से बहुत सारे बदलाव किए थे)

   git checkout -b temp_branch_xyz
   

   नोट: -bध्वज का उपयोग एक नई शाखा बनाने के लिए किया जाता है।
   यदि हमें यह अधिकार मिला है तो सत्यापित करने के लिए, git branchहम यह सुनिश्चित करने के लिए एक त्वरित करेंगे कि हम temp_branch_xyzशाखा पर हैं और git logयह जांचने के लिए कि हमें कमिट्स सही मिले।

2. अस्थायी शाखा को मूल रूप से कमिट्स के लिए अभिप्रेत शाखा में मिलाएं branch_xyz।
   सबसे पहले, मूल शाखा पर स्विच करें branch_xyz( यानी git fetchअगर आपको ऐसा करने की आवश्यकता हो सकती है )

   git checkout branch_xyz
   

   नोट:-b
   अब ध्वज का उपयोग नहीं कर रहे हैं , चलिए उस अस्थायी शाखा को उस शाखा में मिलाते हैं जिसे हमने वर्तमान में चेकआउट किया हैbranch_xyz

   git merge temp_branch_xyz
   

   हो सकता है कि आपको यहाँ कुछ संघर्षों का ध्यान रखना पड़े। सफलतापूर्वक विलय के बाद आप (मैं) धक्का दे सकते हैं या अगले चरणों में जा सकते हैं।

3. इस उत्तर को संदर्भ के रूप में masterउपयोग करने पर आकस्मिक रूप से, पहले स्विच पर जाएँmaster

   git checkout master
   

   फिर इसे रिमोट से मिलान करने के लिए सभी तरीके से पूर्ववत करें (या यदि आप चाहें तो विशेष रूप से प्रतिबद्ध करें)

   git reset --hard origin/master
   

   फिर से, मैं git logपहले और बाद में यह सुनिश्चित करने के लिए करूँगा कि इच्छित परिवर्तन प्रभावी हुए।

4. सबूत मिटाते हुए, जो अस्थायी शाखा को हटा रहा है। इसके लिए, पहले आपको उस शाखा की जाँच करने की आवश्यकता है जिसे अस्थायी में मिला दिया गया था, अर्थात branch_xyz(यदि आप masterनीचे रहते हैं और नीचे दिए गए कमांड को निष्पादित करते हैं, तो आपको मिल सकता है error: The branch 'temp_branch_xyz' is not fully merged), तो चलिए

   git checkout branch_xyz
   

   और फिर इस दुर्घटना के सबूत को हटा दें

   git branch -d temp_branch_xyz
   

तुम वहाँ जाओ।

Answer 10

यदि वह शाखा जिसे आप अपने परिवर्तनों को पहले से ही लागू करना चाहते थे ( उदाहरण के लिए शाखा विकास ) , तो नीचे दिए गए फोटान द्वारा दिए गए निर्देशों का पालन करें :

git checkout develop
git rebase develop my_feature # applies changes to correct branch
git checkout develop # 'cuz rebasing will leave you on my_feature
git merge develop my_feature # will be a fast-forward
git branch -d my_feature

और जाहिर है अगर आप चाहते थे तो आप my_feature के बजाय tempbranch या किसी अन्य शाखा के नाम का उपयोग कर सकते थे।

साथ ही, यदि लागू हो, तो अपने लक्ष्य शाखा में विलीन होने के बाद स्टैश पॉप (लागू) में देरी करें।

Comments

मुझे लगता है कि पहला कमांड (चेकआउट डेवलप) अनावश्यक है ... रिबेट केवल "my_feature" चेकआउट करेगा, जैसा कि पहली बात करता है।

— जोएलफैन

इसके अलावा, आप "रिबेस" कमांड के "my_feature" पैरामीटर को छोड़ सकते हैं (क्योंकि आपने पहले से ही "my_feature" की जांच कर ली है)। आप "मर्ज" के "विकसित" पैरामीटर को भी छोड़ सकते हैं (चूंकि आप पहले से ही "विकसित" चेकआउट करते हैं)

— जोएलफैन

Answer 11

मेरे लिए, यह मेरे द्वारा धकेल दी गई प्रतिबद्धता को वापस लेने के द्वारा हल किया गया था, फिर उस शाखा को दूसरी शाखा में ले जाना।

git checkout branch_that_had_the_commit_originally
git revert COMMIT-HASH
git checkout branch_that_was_supposed_to_have_the_commit
git cherry pick COMMIT-HASH

आप git logसही हैश का पता लगाने के लिए उपयोग कर सकते हैं , और आप जब चाहें इन परिवर्तनों को आगे बढ़ा सकते हैं!