git - मैं गिट में हालिया कामों को पूर्ववत कैसे करूं?





git-commit git-reset git-revert (25)


SourceTree (GitHub के लिए जीयूआई) पर, आप प्रतिबद्धता पर राइट-क्लिक कर सकते हैं और 'रिवर्स कमिट' कर सकते हैं। यह आपके परिवर्तनों को पूर्ववत करना चाहिए।

टर्मिनल पर:

आप वैकल्पिक रूप से उपयोग कर सकते हैं:

git revert

या:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

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

स्थानीय भंडार से उन लोगों को कैसे पूर्ववत किया जा सकता है?




जिस चीज को आप चाहते हैं उसे पाने के लिए फ़ाइलों को जोड़ें / हटाएं:

git rm classdir
git add sourcedir

फिर प्रतिबद्धता में संशोधन करें:

git commit --amend

पिछली, ग़लत प्रतिबद्धता को नए इंडेक्स राज्य को प्रतिबिंबित करने के लिए संपादित किया जाएगा - दूसरे शब्दों में, ऐसा होगा जैसे आपने पहली बार गलती नहीं की थी।

ध्यान दें कि आपको केवल तभी करना चाहिए यदि आपने अभी तक धक्का नहीं दिया है। यदि आपने धक्का दिया है, तो आपको सामान्य रूप से एक फिक्स करना होगा।




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

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>



मुझे पता लगाने में थोड़ी देर लग गई, तो शायद यह किसी की मदद करेगा ...

आपके अंतिम प्रतिबद्धता को पूर्ववत करने के दो तरीके हैं, इस पर निर्भर करते हुए कि आपने पहले से ही अपना प्रतिबद्ध सार्वजनिक कर दिया है (आपके रिमोट रिपोजिटरी पर धक्का दिया गया है):

स्थानीय प्रतिबद्धता को पूर्ववत कैसे करें

मान लें कि मैंने स्थानीय रूप से प्रतिबद्ध किया है, लेकिन अब उस प्रतिबद्धता को हटाना चाहते हैं।

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

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

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

अब git log दिखाएगा कि हमारी आखिरी प्रतिबद्धता हटा दी गई है।

सार्वजनिक प्रतिबद्धता को पूर्ववत कैसे करें

यदि आप पहले ही अपना काम सार्वजनिक कर चुके हैं, तो आप एक नई प्रतिबद्धता बनाना चाहेंगे जो आपके पिछले प्रतिबद्धता (वर्तमान HEAD) में किए गए परिवर्तनों को "वापस" कर देगी।

git revert HEAD

आपके परिवर्तन अब वापस किए जाएंगे और आपके लिए प्रतिबद्ध होंगे:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

अधिक जानकारी के लिए, गिट मूल बातें देखें - चीजों को पूर्ववत करें




यदि आप अंतिम प्रतिबद्धता में फ़ाइलों को हटाना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

git reset --hard HEAD~1

और यदि अंतिम प्रतिबद्धता में फ़ाइलों की आवश्यकता है, तो आप इसका उपयोग कर सकते हैं:

git reset --soft HEAD~1



git revert commit-id प्रयोग करें

प्रतिबद्ध आईडी प्राप्त करने के लिए, बस git log उपयोग करें




पिछली स्थानीय प्रतिबद्धता को कैसे ठीक करें

एक git commit --amend करने के लिए गिट-गुई (या इसी तरह) का प्रयोग करें - git commit --amend । जीयूआई से आप प्रतिबद्ध से व्यक्तिगत फाइलें जोड़ या निकाल सकते हैं। आप प्रतिबद्ध संदेश भी संशोधित कर सकते हैं।

पिछले स्थानीय प्रतिबद्धता को पूर्ववत कैसे करें

बस अपनी शाखा को पिछले स्थान पर रीसेट करें (उदाहरण के लिए, gitk या git rebase gitk का उपयोग करके)। फिर सहेजे गए प्रतिलिपि से अपने परिवर्तन दोबारा लागू करें। आपके स्थानीय भंडार में कचरा संग्रह के बाद, यह अवांछित प्रतिबद्धता की तरह कभी नहीं होगा। एक ही कमांड में ऐसा करने के लिए, git reset HEAD~1 उपयोग करें।

