सवाल एक गिट भंडार को पिछले प्रतिबद्धता में कैसे वापस लाया जाए


मैं अपने वर्तमान राज्य से एक निश्चित प्रतिबद्धता पर किए गए स्नैपशॉट में कैसे वापस आऊंगा?

यदि मैं करता हूँ git log, तो मुझे निम्न आउटपुट मिलता है:

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

3 नवंबर से प्रतिबद्धता पर वापस कैसे आते हैं, यानी प्रतिबद्धता 0d1d7fc?


6021
2017-11-06 16:58


मूल


सम्बंधित आखिरी गिट प्रतिबद्धता को पूर्ववत कैसे करें?।
यहां बताया गया है एक बहुत स्पष्ट और पूरी तरह से पोस्ट गिटब से सीधे गिट में चीजों को पूर्ववत करने के बारे में। - Nobita
सम्बंधित: एक सार्वजनिक रिपो में एक पुराने गिट प्रतिबद्ध करने के लिए रोलबैक। ध्यान दें कि वह प्रश्न एक बाधा डालता है कि रेपो सार्वजनिक है।
मुझे गिट पसंद है, लेकिन तथ्य यह है कि कुछ ऐसे 35 उत्तरों हैं जो अविश्वसनीय रूप से सरल होना चाहिए, गिट के साथ एक बड़ी समस्या का खुलासा करता है। या यह दस्तावेज़ है? - The Muffin Man


जवाब:


यह "रिवर्ट" से आपका क्या मतलब है इस पर बहुत निर्भर करता है।

अस्थायी रूप से एक अलग प्रतिबद्धता पर स्विच करें

यदि आप अस्थायी रूप से वापस जाना चाहते हैं, तो चारों ओर मूर्ख रहें, फिर आप कहां हैं, वहां वापस आएं, आपको बस वांछित प्रतिबद्धता की जांच करनी है:

# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32

या यदि आप वहां रहते समय काम करना चाहते हैं, तो आगे बढ़ें और जब आप इसमें हों तो एक नई शाखा बनाएं:

git checkout -b old-state 0d1d7fc32

जहां आप थे वहां वापस जाने के लिए, बस उस शाखा को देखें जो आप फिर से थे। (यदि आपने शाखाएं स्विच करते समय हमेशा परिवर्तन किए हैं, तो आपको उनके साथ उचित तरीके से निपटना होगा। आप उन्हें फेंकने के लिए रीसेट कर सकते हैं; आप उन्हें अपने साथ ले जाने के लिए स्टैश, चेकआउट, स्टैश पॉप कर सकते हैं; आप प्रतिबद्ध कर सकते हैं यदि आप वहां एक शाखा चाहते हैं तो उन्हें वहां एक शाखा में।)

अप्रकाशित कामों को हार्ड हटाएं

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

# 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.

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

नई प्रतिबद्धताओं के साथ प्रकाशित प्रतिबद्धता पूर्ववत करें

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

# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053

# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD

#Similarly, you can revert a range of commits using commit hashes:
git revert a867b4af..0766c053 

# Reverting a merge commit
git revert -m 1 <merge_commit_sha>

# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .

# Then commit. Be sure and write a good message describing what you just did
git commit

git-revert मैनपेज वास्तव में इसके विवरण में बहुत कुछ शामिल है। एक और उपयोगी लिंक है यह git-scm.com अनुभाग गिट-रिवर्ट पर चर्चा करता है

यदि आप तय करते हैं कि आप सभी के बाद वापस नहीं हटना चाहते हैं, तो आप वापस लौट सकते हैं (जैसा कि यहां बताया गया है) या वापस लौटने से पहले रीसेट करें (पिछला खंड देखें)।

आपको इस मामले में यह उत्तर उपयोगी भी मिल सकता है:
हेड वापस पिछले स्थान पर कैसे स्थानांतरित करें? (अलग सिर)


