मैं पिछले कमिट में Git रिपॉजिटरी को कैसे वापस लाऊं?

7630

मैं अपनी वर्तमान स्थिति से एक निश्चित प्रतिबद्ध पर किए गए स्नैपशॉट पर वापस कैसे ला सकता हूं?

यदि मैं करता हूं 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?

git  git-checkout  git-reset  git-revert 
— क्रेजी सर्ब
स्रोत
10
116
यहाँ एक बहुत स्पष्ट और पूरी तरह से पोस्ट के बारे में है, सीधे github से git में पूर्ववत बातें।
— नोबिता
3
संबंधित: एक सार्वजनिक रिपो में एक पुराने Git के लिए रोलबैक । ध्यान दें कि प्रश्न एक बाधा जोड़ता है कि रेपो सार्वजनिक है।
58
मैं git से प्यार करता हूं, लेकिन यह तथ्य कि कुछ के लिए 35 उत्तर हैं जो अविश्वसनीय रूप से सरल होने चाहिए, git के साथ एक बड़ा मुद्दा उजागर करता है। या यह डॉक्स है?
— मफिन मैन
2
कैसे शब्द "जाल" का उपयोग करने के लिए बोलचाल की भाषा के रूप में वापस करने के लिए अर्थ है यहां तक ​​कि यहां तक ​​कि एड्रेस्ड नहीं रीसेट करने के लिए ??? 6594 अपवोट्स को अब तक और इस तरह से एडिट नहीं किया गया है, जिससे अंतर पर जोर दिया जा सके? यह "
— कमिटिंग

जवाबों:

9716

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

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

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

# 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 अनुभाग है जो git-revert पर चर्चा कर रहा है ।

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

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

— Cascabel
स्रोत
118
@ रॉड की टिप्पणी पर git revert HEAD~3सबसे अच्छा वाट वापस लौटने के रूप में 3करता हूँ महत्वपूर्ण सम्मेलन है।
— न्यू अलेक्जेंड्रिया
19
क्या आप पूरी संख्या लिख ​​सकते हैं? जैसे:git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
— स्पोकेन 13
16
@MathiasMadsenStav हाँ, आप निश्चित रूप से पूर्ण SHA1 द्वारा कमिट निर्दिष्ट कर सकते हैं। मैंने उत्तर को अधिक पठनीय बनाने के लिए संक्षिप्त हैश का उपयोग किया, और यदि आप टाइप कर रहे हैं तो आप उनका उपयोग भी करते हैं। यदि आप कॉपी और पेस्ट कर रहे हैं, तो हर तरह से पूर्ण हैश का उपयोग करें। यह निर्दिष्ट करने के लिए कि आप किस तरह से नाम कमा सकते हैं, इसका पूरा विवरण देने के लिए आदमी को संशोधित करें ।
— कास्कैबेल
59
आप इसका उपयोग कर सकते हैं git revert --no-commit hash1 hash2 ...और इसके बाद बस एक कमिट में हर एक रिवर्ट कर सकते हैंgit commit -m "Message"
— मिर्को अकोव
6
इस संदर्भ में 'प्रकाशित' का क्या अर्थ है?
— होवीकैंप
1846

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

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

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

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

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

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

दुष्ट कोडर?

अपने दम पर काम करना और बस यह काम करना चाहते हैं? नीचे दिए गए इन निर्देशों का पालन करें, उन्होंने वर्षों तक मेरे और कई अन्य लोगों के लिए मज़बूती से काम किया है।

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

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

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

git reset --hard HEAD

जहां 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

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

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

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

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

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

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

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