चेतावनी का शब्द : git reset का लापरवाही उपयोग आपकी कामकाजी प्रति को एक भ्रमित स्थिति में लाने का एक अच्छा तरीका है। मैं अनुशंसा करता हूं कि गिट नौसिखियां इससे बचें यदि वे कर सकते हैं।

सार्वजनिक प्रतिबद्धता को पूर्ववत कैसे करें

परिवर्तनों को पूर्ववत करने के लिए एक रिवर्स चेरी पिक ( git-revert ) करें।

यदि आपने अभी तक अपनी शाखा में अन्य बदलाव नहीं खींचा हैं, तो आप बस कर सकते हैं ...

git revert --no-edit HEAD

फिर अपनी अद्यतन शाखा को साझा भंडार में दबाएं।

प्रतिबद्धता इतिहास दोनों अलग-अलग काम दिखाएगा

उन्नत: सार्वजनिक भंडार में निजी शाखा का सुधार

यह खतरनाक हो सकता है - सुनिश्चित करें कि आपके पास शाखा की स्थानीय प्रतिलिपि है।

यह भी ध्यान दें: यदि आप किसी और शाखा में काम कर रहे हैं तो आप ऐसा नहीं करना चाहते हैं।

git push --delete (branch_name) ## remove public version of branch

अपनी शाखा को स्थानीय रूप से साफ करें, फिर पुन: दबाएं ...

git push origin (branch_name)