7841
2017-11-06 17:04



@ रॉड की टिप्पणी पर git revert HEAD~3 वापस लौटने के लिए सबसे अच्छा wat के रूप में 3 काम महत्वपूर्ण सम्मेलन है। - New Alexandria
क्या आप पूरी संख्या लिख ​​सकते हैं? पसंद: git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50 - Spoeken
@MathiasMadsenStav हां, आप निश्चित रूप से पूर्ण SHA1 द्वारा प्रतिबद्ध निर्दिष्ट कर सकते हैं। मैंने उत्तर को अधिक पठनीय बनाने के लिए संक्षेप में हैश का उपयोग किया, और यदि आप टाइप कर रहे हैं तो आप उनका उपयोग भी करते हैं। यदि आप प्रतिलिपि बना रहे हैं और पेस्ट कर रहे हैं, तो हर तरह से पूर्ण हैश का उपयोग करें। देख मैन गिट रेव-पार्स में संशोधन निर्दिष्ट करना आप कैसे नाम दे सकते हैं के पूर्ण विवरण के लिए। - Cascabel
वर्तमान में वापस पाने के लिए कमांड 'गिट चेकआउट मास्टर' है - Xavier John
आप उपयोग कर सकते हैं git revert --no-commit hash1 hash2 ... और इसके बाद बस एक प्रतिबद्धता में हर एक वापसी को प्रतिबद्ध करें git commit -m "Message" - Mirko Akov


वर्किंग कॉपी को हालिया कमेटी में वापस कर रहा है

किसी भी बदलाव को अनदेखा करते हुए, पिछली प्रतिबद्धता पर वापस जाने के लिए:

git reset --hard HEAD

जहां आपकी वर्तमान शाखा में हेड अंतिम प्रतिबद्धता है

वर्किंग कॉपी को पुरानी प्रतिबद्धता में वापस लाएं