git clean -i
— Pogrindis
स्रोत
37
अप्रचलित चेतावनी: ऐसा न करें यदि आप अपनी शाखा को दूसरे लोगों के साथ साझा कर रहे हैं जिनके पास पुराने कमिट की प्रतियां हैं, क्योंकि इस तरह हार्ड रीसेट का उपयोग करने से उन्हें नए रीसेट शाखा के साथ अपने काम को फिर से सिंक्रनाइज़ करने के लिए मजबूर होना पड़ेगा। एक समाधान के लिए जो विस्तार से बताता है कि हार्ड रीसेट के साथ काम खोए बिना सुरक्षित रूप से कैसे वापस आना है, इस उत्तर को देखें ।
7
मैं दूसरी @ कपकेक की चेतावनी ... परिणाम के बारे में बहुत जागरूक हूं। ध्यान दें, हालांकि, अगर आपकी ज़रूरत वास्तव में उन कमिट्स को हमेशा के लिए इतिहास से गायब करने की है, तो यह रीसेट + क्लीन विधि इसे करेगी, और आपको बलपूर्वक अपनी संशोधित शाखाओं को किसी भी और सभी रीमोट पर वापस धकेलने की आवश्यकता होगी ।
— असनाजग
5
git clean -f DANGER DANGER
— टिस्क जूल
2
यह मेरी स्थानीय प्रति के मुखिया को वांछित प्रतिबद्ध के लिए निर्धारित करता है। लेकिन तब मैं किसी भी बदलाव को आगे नहीं बढ़ा सकता क्योंकि यह रिमोट के पीछे है। और अगर मैं रिमोट से खींचता हूं तो यह वापस समाप्त हो जाता है जहां यह रिमोट ब्रांच पर नवीनतम प्रतिबद्ध था। मैं पूरी तरह से (हर जगह से) कैसे अलग हो जाऊं, मेरी स्थानीय कॉपी पर दोनों को धक्का दिया गया है?
— Ade
2
@ ऑड .. आप git push -fध्वज का उपयोग कर सकते हैं .. लेकिन सावधान रहें, यह रिमोट को ओवरराइड करेगा .. सुनिश्चित करें कि आप जानते हैं कि आप क्या करना चाहते हैं ..
— पोग्रिंडिस
176

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

First of all what is HEAD?

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

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

detached HEAD

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

यहां छवि विवरण दर्ज करें

कमांड लाइन पर यह इस तरह दिखेगा - शा.आ.-1 शाखा के नाम के बजाय चूंकि 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 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।

यहां छवि विवरण दर्ज करें

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

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

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

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

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

— स्टीफन ओस्टरमिलर
स्रोत
3
यह नरम और धीरे: जोखिम मुक्त है अगर आपने अपना काम नहीं किया है
— nilsM
124

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

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

यह आपकी पिछली Git कमिटमेंट को हटा देगा।

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

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

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

— किरन बोगरा
स्रोत
2
मैंने इस पोस्ट में १/२ दर्जन उत्तर देने की कोशिश की, जब तक कि मुझे यह एक नहीं मिला .. उन सभी में से, मेरे git config मुझे धक्का देने की कोशिश में एक त्रुटि देता रहा। इस जवाब ने काम कर दिया। धन्यवाद!
— जीन बो
मेरे लिए एक विवरण यह था कि मैंने डिफरेंशियल खो दिया था .. जिसे मैं यह देखना चाहता था कि मैंने जो काम किया था, उसमें मैंने क्या किया। तो अगली बार जब मैं करूंगा सिर्फ इस रीसेट आदेश जारी करने से पहले डेटा को सहेजना
— जीन बो
1
यह मेरे लिए एक बुरा मर्ज पूर्ववत करने का एकमात्र तरीका था, उस मामले में वापस काम नहीं किया। धन्यवाद!
— डेव कोल
सबसे बढ़िया उत्तर। धन्यवाद
— इमरान Pollob
सर्वश्रेष्ठ उत्तर, धन्यवाद।
— user1394
114

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

git add . && git checkout master -f

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

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

मैंने उपरोक्त परिणामों को प्राप्त करने के लिए अधिक सुविधाजनक और सरल तरीका पाया: 

git add . && git reset --hard HEAD

जहां HEAD आपके वर्तमान शाखा की नवीनतम प्रतिबद्धताओं की ओर इशारा करता है।

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

— रोमन माइनोक
स्रोत
83

ठीक है, Git में पिछली कमिट पर वापस जाना काफी आसान है ...

परिवर्तनों को रखे बिना वापस लौटें :

git reset --hard <commit>

परिवर्तन रखने के साथ वापस लौटें :

git reset --soft <commit>

