खोज…
पूर्ववत विलय
एक मर्ज को अभी तक रिमोट में नहीं धकेला गया
यदि आपने अभी तक अपने विलय को दूरस्थ रिपॉजिटरी में नहीं धकेल दिया है, तो आप उसी प्रक्रिया का पालन कर सकते हैं जैसा कि प्रतिबद्ध में है, हालांकि कुछ सूक्ष्म अंतर हैं।
एक रीसेट सबसे सरल विकल्प है क्योंकि यह मर्ज कमिट और शाखा से जोड़े गए किसी भी कमिट को पूर्ववत् करेगा। हालांकि, आपको यह जानना होगा कि SHA को वापस रीसेट करने के लिए क्या करना है, यह मुश्किल हो सकता है क्योंकि आपका git log अब दोनों शाखाओं के लिए कमिट दिखाएगा। यदि आप गलत प्रतिबद्ध पर रीसेट करते हैं (उदाहरण के लिए दूसरी शाखा पर) तो यह प्रतिबद्ध कार्य को नष्ट कर सकता है।
> git reset --hard <last commit from the branch you are on>
या, मर्ज मान लेना आपकी सबसे हाल की प्रतिबद्धता थी।
> git reset HEAD~
एक रिवर्ट सुरक्षित है, इसमें वह प्रतिबद्ध काम को नष्ट नहीं करेगा, लेकिन इसमें और भी काम शामिल हैं क्योंकि आपको ब्रांच को वापस फिर से मर्ज करने से पहले रिवर्ट करना होगा (अगला भाग देखें)।
एक मर्ज को दूरस्थ में धकेल दिया गया
मान लें कि आप एक नई सुविधा में विलय (ऐड-ग्रेमलिन)
> git merge feature/add-gremlins
...
#Resolve any merge conflicts
> git commit #commit the merge
...
> git push
...
501b75d..17a51fd master -> master
बाद में आपको पता चलता है कि जिस सुविधा का आपने अभी विलय किया है, वह अन्य डेवलपर्स के लिए सिस्टम को तोड़ दिया है, इसे तुरंत पूर्ववत किया जाना चाहिए, और सुविधा को ठीक करने में बहुत अधिक समय लगेगा, इसलिए आप केवल मर्ज को पूर्ववत करना चाहते हैं।
> git revert -m 1 17a51fd
...
> git push
...
17a51fd..e443799 master -> master
इस बिंदु पर gremlins सिस्टम से बाहर हैं और आपके साथी डेवलपर्स ने आप पर चिल्लाना बंद कर दिया है। हालाँकि, हम अभी समाप्त नहीं हुए हैं। एक बार जब आप ऐड-ग्रेम्लिंस सुविधा के साथ समस्या को ठीक कर लेते हैं, तो आपको इसे वापस मर्ज करने से पहले इस रिवर्ट को पूर्ववत करना होगा।
> git checkout feature/add-gremlins
...
#Various commits to fix the bug.
> git checkout master
...
> git revert e443799
...
> git merge feature/add-gremlins
...
#Fix any merge conflicts introduced by the bug fix
> git commit #commit the merge
...
> git push
इस बिंदु पर आपकी सुविधा अब सफलतापूर्वक जोड़ दी गई है। हालांकि, यह देखते हुए कि इस प्रकार के बगों को अक्सर मर्ज संघर्ष द्वारा पेश किया जाता है थोड़ा अलग वर्कफ़्लो कभी-कभी अधिक सहायक होता है क्योंकि यह आपको अपनी शाखा पर मर्ज संघर्ष को ठीक करने देता है।
> git checkout feature/add-gremlins
...
#Merge in master and revert the revert right away. This puts your branch in
#the same broken state that master was in before.
> git merge master
...
> git revert e443799
...
#Now go ahead and fix the bug (various commits go here)
> git checkout master
...
#Don't need to revert the revert at this point since it was done earlier
> git merge feature/add-gremlins
...
#Fix any merge conflicts introduced by the bug fix
> git commit #commit the merge
...
> git push
Reflog का उपयोग करना
यदि आप एक रिबास को पेंच करते हैं, तो फिर से शुरू करने का एक विकल्प कमिट (पूर्व रीबेस) पर वापस जाना है। आप इसे reflog का उपयोग कर सकते हैं (जिसमें पिछले 90 दिनों के लिए आपके द्वारा किए गए हर चीज का इतिहास है - इसे कॉन्फ़िगर किया जा सकता है):
$ git reflog
4a5cbb3 HEAD@{0}: rebase finished: returning to refs/heads/foo
4a5cbb3 HEAD@{1}: rebase: fixed such and such
904f7f0 HEAD@{2}: rebase: checkout upstream/master
3cbe20a HEAD@{3}: commit: fixed such and such
...
आप रिबेस को HEAD@{3} से पहले देख सकते हैं (आप हैश की जांच भी कर सकते हैं):
git checkout HEAD@{3}
अब आप एक नई शाखा बनाते हैं / पुराने को हटाते हैं / फिर से रिबेस करने का प्रयास करते हैं।
आप सीधे अपने reflog में एक बिंदु पर वापस रीसेट कर सकते हैं, लेकिन ऐसा केवल तभी करें जब आप 100% सुनिश्चित हों कि आप क्या करना चाहते हैं:
git reset --hard HEAD@{3}
यह आपके वर्तमान git ट्री को उस बिंदु पर मिलान करने के लिए सेट करेगा, जो उस बिंदु पर था (पूर्ववत परिवर्तन देखें)।
इसका उपयोग तब किया जा सकता है जब आप अस्थायी रूप से देख रहे हों कि किसी शाखा को किसी अन्य शाखा में पुन: उपयोग करने पर कितनी अच्छी तरह काम करता है, लेकिन आप परिणाम नहीं रखना चाहते हैं।
पिछली कमिट पर लौटें
पिछली कमिट पर वापस जाने के लिए, पहले git log का उपयोग करके कमिट के हैश का पता लगाएं।
अस्थायी रूप से उस कमिट पर वापस जाने के लिए, अपने सिर को अलग करें:
git checkout 789abcd
यह आपको 789abcd पर स्थान 789abcd । अब आप अपने सिर पर लगी शाखा को प्रभावित किए बिना इस पुराने कमिट के शीर्ष पर नए कमिट कर सकते हैं। किसी भी परिवर्तन को branch या checkout -b का उपयोग करके एक उचित शाखा में किया जा सकता है।
परिवर्तनों को रखते हुए पिछली कमिट में वापस आने के लिए:
git reset --soft 789abcd
अंतिम कमिट वापस करने के लिए:
git reset --soft HEAD~
किसी विशिष्ट परिवर्तन के बाद किए गए परिवर्तनों को स्थायी रूप से त्यागने के लिए, उपयोग करें:
git reset --hard 789abcd
अंतिम रूप से किए गए परिवर्तनों को स्थायी रूप से छोड़ने के लिए:
git reset --hard HEAD~
खबरदार: जब आप reflog और reset का उपयोग करके हटाए गए कमिट्स को पुनर्प्राप्त कर सकते हैं, तब तक अनकम्यूट किए गए परिवर्तनों को पुनर्प्राप्त नहीं किया जा सकता है। git stash; git reset उपयोग करें git stash; git reset बजाय git reset --hard सुरक्षित होने के लिए।
पूर्ववत परिवर्तन
काम की कॉपी में एक फ़ाइल या निर्देशिका में परिवर्तन करें।
git checkout -- file.txt
सभी फ़ाइल पथों पर उपयोग किया जाता है, वर्तमान निर्देशिका से पुनरावर्ती रूप से, यह कार्यशील प्रतिलिपि में सभी परिवर्तनों को पूर्ववत कर देगा।
git checkout -- .
परिवर्तनों के केवल पूर्ववत भागों के लिए --patch उपयोग --patch । आपको प्रत्येक परिवर्तन के लिए कहा जाएगा, यदि यह पूर्ववत होना चाहिए या नहीं।
git checkout --patch -- dir
इंडेक्स में बदलाव को पूर्ववत करने के लिए।
git reset --hard
--hard फ्लैग के बिना यह एक सॉफ्ट रीसेट करेगा।
स्थानीय कमिट्स के साथ जो आपको अभी तक रिमोट पर धकेलना है, आप एक सॉफ्ट रीसेट भी कर सकते हैं। आप इस प्रकार फ़ाइलों को फिर से काम कर सकते हैं और फिर कमिट कर सकते हैं।
git reset HEAD~2
उपरोक्त उदाहरण आपके अंतिम दो कमिट को खोल देगा और फाइलों को आपकी कार्यशील प्रति में लौटा देगा। फिर आप आगे बदलाव और नए बदलाव कर सकते हैं।
खबरदार: सॉफ्ट रीसेट के अलावा, ये सभी ऑपरेशन आपके परिवर्तनों को स्थायी रूप से हटा देंगे। सुरक्षित विकल्प के लिए, क्रमशः git stash -p या git stash उपयोग करें। आप बाद में stash pop साथ पूर्ववत कर सकते हैं या stash drop साथ हमेशा के लिए हटा सकते हैं।
कुछ मौजूदा कमिट्स वापस करें
मौजूदा कमिट्स को वापस करने के लिए git रिवर्ट का उपयोग करें, खासकर जब उन कमिट्स को किसी दूरस्थ रिपॉजिटरी में धकेल दिया गया हो। यह कुछ नए कमिट्स को रिकॉर्ड करता है, जो पहले के कमिट्स के प्रभाव को उलट देता है, जिसे आप इतिहास को फिर से लिखे बिना सुरक्षित रूप से आगे बढ़ा सकते हैं।
जब तक आप उस रिपॉजिटरी के अन्य सभी उपयोगकर्ताओं के ऑप्रोग्रिब को नीचे लाने की इच्छा नहीं रखते, तब तक git push --force उपयोग न करें। सार्वजनिक इतिहास को कभी भी फिर से लिखना नहीं चाहिए।
यदि, उदाहरण के लिए, आपने अभी-अभी एक कमिट को पुश किया है जिसमें एक बग है और आपको इसे वापस करने की आवश्यकता है, तो निम्न कार्य करें:
git revert HEAD~1
git push
अब आप स्थानीय स्तर पर रिवर्ट कमिट को वापस करने के लिए स्वतंत्र हैं, अपना कोड ठीक करें, और अच्छे कोड को पुश करें:
git revert HEAD~1
work .. work .. work ..
git add -A .
git commit -m "Update error code"
git push
यदि आप जिस प्रतिज्ञा को वापस लेना चाहते हैं, वह पहले से ही इतिहास में वापस आ गई है, तो आप बस प्रतिबद्ध हैश पारित कर सकते हैं। Git आपके मूल प्रतिबद्ध को पूर्ववत करते हुए एक काउंटर-कमिट बनाएगा, जिसे आप अपने रिमोट से सुरक्षित रूप से पुश कर सकते हैं।
git revert 912aaf0228338d0c8fb8cca0a064b0161a451fdc
git push
पूर्ववत करें / फिर से करें
मान लें कि आप एक दर्जन कमियों को पूर्ववत करना चाहते हैं और आप उनमें से कुछ को ही चाहते हैं।
git rebase -i <earlier SHA>
-आई "इंटरएक्टिव मोड" में रिबास डालता है। यह ऊपर चर्चा की गई रीबेस की तरह शुरू होता है, लेकिन किसी भी हिट को फिर से शुरू करने से पहले, यह रुक जाता है और आपको प्रत्येक कमिट को धीरे-धीरे संशोधित करने की अनुमति देता है क्योंकि यह फिर से शुरू होता है। rebase -i आपके डिफ़ॉल्ट टेक्स्ट एडिटर में खुलेगा, इस तरह से लागू होने वाले कमिट की सूची के साथ: 
कमिट करने के लिए, अपने संपादक में बस उस लाइन को हटा दें। यदि आप अब अपनी परियोजना में खराब आवागमन नहीं चाहते हैं, तो आप 1 और 3-4 लाइनों को हटा सकते हैं। यदि आप दो आवागमन को एक साथ जोड़ना चाहते हैं, तो आप squash या fixup कमांड का उपयोग कर सकते हैं 