सामान्य स्थिति में, आपको शायद अपने निजी-शाखा प्रतिबद्ध इतिहास के बारे में चिंता करने की आवश्यकता नहीं है। बस एक फॉलोअप प्रतिबद्धता को दबाएं (ऊपर 'सार्वजनिक प्रतिबद्धता को पूर्ववत करने के लिए कैसे करें) देखें, और बाद में, इतिहास को छिपाने के लिए squash-merge करें।




"काम करने वाले पेड़ को अंतिम प्रतिबद्धता में रीसेट करें"

git reset --hard HEAD^ 

"काम करने वाले पेड़ से अज्ञात फाइलें साफ़ करें"

git clean    

देखें - गिट त्वरित संदर्भ

नोट: यह आदेश आपकी पिछली प्रतिबद्धता को हटा देगा, इसलिए सावधानी के साथ उपयोग करें! git reset --hard - git reset --hard सुरक्षित है -




एक ही आदेश:

git reset --soft 'HEAD^' 

यह अंतिम स्थानीय प्रतिबद्धता पूर्ववत करने के लिए बहुत अच्छा काम करता है!




यदि आपके पास गिट एक्स्ट्रा इंस्टॉल हैं, तो आप नवीनतम प्रतिबद्धता को पूर्ववत git undo लिए git undo चला सकते हैं। git undo 3 पिछले 3 कामों को पूर्ववत कर देगा।




ऐसा करने के कई तरीके हैं:

पिछली प्रतिबद्धता / पिछली प्रतिबद्धताओं को पूर्ववत करने के लिए गिट कमांड:

चेतावनी: अगर आप नहीं जानते कि आप क्या कर रहे हैं तो इसका उपयोग न करें। --हार्ड बहुत खतरनाक है , और यह आपकी फाइलों को हटा सकता है

गिट में प्रतिबद्धता को वापस करने के लिए मूल आदेश है:

$ git reset --hard <COMMIT -ID>

या

$ git reset --hard HEAD~<n>

COMMIT-ID : प्रतिबद्धता के लिए आईडी

n: पिछली बातों की संख्या है जिसे आप वापस करना चाहते हैं

जैसा कि नीचे दिखाया गया है आप प्रतिबद्ध आईडी प्राप्त कर सकते हैं:

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

जहां d81d3f1 और be20eb8 आईडी प्रतिबद्ध हैं।

अब कुछ मामलों को देखते हैं:

मान लीजिए कि आप अंतिम प्रतिबद्धता 'd81d3f1' को वापस करना चाहते हैं। यहां दो विकल्प दिए गए हैं:

$ git reset --hard d81d3f1

या

$ git reset --hard HEAD~1

मान लीजिए कि आप 'be20eb8' प्रतिबद्धता को वापस करना चाहते हैं:

$ git reset --hard be20eb8

अधिक विस्तृत जानकारी के लिए आप किसी निर्दिष्ट स्थिति में सिर को रीसेट करने के लिए कुछ अन्य आदेशों का भी उल्लेख कर सकते हैं और कोशिश कर सकते हैं:

$ git reset --help



यदि आप इसे स्थायी रूप से पूर्ववत करना चाहते हैं और आपने कुछ भंडार क्लोन किया है

प्रतिबद्ध आईडी द्वारा देखा जा सकता है

git log 

फिर आप कर सकते हैं -

git reset --hard <commit_id>

git push origin <branch_name> -f



git का उपयोग करके नीचे दिए गए कमांड को बस रीसेट करें:

git reset --soft HEAD~1

समझाएं: क्या git reset करता है, यह मूल रूप से किसी भी प्रतिबद्धता को reset कर देता है जिसे आप वापस जाना चाहते हैं, फिर यदि आप इसे - --soft कुंजी के साथ --soft , तो यह वापस जायेगा, लेकिन आपकी फ़ाइल में बदलावों को बनाए रखेगा, इसलिए आप मंच पर वापस आ गए हैं, जिसे फ़ाइल अभी जोड़ा गया था, HEAD शाखा का प्रमुख है और यदि आप ~1 साथ गठबंधन करते हैं (इस मामले में आप HEAD^ का भी उपयोग करते हैं), तो यह केवल एक प्रतिबद्धता वापस जायेगा जो आप चाहते हैं। ..

मैं आपके लिए अधिक जानकारी में नीचे दी गई छवि में चरणों का निर्माण करता हूं, जिसमें वास्तविक परिस्थितियों में होने वाले सभी चरणों और कोड को शामिल करना शामिल है:




अंतिम प्रतिबद्धता पूर्ववत करें:

git reset --soft HEAD^ या git reset --soft HEAD~

यह अंतिम प्रतिबद्धता पूर्ववत करेगा।

यहां - --soft मतलब है स्टेजिंग में रीसेट करें।

HEAD~ या HEAD^ मतलब है सिर से पहले प्रतिबद्ध होना।

अंतिम प्रतिबद्धता को नई प्रतिबद्धता में बदलें:

git commit --amend -m "message"

यह नई प्रतिबद्धता के साथ अंतिम प्रतिबद्धता को प्रतिस्थापित करेगा।




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

git reset --hard HEAD^1

(यह आदेश आपकी पूरी प्रतिबद्धता को अनदेखा कर देगा और आपके परिवर्तन आपके स्थानीय कामकाजी पेड़ से पूरी तरह से खो जाएंगे)। यदि आप अपनी प्रतिबद्धता पूर्ववत करना चाहते हैं, लेकिन आप स्टेजिंग क्षेत्र में अपने परिवर्तन चाहते हैं ( git add बाद ही प्रतिबद्ध होने से पहले) तो निम्न आदेश करें।

git reset --soft HEAD^1

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

git reset HEAD

अब चरणबद्ध क्षेत्र से अस्थिर क्षेत्र में आने वाली फाइलें प्रतिबद्ध हैं। अब फाइलें संपादित करने के लिए तैयार हैं, इसलिए जो भी आप बदलते हैं, आप संपादन करना चाहते हैं और इसे जोड़ना चाहते हैं और एक नई / नई प्रतिबद्धता बनाना चाहते हैं।

More




आखिरी गिट प्रतिबद्धता को पूर्ववत कैसे करें?

आखिरी प्रतिबद्धता से पहले सब कुछ वापस बहाल करने के लिए, हमें सिर से पहले प्रतिबद्धता को रीसेट करने की आवश्यकता है।

  1. यदि आप अपने परिवर्तनों को नहीं रखना चाहते हैं:

    git reset --hard HEAD^
    
  2. यदि आप अपने परिवर्तन रखना चाहते हैं:

    git reset --soft HEAD^
    

अब अपने गिट लॉग की जांच करें। यह दिखाएगा कि हमारी आखिरी प्रतिबद्धता हटा दी गई है।




मेरे मामले में मैंने गलती से कुछ फाइलें की जो मैं नहीं चाहता था। तो मैंने निम्नलिखित किया और यह काम किया:

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Gitk या git log --stat के साथ परिणामों की पुष्टि करें




अंतिम प्रतिबद्धता को बदलने के लिए

इंडेक्स में फ़ाइलों को बदलें:

git rm --cached *.class
git add *.java

फिर, यदि यह एक निजी शाखा है, तो प्रतिबद्धता में संशोधन करें:

git commit --amend

या, यदि यह एक साझा शाखा है, तो एक नई प्रतिबद्धता बनाएं:

git commit -m 'Replace .class files with .java files'


( पिछली प्रतिबद्धता को बदलने के लिए , भयानक इंटरैक्टिव रीबेस का उपयोग करें)

ProTip ™: यह फिर से होने से रोकने के लिए *.class gitignore में *.class जोड़ें।

एक प्रतिबद्धता वापस करने के लिए

प्रतिबद्धता में संशोधन करना आदर्श समाधान है यदि आपको अंतिम प्रतिबद्धता को बदलने की आवश्यकता है, लेकिन एक और सामान्य समाधान reset

आप गिट को किसी भी प्रतिबद्धता के साथ रीसेट कर सकते हैं:

git reset @~N

जहां N HEAD से पहले काम करने की संख्या है, और @~ पिछले प्रतिबद्धता को रीसेट करता है।

तो, प्रतिबद्धता में संशोधन करने के बजाय, आप इसका उपयोग कर सकते हैं:

git reset @~
git add *.java
git commit -m "Add .java files"

यह क्या करता है इसकी बेहतर समझ के लिए, git help reset , विशेष रूप से --soft --mixed और --hard पर --soft --mixed

Reflog

यदि आप गड़बड़ करते हैं, तो आप गिराए गए कामों को खोजने के लिए हमेशा रीफ्लॉग का उपयोग कर सकते हैं:

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started





पहला रन:

git reflog

यह आपको आपके भंडार पर किए गए सभी संभावित कार्यों को दिखाएगा, उदाहरण के लिए, प्रतिबद्ध, विलय, खींचें इत्यादि।

फिर करो:

git reset --hard ActionIdFromRefLog



सरल, इसे अपनी कमांड लाइन में चलाएं:

git reset --soft HEAD~ 



दूसरा रास्ता:

जिस शाखा को आप वापस करना चाहते हैं उसे चेकआउट करें, फिर अपनी स्थानीय कामकाजी प्रतिलिपि को उस प्रतिबद्धता पर रीसेट करें जिसे आप रिमोट सर्वर पर नवीनतम एक बनना चाहते हैं (इसके बाद सब कुछ अलविदा होगा)। ऐसा करने के लिए, SourceTree I में राइट-क्लिक किया गया और चयनित "इस प्रतिबद्धता में BRANCHNAME रीसेट करें"।

फिर अपनी रिपोजिटरी की स्थानीय निर्देशिका पर नेविगेट करें और यह आदेश चलाएं:

git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

यह आपके स्थानीय भंडार में वर्तमान के बाद सभी काम मिटा देगा, लेकिन केवल उस शाखा के लिए।




git log टाइप करें और अंतिम प्रतिबद्ध हैश कोड ढूंढें और फिर दर्ज करें:

git reset <the previous co>



यदि आपने जंक किया है लेकिन धक्का नहीं दिया है,

git reset --soft HEAD~1

हेड ~ 1 सिर से पहले प्रतिबद्धता के लिए एक शॉर्टेंड है। वैकल्पिक रूप से आप हैश के SHA-1 को संदर्भित कर सकते हैं यदि आप रीसेट करना चाहते हैं। --soft विकल्प प्रतिबद्धता को हटा देगा लेकिन यह आपकी सभी बदली गई फ़ाइलों को "परिवर्तन करने के लिए परिवर्तन" छोड़ देगा, क्योंकि गिट स्थिति इसे रखेगी

यदि आप काम करने वाले पेड़ में ट्रैक किए गए फ़ाइलों में किसी भी बदलाव से छुटकारा पाने के लिए चाहते हैं, तो इसके बजाय सिर का उपयोग करने से पहले " --हार्ड "।

या

यदि आप पहले ही धकेल चुके हैं और किसी ने खींचा है जो आम तौर पर मेरा मामला है, तो आप गिट रीसेट का उपयोग नहीं कर सकते हैं। हालांकि आप एक गिट रिवर्ट कर सकते हैं,

git revert HEAD

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




दो मुख्य परिदृश्य हैं

आपने अभी तक प्रतिबद्धता को धक्का नहीं दिया है

अगर समस्या अतिरिक्त फाइलें थीं (और आप उन्हें भंडार पर नहीं चाहते हैं), तो आप उन्हें git rm का उपयोग करके हटा सकते हैं और फिर --amend साथ --amend

git rm <pathToFile>

आप -r साथ, या अन्य Bash कमांड के साथ गठबंधन के साथ पूरी निर्देशिका को भी हटा सकते हैं

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

फ़ाइलों को हटाने के बाद, आप --amend विकल्प के साथ प्रतिबद्ध कर सकते हैं

git commit --amend -C HEAD # the -C option is to use the same commit message

यह आपके हालिया स्थानीय प्रतिबद्धताओं को अतिरिक्त फ़ाइलों को हटाने के लिए फिर से लिख देगा, इसलिए, इन फ़ाइलों को कभी भी पुश पर नहीं भेजा जाएगा और जीसी द्वारा आपके स्थानीय .git रिपोजिटरी से भी हटा दिया जाएगा।

आपने पहले ही प्रतिबद्धता को धक्का दिया है

आप अन्य परिदृश्य का एक ही समाधान लागू कर सकते हैं और फिर -f विकल्प के साथ git push कर सकते हैं, लेकिन यह अनुशंसित नहीं है क्योंकि यह रिमोट हिस्ट्री को एक अलग परिवर्तन के साथ ओवरराइट करता है (यह आपके भंडार को गड़बड़ कर सकता है)।

इसके बजाए, आपको बिना काम के प्रतिबद्धता करना है (इसे याद रखें- यह विकल्प अंतिम प्रतिबद्धता पर इतिहास को फिर से लिखता है)।




सबसे पिछले जवाब खतरनाक रूप से गलत हैं!

यह मत करो:

git branch -t newbranch
git reset --hard HEAD~3
git checkout newbranch

अगली बार जब आप git rebase git pull --rebase (या git pull --rebase ) git pull --rebase उन 3 newbranch चुपचाप newbranch से हटा दिया जाएगा! (नीचे स्पष्टीकरण देखें)

इसके बजाए ऐसा करें:

git reset --keep HEAD~3
git checkout -t -b newbranch
git cherry-pick [email protected]{2}
  • सबसे पहले यह 3 सबसे हालिया --keep को छोड़ देता है ( --keep की तरह है --keep लेकिन सुरक्षित, असम्बद्ध परिवर्तनों को फेंकने के बजाए विफल रहता है)।
  • फिर यह newbranch बंद कर newbranch
  • फिर यह चेरी-पिक्स उन 3 को वापस newbranch पर ले newbranch । चूंकि अब उन्हें किसी शाखा द्वारा संदर्भित नहीं किया जाता है, यह गिट के reflog का उपयोग करके करता है: [email protected]{2} वह प्रतिबद्धता है जिसे HEAD 2 ऑपरेशंस पहले संदर्भित करता था, यानी हम 1 से पहले। newbranch जांच की गई और 2. git reset इस्तेमाल किया गया 3 कामों को त्यागने के लिए git reset करें।

चेतावनी: डिफ़ॉल्ट रूप से रीफ्लॉग सक्षम है, लेकिन यदि आपने इसे मैन्युअल रूप से अक्षम कर दिया है (उदाहरण के लिए "बेयर" गिट रिपोजिटरी का उपयोग करके), आप git reset --keep HEAD~3 चलाने के बाद 3 को वापस ले पाएंगे git reset --keep HEAD~3

एक विकल्प जो रिफ्लॉग पर भरोसा नहीं करता है:

# newbranch will omit the 3 most recent commits.
git checkout -b newbranch HEAD~3
git branch --set-upstream-to=oldbranch
# Cherry-picks the extra commits from oldbranch.
git cherry-pick ..oldbranch
# Discards the 3 most recent commits from oldbranch.
git branch --force oldbranch oldbranch~3

(यदि आप चाहें तो आप @{-1} - पूर्व चेक आउट शाखा - oldbranch बजाय oldbranch )।

तकनीकी स्पष्टीकरण

पहले उदाहरण के बाद 3 git rebase क्यों बंद कर देगा? ऐसा इसलिए है क्योंकि कोई तर्क के साथ git rebase डिफ़ॉल्ट रूप से --fork-point विकल्प को सक्षम बनाता है, जो स्थानीय --fork-point का उपयोग करता है ताकि अपस्ट्रीम शाखा को मजबूती से धक्का दिया जा सके।

मान लीजिए कि जब आपने एम 1, एम 2, एम 3 को नियुक्त किया है तो आपने मूल / मास्टर को ब्रांच किया है, फिर तीन ने खुद को बनाया है:

M1--M2--M3  <-- origin/master
         \
          T1--T2--T3  <-- topic

लेकिन फिर कोई व्यक्ति एम 2 को हटाने के लिए बल-पुशिंग मूल / मास्टर द्वारा इतिहास को फिर से लिखता है:

M1--M3'  <-- origin/master
 \
  M2--M3--T1--T2--T3  <-- topic

अपने स्थानीय रिफ्लॉग का उपयोग करके, git rebase देख सकता है कि आपने मूल / मास्टर शाखा के पहले अवतार से फोर्क किया है, और इसलिए एम 2 और एम 3 काम करता है वास्तव में आपकी विषय शाखा का हिस्सा नहीं है। इसलिए यह उचित रूप से मानता है कि एम 2 को अपस्ट्रीम शाखा से हटा दिया गया था, इसलिए जब आप विषय शाखा का पुन: उपयोग कर लेते हैं तो आप इसे अपनी विषय शाखा में नहीं चाहते हैं:

M1--M3'  <-- origin/master
     \
      T1'--T2'--T3'  <-- topic (rebased)

यह व्यवहार समझ में आता है, और आम तौर पर पुन: प्रयास करते समय करना सही होता है।

तो कारण निम्न आदेश विफल:

git branch -t newbranch
git reset --hard HEAD~3
git checkout newbranch

ऐसा इसलिए है क्योंकि वे गलत स्थिति में रिफ्लॉग छोड़ देते हैं। गिट ने newbranch को एक संशोधन में अपस्ट्रीम शाखा से बाहर newbranch रूप में देखा है जिसमें 3 काम शामिल हैं, फिर reset --hard को हटाने के लिए अपस्ट्रीम के इतिहास को फिर से लिखता है, और अगली बार जब आप git rebase चलाते हैं तो यह उन्हें किसी भी अन्य प्रतिबद्धता की तरह छोड़ देता है अपस्ट्रीम से हटा दिया गया है।

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

अधिक जानकारी के लिए, गिट रिबेस और गिट मर्ज-बेस डॉक्स में --fork-point की परिभाषा देखें।





git git-commit git-reset git-revert