स्पष्टीकरण: का उपयोग करgit reset , आप एक विशिष्ट स्थिति में रीसेट कर सकते हैं। जैसा कि आप ऊपर देख रहे हैं, यह एक प्रतिबद्ध हैश के साथ उपयोग करना आम है।

लेकिन जैसा कि आप देखते हैं कि अंतर दो झंडे का उपयोग कर रहा है --softऔर --hard, डिफ़ॉल्ट रूप से ध्वज git resetका उपयोग कर रहा है --soft, लेकिन यह हमेशा ध्वज का उपयोग करने के लिए एक अच्छा अभ्यास है, मैं प्रत्येक ध्वज का उपयोग करता हूं:

--मुलायम

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

--मुश्किल

इस ध्वज के साथ सावधान रहें। यह काम कर रहे पेड़ और ट्रैक की गई फ़ाइलों के लिए सभी परिवर्तन और सभी चला जाएगा!

मैंने नीचे चित्र भी बनाया है जो वास्तविक जीवन में Git के साथ काम कर सकता है:

एक कमिट पर रीसेट करें

— एलिरेज़ा
स्रोत
का डिफ़ॉल्ट git resetहै git reset --mixed, नहीं git reset --soft। कृपया जांच लें कि git reset --mixed, --soft, और --hard के बीच क्या अंतर है? और सादे अंग्रेजी में, "git रीसेट" क्या करता है?
— फैबियो का कहना है कि मोनिका
70

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

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

मुझे एक ब्लॉग पोस्ट से जवाब मिला (अब मौजूद नहीं है)

ध्यान दें कि यह रिसेटिंग और रिमोट को बदलने के लिए मजबूर कर रहा है, ताकि यदि आपकी टीम के अन्य लोगों ने पहले से ही खींच लिया है, तो आप उनके लिए समस्याएँ पैदा करेंगे। आप परिवर्तन इतिहास को नष्ट कर रहे हैं, जो एक महत्वपूर्ण कारण है कि लोग पहली जगह में गिट का उपयोग करते हैं।

रीसेट की तुलना में रिवर्ट (अन्य उत्तर देखें) का उपयोग करना बेहतर है। अगर आप वन मैन टीम हैं तो शायद कोई फर्क नहीं पड़ता।

— markreyes
स्रोत
6
यह उत्तर दूसरों के असंख्य से अलग कैसे है?
— मत्स्यमथ
बदकिस्मती से। मैंने ब्लॉगर को ईमेल किया - उम्मीद है कि अभी भी उसके पास है!
— मार्क
— टॉम
2
इसे ठीक करने के लिए अधिकांश अन्य सुझावों से पुश सिंटैक्स गायब है। बढ़िया काम किया।
— jpa57
61

कहो कि आपके पास एक पाठ फ़ाइल में निम्नलिखित नाम हैं ~/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 नहीं git revert --to <hash>है मेरे से परे है।

— लांस कारसियोली
स्रोत
41
आप git revert HEAD~3
— रॉड
25
@ रोड - नहीं, यह सही नहीं है। यह आदेश उस प्रतिबद्ध को वापस ले लेगा जो HEAD का तीसरा दादा-दादी है (अंतिम तीन कमिट नहीं)।
— क्फ्फोरेंस
1
@kflorence ठीक है जानकारी के लिए धन्यवाद। चाहेंगे git revert -n master~3..master~1काम करते हैं? (जैसा कि kernel.org/pub/software/scm/git/docs/git-revert.html से देखा गया है )
— रॉड
3
@Rod - यह सही लगता है, यकीन है कि एक बदसूरत वाक्य रचना है, हालांकि यह नहीं है? मैंने हमेशा यह पाया है कि मैं जिस कमिटमेंट को "रिवर्ट" करना चाहता हूँ और फिर उसे और अधिक सहज बनाना।
— kflorence
7
इस तरह की स्क्रिप्ट के साथ अब ऐसा करने का एक बहुत आसान तरीका है, बस उपयोग करें git revert --no-commit <start>..<end>, क्योंकि git revertगिट के नए (या सभी?) संस्करणों में एक प्रतिबद्ध सीमा को स्वीकार करता है। ध्यान दें कि रेंज की शुरुआत रिवर्ट में शामिल नहीं है।
58

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

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

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

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