सबसे हालिया प्रतिबद्धता से पुरानी प्रतिबद्धता पर वापस जाने के लिए:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft HEAD@{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

क्रेडिट एक समान स्टैक ओवरफ़्लो प्रश्न पर जाते हैं, गिट में एक एसएचए हैश द्वारा एक प्रतिबद्धता पर वापस?


1262
2017-08-21 06:19



मैंने ऐसा किया, लेकिन फिर मैं रिमोट रिपोजिटरी को प्रतिबद्ध और धक्का देने में सक्षम नहीं था। मैं एक विशिष्ट पुरानी प्रतिबद्धता बनना चाहता हूं ... - Lennon
इसका मतलब है कि आप पहले से ही उन चीजों में धकेल चुके हैं जिन्हें आप वापस करना चाहते हैं। यह उन लोगों के लिए बहुत सारी समस्याएं पैदा कर सकता है जिन्होंने आपके कोड की जांच की है और उस पर काम कर रहे हैं। चूंकि वे आपकी प्रतिबद्धता को आसानी से लागू नहीं कर सकते हैं। ऐसे मामले में बेहतर एक गिट वापसी करें। यदि आप रेपो का उपयोग कर एकमात्र हैं। एक गिट पुश-एफ करें (लेकिन ऐसा करने से पहले दो बार सोचें) - vinothkr
अनिवार्य चेतावनी: हार्ड रीसेट नहीं है यदि आप अपनी शाखा को अन्य लोगों के साथ साझा कर रहे हैं जिनके पास पुराने कामों की प्रतियां हैं, क्योंकि इस तरह की हार्ड रीसेट का उपयोग करके उन्हें अपने रीसेट को नई रीसेट शाखा के साथ पुन: सिंक्रनाइज़ करना होगा। मुलायम रीसेट सुरक्षित है, साथ ही साथ अंतिम समाधान भी सुरक्षित है यह जवाब।
मैं यह भी इंगित करना चाहता हूं कि, वैकल्पिक रूप से मुलायम रीसेट समाधान के लिए, पहले मिश्रित रीसेट करने और हार्ड रीसेट करने के बजाय, आप वास्तव में पहले हार्ड रीसेट कर सकते हैं, जैसा कि निम्न है: git reset --hard 56e05fc; git reset --soft HEAD@{1}; git commit।
@ न्यूटन लिनस खुद को घुमाकर, गिट के निर्माता ने बहुत जटिल होने के लिए आलोचना की। वह रिकॉर्ड पर कह रहे हैं कि वह "चौंक गया" गिट अपनी जटिलता के कारण इतना लोकप्रिय हो गया - boulder_ruby


यहां जटिल और खतरनाक उत्तरों के बहुत सारे हैं, लेकिन यह वास्तव में आसान है:

git revert --no-commit 0766c053..HEAD
git commit

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

( --no-commit झंडा गिट को एक ही समय में सभी कामों को वापस करने देता है - अन्यथा आपको सीमा में प्रत्येक प्रतिबद्धता के लिए एक संदेश के लिए संकेत दिया जाएगा, अनावश्यक नई प्रतिबद्धताओं के साथ अपने इतिहास को कूड़ा जाएगा।)

यह है एक पिछले राज्य में रोलबैक के लिए सुरक्षित और आसान तरीका। कोई इतिहास नष्ट नहीं हुआ है, इसलिए इसका उपयोग उन लोगों के लिए किया जा सकता है जो पहले से ही सार्वजनिक किए जा चुके हैं।


1221
2018-02-12 04:18



यदि आप वास्तव में व्यक्तिगत काम करना चाहते हैं (एक बड़ी प्रतिबद्धता के साथ सबकुछ वापस करने के बजाय), तो आप पास कर सकते हैं --no-edit के बजाय --no-commit, ताकि आपको प्रत्येक रिवर्सन के लिए एक प्रतिबद्ध संदेश संपादित करने की आवश्यकता न हो।
यदि 0766c053..HEAD के बीच में से कोई एक विलय है तो एक त्रुटि पॉप अप हो जाएगी (निर्दिष्ट नहीं के साथ करने के लिए)। यह उन लोगों की मदद कर सकता है जो: stackoverflow.com/questions/5970889/... - timhc22
उपयोग करने से पहले अंतर देखने के लिए git diff --cached। - John Erck
$ git revert --no-commit 53742ae..HEAD रिटर्न fatal: empty commit set passed - Alex G
@AlexG ऐसा इसलिए है क्योंकि आपको हैश दर्ज करना होगा एक पहले वह जिसे आप वापस जाना चाहते हैं। मेरे मामले में, हैश इस तरह थे: 81bcc9e HEAD{0}; e475924 HEAD{1}, ... (से git reflog), और मैं जो करना चाहता था उसे पूर्ववत करना चाहता था 81bcc9e, तो मुझे करना था git revert e475924..HEAD - EpicPandaForce


मेरे और शायद दूसरों के लिए सबसे अच्छा विकल्प गिट रीसेट विकल्प है:

git reset --hard <commidId> && git clean -f

यह मेरे लिए सबसे अच्छा विकल्प रहा है! यह सरल, तेज़ और प्रभावी है!


ध्यान दें :  जैसा कि टिप्पणियों में उल्लिखित है, ऐसा न करें अगर आप अपनी शाखा को अन्य लोगों के साथ साझा कर रहे हैं जिनके पास पुराने कामों की प्रतियां हैं

टिप्पणियों से भी, यदि आप कम 'बॉलजी' विधि चाहते थे तो आप इसका उपयोग कर सकते थे

git clean -i 


153
2017-10-22 11:53



अनिवार्य चेतावनी: ऐसा मत करो यदि आप अपनी शाखा को अन्य लोगों के साथ साझा कर रहे हैं जिनके पास पुराने कामों की प्रतियां हैं, क्योंकि इस तरह की हार्ड रीसेट का उपयोग करके उन्हें अपने रीसेट को नई रीसेट शाखा के साथ पुन: सिंक्रनाइज़ करना होगा। एक ऐसे समाधान के लिए जो विस्तार से बताता है कि हार्ड रीसेट के साथ काम खोने के बिना सुरक्षित रूप से कैसे काम करना है, यह जवाब देखें।
मैं दूसरा @ कपकेक की चेतावनी ... परिणामों के बारे में बहुत जागरूक रहें। नोट, हालांकि, अगर आपकी ज़रूरत है कि वास्तव में उन लोगों को इतिहास से गायब कर दिया जाए, तो यह रीसेट + क्लीन विधि इसे करेगा, और आपको इसकी आवश्यकता होगी बल अपनी संशोधित शाखाओं को किसी भी और सभी रिमोट पर वापस धक्का दें। - ashnazg
याद रखें, साफ-सफाई फाइलों / फ़ोल्डरों जैसे .idea (phpstorm) या .vagrant (vagrant) को हटा देगा जो आपके सेट अप / आईडीई द्वारा उपयोग किया जा सकता है! - timhc22
गिट क्लीन-डेंजर डेंजर - Tisch
@Pogrindis - यहां पर बहुत अच्छे उत्तर हैं जो अनचाहे फ़ाइलों को हटा नहीं देते हैं। - Tisch


यदि आप "असामान्य" करना चाहते हैं, तो अंतिम प्रतिबद्ध संदेश मिटाएं, और संशोधित फ़ाइलों को स्टेजिंग में वापस रखें, आप कमांड का उपयोग करेंगे:

git reset --soft HEAD~1
  • --soft इंगित करता है कि असामान्य फ़ाइलों को विरोध करने वाली फ़ाइलों के रूप में बनाए रखा जाना चाहिए --hard जो उन्हें त्याग देगा।
  • HEAD~1 आखिरी प्रतिबद्धता है। यदि आप रोलबैक 3 करना चाहते हैं तो आप इसका उपयोग कर सकते हैं HEAD~3। यदि आप एक विशिष्ट संशोधन संख्या में रोलबैक करना चाहते हैं, तो आप अपने एसएचए हैश का उपयोग करके भी ऐसा कर सकते हैं।

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

स्रोत: http://nakkaya.com/2009/09/24/git-delete-last-commit/


103
2018-03-04 17:25



यह नरम और धीरे-धीरे है: यदि आपने अपना काम धक्का नहीं दिया है तो जोखिम मुक्त हो - nilsM


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

First of all what is HEAD?

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

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


detached HEAD

यदि आप नवीनतम प्रतिबद्धता पर नहीं हैं - जिसका अर्थ है HEAD इतिहास में पूर्व प्रतिबद्धता को इंगित कर रहा है जिसे इसे कहा जाता है detached HEAD

Enter image description here

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

Enter image description here


एक अलग सिर से कैसे ठीक होने के बारे में कुछ विकल्प:


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@{...}

यह आपको आपकी वांछित प्रतिबद्धता पर वापस ले जाएगा

Enter image description here


git reset HEAD --hard <commit_id>

अपने सिर को वांछित प्रतिबद्धता पर वापस ले जाएं।

# 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.

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

Enter image description here


102
2018-02-05 21:56



उत्कृष्ट संकेत git reflog, यह वही है जो मुझे चाहिए था - smac89
आउच! यह सब बहुत जटिल लगता है ... क्या कोई आसान आदेश नहीं है जो आपको प्रक्रिया में एक कदम वापस ले जाता है? अपनी परियोजना में संस्करण 1.1 से संस्करण 1.0 पर जाने की तरह? मुझे कुछ ऐसा लगता है: git stepback_one_commit या कुछ .... - Kokodoko
वहाँ है: git reset HEAD^ --hard` - CodeWizard
@ कोकोदोको हां, यह बेहद जटिल है ... और यह एक आदर्श उदाहरण है कि विशेषज्ञों के लिए कितने कम विचार विशेषज्ञ हैं जो अभी शुरू कर रहे हैं। कृपया मेरा उत्तर यहां देखें, और उस पुस्तक के लिए भी जिसमें मैं अनुशंसा करता हूं। गिट ऐसा कुछ नहीं है जिसे आप आसानी से उठा सकते हैं। और मैं बिल्कुल निश्चित हो सकता हूं कि कोडविज़ार्ड ऐसा नहीं करता था। - mike rodent


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

git add . && git checkout master -f

संक्षिप्त वर्णन:

  • यह किसी भी काम के रूप में नहीं बनाएगा git revert कर देता है।
  • यह आपके सिर को अलग नहीं करेगा git checkout <commithashcode> कर देता है।
  • यह आपके सभी स्थानीय परिवर्तनों को ओवरराइड करेगा और शाखा में अंतिम प्रतिबद्धता के बाद से सभी अतिरिक्त फ़ाइलों को हटा देगा।
  • यह केवल शाखाओं के नामों के साथ काम करता है, इसलिए आप इस तरह शाखा में केवल नवीनतम प्रतिबद्धता को वापस कर सकते हैं।

मुझे ऊपर दिए गए परिणामों को प्राप्त करने के लिए एक और अधिक सुविधाजनक और सरल तरीका मिला:

git add . && git reset --hard HEAD

जहां हेड वर्तमान शाखा में नवीनतम प्रतिबद्धता को इंगित करता है।

यह वही कोड कोड है जैसा कि बोल्डर_रुबी ने सुझाव दिया है, लेकिन मैंने जोड़ा है git add . से पहले git reset --hard HEAD आखिरी प्रतिबद्धता के बाद से बनाई गई सभी नई फाइलों को मिटाने के लिए, क्योंकि अधिकांश लोगों की अपेक्षा है कि मैं नवीनतम प्रतिबद्धता पर वापस लौटने पर विश्वास करता हूं।


96
2017-07-29 11:01





आप इसे निम्नलिखित दो आदेशों से कर सकते हैं:

git reset --hard [previous Commit SHA id here]
git push origin [branch Name] -f

यह आपकी पिछली गिट प्रतिबद्धता को हटा देगा।

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

git reset --soft [previous Commit SHA id here]

फिर यह आपके परिवर्तनों को बचाएगा।


76
2017-12-12 06:52



मैंने इस पोस्ट में 1/2 दर्जन उत्तरों का प्रयास किया जब तक कि मुझे यह नहीं मिला .. उन सभी में से, मेरे गिट कॉन्फ़िगरेशन ने मुझे धक्का देने की कोशिश करते समय मुझे एक त्रुटि दे दी। यह जवाब काम किया। धन्यवाद! - gnB
मेरे लिए एक विवरण यह था कि मैंने diffs खो दिया .. जो मैं देखना चाहता था कि मैंने जो काम किया है उसमें मैंने क्या किया था। तो अगली बार जब मैं इस रीसेट कमांड को जारी करने से पहले उस डेटा को सहेज लेगा - gnB
खराब विलय को पूर्ववत करने का यही एकमात्र तरीका था, उस मामले में वापस नहीं लौटा। धन्यवाद! - Dave Cole


मान लें कि आपके पास नाम की एक टेक्स्ट फ़ाइल में निम्न कार्य करता है ~/commits-to-revert.txt (मैंनें इस्तेमाल किया git log --pretty=oneline उन्हें पाने के लिए)

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

बनाओ दे घुमा के उनमें से प्रत्येक को वापस करने के लिए खोल स्क्रिप्ट:

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

यह सब कुछ वापस पिछले राज्य में वापस ले जाता है, जिसमें फ़ाइल और निर्देशिका निर्माण, और हटाना शामिल है, इसे अपनी शाखा में प्रतिबद्ध करें और आप इतिहास को बनाए रखें, लेकिन आपने इसे उसी फ़ाइल संरचना में वापस कर दिया है। गिट के पास क्यों नहीं है git revert --to <hash> मेरे बाहर है


51
2017-10-13 21:51



आप एक कर सकते हैं git revert HEAD~3 पिछले 3 कामों को हटाने के लिए - Rod
@ रोड - नहीं, यह सही नहीं है। वह आदेश उस वचन को वापस लाएगा जो हेड का तीसरा दादा है (अंतिम तीन काम नहीं करता)। - kflorence
@ रोड - यह सही लगता है, यकीन है कि एक बदसूरत वाक्यविन्यास है, है ना? मैंने हमेशा उस प्रतिबद्धता की जांच की है जिसे मैं "वापस" करना चाहता हूं और फिर इसे अधिक सहज बनाना चाहता हूं। - kflorence
@ लांस मैं आपके साथ गिट रिवर्ट के बारे में सहमत हूं - यह - यह एक साधारण चीज़ प्राप्त करने के लिए अविश्वसनीय रूप से जटिल तरीका जैसा लगता है! - Mike Vella
वहां एक बहुत आसान इस तरह की एक स्क्रिप्ट के साथ अब ऐसा करने का तरीका, बस उपयोग करें git revert --no-commit <start>..<end>, इसलिये git revert गिट के नए (या सभी?) संस्करणों में एक प्रतिबद्धता सीमा स्वीकार करता है। ध्यान दें कि सीमा की शुरुआत को वापस करने में शामिल नहीं किया गया है।


जेफ्रोमी के समाधान के अतिरिक्त विकल्प

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

स्पष्ट करने के लिए, इन विकल्पों काम वापस करने का सबसे अच्छा तरीका नहीं है, जेफ्रोमी के समाधान हैं, लेकिन मैं सिर्फ यह इंगित करना चाहता हूं कि आप वही चीज़ प्राप्त करने के लिए इन अन्य विधियों का भी उपयोग कर सकते हैं git revert

वैकल्पिक 1: हार्ड और सॉफ्ट रीसेट

यह चार्ल्स बेली के समाधान का एक बहुत ही छोटा संस्करण है गिट में एक एसएचए हैश द्वारा एक प्रतिबद्धता पर वापस?:

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft HEAD@{1}

# Commit the changes
git commit -m "Revert to <commit>"

यह मूल रूप से इस तथ्य का उपयोग करके काम करता है कि मुलायम रीसेट इंडेक्स / स्टेजिंग-क्षेत्र में पिछली प्रतिबद्धता की स्थिति को छोड़ देगा, जिसे आप तब कर सकते हैं।

वैकल्पिक 2: वर्तमान पेड़ को हटाएं और नए के साथ बदलें

यह समाधान svick के समाधान से आता है पुरानी प्रतिबद्धता जांचें और इसे एक नई प्रतिबद्ध बनाएं:

git rm -r .
git checkout <commit> .
git commit

इसी तरह वैकल्पिक # 1 के लिए, यह राज्य की पुनरुत्पादन करता है <commit> वर्तमान कामकाजी प्रति में। ऐसा करना जरूरी है git rm पहले क्योंकि git checkout उन फ़ाइलों को नहीं हटाएगा जिन्हें बाद में जोड़ा गया है <commit>


48
2018-02-29 08:40



वैकल्पिक 1 के बारे में, एक त्वरित सवाल: ऐसा करके हम सही काम करने के बीच में ढीले नहीं होते? - Bogac
वैकल्पिक 2 में, डॉट्स उन आदेशों में क्या खड़े हैं? - Bogac
@Bogac - डॉट्स एक फ़ाइल पथ इंगित करते हैं, इस मामले में वर्तमान निर्देशिका, इसलिए यह माना जाता है कि आप इसे अपनी कार्यशील प्रति की जड़ से चला रहे हैं। - Tom