यह एक बहुत ही थोड़ा संशोधित चार्ल्स बेली के समाधान के लिए एक एसएचए हैश द्वारा Git में वापस करने का समाधान है ? :

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

— उपयोगकर्ता 454514 को दर्शाता है
स्रोत
वैकल्पिक 1 के बारे में, एक त्वरित प्रश्न: ऐसा करने से हम सही के बीच में ढीले नहीं होते?
— बोगैक
2
@ बोगैक - डॉट्स एक फ़ाइल पथ को इंगित करते हैं, इस मामले में वर्तमान निर्देशिका, इसलिए यह माना जाता है कि आप इसे अपनी कार्यशील प्रतिलिपि की जड़ से चला रहे हैं।
— टॉम
चेतावनी को उत्तर में कई बार दोहराया जाता है, लेकिन क्या कोई जोड़ सकता है कि ये सबसे अच्छा तरीका क्यों नहीं हैं - इसकी तुलना, git revert HEAD~2..HEAD@ Cascabel's (@ Jefromi) से जुड़े समाधान की तरह है। मैं समस्या नहीं देख रहा हूँ।
— जोशुआ गोल्डबर्ग
55

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

git reset HEAD~1

तो, प्रतिबद्ध आईडी और इतने पर के लिए कोई ज़रूरत नहीं है :)

— पॉल Walczewski
स्रोत
काम नहीं किया, इस पैदावार के बाद एक पुल खींचो: त्रुटि: निम्न फ़ाइलों के लिए आपके स्थानीय परिवर्तन मर्ज द्वारा अधिलेखित हो जाएंगे:
— malhal
1
@माल यह इसलिए है क्योंकि आपने परिवर्तन नहीं किए हैं। उन्हें स्लेश / रीसेट करें और फिर यह उस त्रुटि के बिना काम करेगा।
— पॉल वॉल्केवस्की
39

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

git back

प्रति आदमी पेज है, यह भी इस तरह के रूप में इस्तेमाल किया जा सकता है:

# Remove the latest three commits
git back 3
— प्रतिच्छाया
स्रोत
38

सबसे अच्छा तरीका है:

git reset --hard <commidId> && git push --force

यह शाखा को विशिष्ट कमिट पर रीसेट कर देगा और फिर रिमोट सर्वर को उसी तरह से अपलोड करेगा जैसा आपके पास स्थानीय है (यह उस विशिष्ट कमिट के बाद कमांड को पूरी तरह से समाप्त कर देगा)

--forceध्वज के साथ सावधान रहें उन्हें पुनर्प्राप्त करने के विकल्प के बिना चयनित प्रतिबद्ध के बाद बाद के सभी कमिटों को हटा देता है।

— david.t_92
स्रोत
3
आकर्षण की तरह काम किया!
— गौरव गुप्ता
मैं downvoted क्योंकि मैं देखना चाहते हैं कि आपका जवाब कोई नई जानकारी उदाहरण के लिए पहले से ही नहीं दिया प्रदान करता है असफल stackoverflow.com/a/37145089/1723886 , stackoverflow.com/a/27438379/1723886 या stackoverflow.com/a/48756719/1723886 । वास्तव में अधिकांश कमिट्स में पहले से ही git reset --hard का उल्लेख होता है, और कई और उल्लेख - पुश करने के लिए --force या -f का उपयोग करते हैं।
— एलेक्स टेलन
यह केवल एक कमांड के साथ काम करता है, स्पष्ट और सरल। यदि आपको यह पसंद नहीं है तो आप मेरे उत्तर को अस्वीकार करने के लिए स्वतंत्र हैं।
— david.t_92
1
भविष्य के लिए विचार करने का एक अन्य विकल्प पहले के उत्तर पर एक संपादन का सुझाव देना है या यह कहते हुए एक टिप्पणी जोड़ना है कि 'उदाहरण के लिए &&' का उपयोग करके इसे एक पंक्ति में भी किया जा सकता है। इस तरह हर कोई फिर एक ही स्थान पर बेहतर जवाब देख सकता है।
— एलेक्स टेलोन
36

सभी परिवर्तनों के बाद, जब आप इन सभी आदेशों को आगे बढ़ाते हैं, तो आपको उपयोग करना पड़ सकता है:

git push -f ...

और न केवल git push।

— sivi
स्रोत
15
अप्रचलित चेतावनी: ऐसा न करें यदि आप अपनी शाखा को अन्य लोगों के साथ साझा कर रहे हैं, जिनके पास पुराने कमिट्स की प्रतियां हैं, क्योंकि इस तरह एक बल पुश का उपयोग करने से उन्हें अपने काम को फिर से संगठित करने के लिए मजबूर होना पड़ेगा। एक समाधान के लिए जो विस्तार से बताता है कि बल धक्का के साथ काम को खोए बिना सुरक्षित रूप से कैसे वापस जाना है, इस उत्तर को देखें ।
3
कभी-कभी यही आप चाहते हैं। उदाहरण: गलत शाखा (शाखा ए) के लिए कई प्रतिबद्ध और प्रतिबद्ध। चेरी को शाखा बी में ले जाने के बाद, मैं चाहता हूं कि इन शाखाओं को शाखा ए से हटा दिया जाए। मैं वापस नहीं लौटना चाहूंगा, क्योंकि बाद में शाखा ए और बी को एक साथ विलय होने पर बाद में लागू किया जाएगा। शाखा A में एक रीसेट - भार <कमिट> A करने के बाद एक बल पुश द्वारा इन शाखाओं को हटा दिया जाता है, जबकि शाखा B में उनका संरक्षण किया जाता है। मैं इस से दूर हो सकता हूं क्योंकि मुझे पता है कि शाखा A. पर किसी और का विकास नहीं हो रहा है
— डग आर
धन्यवाद! मैं यह पता नहीं लगा सका कि मेरी स्थानीय शाखा से मिलान करने के लिए दूरस्थ शाखा कैसे प्राप्त की जाए, बस एक बल पुश करने की आवश्यकता है।
— मिडो
32

आप इन सभी प्रारंभिक चरणों को स्वयं पूरा कर सकते हैं और गिट रिपॉजिटरी में वापस धकेल सकते हैं।

  1. git pull --allआदेश का उपयोग करके Bitbucket से अपने भंडार का नवीनतम संस्करण खींचें ।

  2. -n 4अपने टर्मिनल से Git लॉग कमांड चलाएँ । -nआपके स्थानीय इतिहास में सबसे हालिया प्रतिबद्ध से शुरू होने वाले लॉग में कमिट की संख्या निर्धारित करने के बाद की संख्या ।

    $ git log -n 4

  3. अपने रिपॉजिटरी के इतिहास के प्रमुख को रीसेट करें git reset --hard HEAD~Nजहां N का उपयोग करके आप सिर को वापस ले जाना चाहते हैं। निम्नलिखित उदाहरण में सिर को एक इतिहास में अंतिम प्रतिबद्ध करने के लिए, एक प्रतिबद्ध वापस किया जाएगा:

  4. परिवर्तन को git push --forceबल देने के लिए Git रिपॉजिटरी में परिवर्तन को पुश करें।

अगर आप पिछले कमिट में Git रिपॉजिटरी चाहते हैं:

git pull --all
git reset --hard HEAD~1
git push --force
— नन्हे कुमार
स्रोत
28

अपनी आवश्यक प्रतिबद्ध का चयन करें, और इसे जांचें

git show HEAD
git show HEAD~1
git show HEAD~2

जब तक आपको आवश्यक वचन नहीं मिल जाता। उस बिंदु को हेड बनाने के लिए, करें

git reset --hard HEAD~1

या git reset --hard HEAD~2जो भी हो।

— tonythomas01
स्रोत
7
अप्रचलित चेतावनी: ऐसा न करें यदि आप अपनी शाखा को दूसरे लोगों के साथ साझा कर रहे हैं जिनके पास पुराने कमिट की प्रतियां हैं, क्योंकि इस तरह हार्ड रीसेट का उपयोग करने से उन्हें नए रीसेट शाखा के साथ अपने काम को फिर से सिंक्रनाइज़ करने के लिए मजबूर होना पड़ेगा। एक समाधान के लिए जो विस्तार से बताता है कि हार्ड रीसेट के साथ काम खोए बिना सुरक्षित रूप से कैसे वापस आना है, इस उत्तर को देखें ।
2
इसके अलावा, स्पष्ट होना, git show HEADसिर्फ उपयोग करने के बराबर है git log HEAD -1।
25

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

क्विक एंड डर्टी: परिस्थितियों के आधार पर, त्वरित और गंदे वास्तव में बहुत अच्छे हो सकते हैं। यहाँ मेरा समाधान क्या अपरिवर्तनीय रूप से प्रतिस्थापित नहीं किया गया है जो आपके पास आपके वर्किंग डायरेक्टरी में मौजूद फाइल्स के साथ आपके वर्किंग डायरेक्टरी में है। आपके / .it / डायरेक्टरी के नीचे गुप्त रिपॉजिटरी की गहराइयों से निकाले गए हैं। अनेक। आप जो कुछ भी विनाशकारी स्थिति प्रतीत हो सकती है, उसे प्राप्त करने के लिए और फिर से पर्याप्त विशेषज्ञता के बिना ऐसा करने का प्रयास घातक साबित हो सकता है, जो कुछ भी हो सकता है, ऐसा करने के लिए नहीं है ।

  1. पूरी निर्देशिका को कॉपी करें और इसे कुछ और कॉल करें, जैसे "मेरा प्रोजेक्ट - कॉपी"। आपकी गिट रिपॉजिटरी ("रेपो") फाइलों को "मेरी परियोजना" निर्देशिका (उनके लिए डिफ़ॉल्ट स्थान, ".गित" नामक एक निर्देशिका के तहत) के तहत मान लिया गया है, अब आप अपनी काम की फाइलों और अपनी रेपो फाइलों दोनों की नकल करेंगे।

  2. इस निर्देशिका में "मेरी परियोजना" करें:

    .../my project $ git reset --hard [first-4-letters&numbers-of-commit's-SHA]

यह "मेरी परियोजना" के तहत रेपो की स्थिति को वापस कर देगा, जब आपने वह काम किया था ("कमिट" का अर्थ है आपके काम करने वाली फ़ाइलों का स्नैपशॉट)। तब से सभी कमिट्स "मेरी परियोजना" के तहत हमेशा के लिए खो जाएंगे, लेकिन ... वे अब भी "मेरे प्रोजेक्ट - कॉपी" के तहत रेपो में मौजूद रहेंगे , क्योंकि आपने उन सभी फाइलों को कॉपी किया है - जिनमें अंडर / ... शामिल हैं। /।

आपके पास तब आपके सिस्टम पर दो संस्करण होते हैं ... आप पूर्व की ओर से ब्याज की फाइलों की जांच कर सकते हैं या कॉपी या संशोधित कर सकते हैं। आप "मेरा प्रोजेक्ट - कॉपी" के तहत फाइलों को पूरी तरह से त्याग सकते हैं, यदि आपने नया काम तय कर लिया है क्योंकि पुनर्निर्मित प्रतिबद्ध कहीं नहीं था ...

स्पष्ट बात यह है कि यदि आप वास्तव में इस काम को छोड़ दिए बिना परियोजना की स्थिति को आगे बढ़ाना चाहते हैं, क्योंकि यह पुनः प्राप्त करने के लिए अपनी निर्देशिका को फिर से नाम देना है: परियोजना को हटाए गए प्रतिबद्ध को हटा दें (या इसे एक अस्थायी नाम दें) और अपना नाम बदल दें " मेरी परियोजना - कॉपी "निर्देशिका" वापस "मेरी परियोजना" के लिए। फिर शायद यहां कुछ अन्य उत्तरों को समझने की कोशिश करें, और संभवत: जल्द ही एक और प्रतिबद्ध करें।

गिट एक शानदार रचना है, लेकिन कोई भी व्यक्ति "उड़ने पर इसे लेने" में सक्षम नहीं है: ऐसे लोग भी जो इसे बहुत दूर तक समझाने की कोशिश करते हैं, अक्सर दूसरे वीसीएस [संस्करण नियंत्रण प्रणाली] का पूर्व ज्ञान ग्रहण करते हैं और बहुत दूर तक गहरा करते हैं बहुत जल्द, और अन्य अपराध करते हैं, जैसे "चेक आउट" के लिए विनिमेय शब्दों का उपयोग करना - उन तरीकों से जो कभी-कभी एक शुरुआत को भ्रमित करने के लिए लगभग गणना करते हैं।

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

खासकर अगर, उदाहरण के लिए, यह एक हताश स्थिति है और आप गिट के साथ एक नौसिखिया हैं!

पुनश्च: एक दूसरे ने सोचा: यह (अब) वास्तव में जीआईटी रेपो को कार्यशील फाइलों के साथ एक के अलावा एक निर्देशिका में रखने के लिए काफी सरल है। इसका मतलब यह है कि आपको उपरोक्त त्वरित और गंदे समाधान का उपयोग करके पूरे गिट रिपॉजिटरी को कॉपी नहीं करना होगा। --separate-git-dir यहाँ उपयोग करके फ्रायर का उत्तर देखें । चेतावनी दी है , यद्यपि: यदि आपके पास "अलग-निर्देशिका" रिपॉजिटरी है जिसे आप कॉपी नहीं करते हैं, और आप एक हार्ड रीसेट करते हैं, तो रीसेट कमिट के बाद के सभी संस्करण हमेशा के लिए खो जाएंगे, जब तक आपके पास, जैसा कि आप बिल्कुल होना चाहिए, नियमित रूप से अपनी रिपॉजिटरी का समर्थन किया, अन्य स्थानों के बीच क्लाउड (जैसे Google ड्राइव ) के लिए अधिमानतः ।

"बैक अप टू द क्लाउड" के इस विषय पर, अगला कदम GitHub या (मेरे विचार में बेहतर) GitLab के साथ एक खाता खोलने (निश्चित रूप से) है । फिर आप git pushअपने क्लाउड रेपो-टू-डेट "ठीक से" बनाने के लिए नियमित रूप से एक कमांड कर सकते हैं । लेकिन फिर, इस बारे में बात करना बहुत जल्द हो सकता है।

— माणिक कृंतक
स्रोत
23

यह हाल ही में किए गए प्रतिबद्ध के लिए सीधे रीसेट करने का एक और तरीका है

git stash
git stash clear

यह सीधे उन सभी परिवर्तनों को स्पष्ट करता है जो आप पिछले प्रतिबद्ध के बाद से कर रहे हैं।

पुनश्च: इसमें थोड़ी समस्या है; यह आपके द्वारा हाल ही में संग्रहीत स्टेश परिवर्तनों को भी हटा देता है। मुझे लगता है कि ज्यादातर मामलों में कोई फर्क नहीं पड़ता।

— प्वाइंट नेटवर्क
स्रोत
नोट: नई फ़ाइलें जो इंडेक्स में नहीं जोड़ी गई हैं वे अटकी नहीं हैं। आपने उन्हें भी जोड़ दिया है या मैन्युअल रूप से उन्हें हटा दिया है।
— ओरियो डे
क्यों ओह क्यों समाशोधन? गैर-समाधान होने के अलावा, यह वास्तव में हानिकारक है। प्रश्न के पहले ही वाक्य को पढ़ना तुरंत स्टैश सॉल्यूशन को अमान्य कर देता है (जो कि केवल LAST कमिट पर रीसेट करने के लिए उपयोगी हो सकता है)।
— रोमेनवेलरी
22

कुछ आकस्मिक परिवर्तनों से एक कोडर की निर्देशिका को पूरी तरह से साफ करने के लिए, हमने उपयोग किया:

git add -A .
git reset --hard HEAD

बस git reset --hard HEADसंशोधनों से छुटकारा मिल जाएगा, लेकिन इसे "नई" फ़ाइलों से छुटकारा नहीं मिलेगा। उनके मामले में वे गलती से एक महत्वपूर्ण फ़ोल्डर को यादृच्छिक रूप से खींच reset --hardलेंगे , और उन सभी फ़ाइलों को गिट द्वारा नया माना जा रहा था , इसलिए इसे ठीक नहीं किया। git add -A .पहले से चलाकर , यह स्पष्ट रूप से उन सभी को गिट के साथ ट्रैक करता है, रीसेट द्वारा मिटा दिया जाना है।

— क्रिस मोसचिनी
स्रोत
21

पिछली कमेटी से एचएएडी में बदलाव करने और पिछली कमेटी में जाने के लिए, करें:

git reset <SHA>

यदि परिवर्तन पिछली प्रतिबद्धता से HEAD के लिए आवश्यक नहीं हैं और सभी परिवर्तनों को छोड़ दें, तो करें:

git reset --hard <SHA>
— विष्णु अतरई
स्रोत
20

मेरा मानना ​​है कि कुछ लोग इस सवाल पर आ सकते हैं कि यह जानना चाहते हैं कि अपने मास्टर में किए गए बदलावों को कैसे रोलबैक किया जाए - यानी सबकुछ फेंक दें और मूल / मास्टर पर वापस जाएं, जिस स्थिति में, यह करें:

git reset --hard origin/master

/superuser/273172/how-to-reset-master-to-origin-master

— nevster
स्रोत
18

उल्टा कमिट्स को रोलबैक करने की कमांड है।

git revert <commit1> <commit2>

नमूना:

git revert 2h3h23233

यह नीचे की तरह ही हेड से रेंज लेने में सक्षम है। यहां 1 कहता है "अंतिम प्रतिबद्ध वापस करें।"

git revert HEAD~1..HEAD

और फिर करते हैं git push

— सिरेश यारलागड्डा
स्रोत
14

इच्छित कमिट पर रीसेट करने का प्रयास करें -

git reset <COMMIT_ID>

(COMMIT_ID उपयोग की जांच करने के लिए git log)

यह सभी परिवर्तित फ़ाइलों को अन-एडेड स्थिति में रीसेट कर देगा।

अब आप checkoutसभी अन-एडेड फ़ाइलों को कर सकते हैं

git checkout .

git logअपने परिवर्तनों को सत्यापित करने के लिए जाँच करें।

अपडेट करें

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

git update-ref -d HEAD

— optimistanoop
स्रोत
13

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

आपको पहले मूल से विकास हटाने की आवश्यकता है :

git push origin :develop (note the colon)

फिर आपको अपनी मनचाही स्थिति को विकसित करने की आवश्यकता है, मुझे लगता है कि प्रतिबद्ध हैश EFGHIJK है:

git reset --hard EFGHIJK

अंत में, फिर से विकास को आगे बढ़ाएं :

git push origin develop
— जॉर्ज निनन
स्रोत
13

सावधान! यदि उपयोगकर्ता गलत तरीके से गलती करता है तो यह कमांड कमिट हिस्ट्री खो सकती है। हमेशा अपने git का अतिरिक्त बैकअप रखें जहां अगर आप गलतियाँ करते हैं तो कुछ और जहाँ आप कर सकते हैं। :)

मेरे पास इसी तरह का मुद्दा है और मैं पहले वाली कमिट पर वापस लौटना चाहता हूं। मेरे मामले में मुझे नई प्रतिबद्धता रखने में कोई दिलचस्पी नहीं थी, इसलिए मैंने इसका इस्तेमाल किया Hard।

मैंने इस तरह से इसे किया:

git reset --hard CommitId && git clean -f

यह स्थानीय रिपॉजिटरी पर वापस आ जाएगा, और यहां उपयोग करने के बाद git push -fरिमोट रिपॉजिटरी को अपडेट करेगा।

git push -f
— maytham-ɯɐɥʇʎɐɯ
स्रोत
13

में GitKraken आप यह कर सकते हैं:

  1. आप जिस रीसेट को रीसेट करना चाहते हैं, उस पर राइट क्लिक करें: इस कमेट पर रीसेट करें / हार्ड :

    यहां छवि विवरण दर्ज करें

  2. फिर से कमेंट पर राइट क्लिक करें, चुनें: करंट ब्रांच नाम / पुश :

    यहां छवि विवरण दर्ज करें

  3. फोर्स पुश पर क्लिक करें :

    यहां छवि विवरण दर्ज करें

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

— Ângelo Polotto
स्रोत
11

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

— उपुल दोलुवेरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.