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




git-checkout git-reset git-revert (25)

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

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

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

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


Answers

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

git push -f ...

और न केवल git push


वापसी करना कमांड को रोलबैक करने का आदेश है।

git revert <commit1> <commit2> 

नमूना:

git revert 2h3h23233

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

git revert HEAD~1..HEAD

और फिर करो git push


रोलबैक के लिए (या वापस करने के लिए):

  1. गिट रिवर्ट - नो-प्रतिबद्ध "प्रतिबद्ध-कोड-टू-रीम" हेड (उदाहरण के लिए गिट रिवर्ट - नो-प्रतिबद्ध d57a39d HEAD)
  2. गिट प्रतिबद्ध
  3. गिट पुश

दो चरणों से ऊपर आज़माएं, और यदि आपको लगता है कि यह वही है जो आप चाहते हैं तो गिट पुश करें।

अगर आपको कुछ गलत लगता है:

गिट रिवर्ट --बॉर्ट


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

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

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

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

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

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


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

जेफ्रोमी के समाधान निश्चित रूप से सबसे अच्छे हैं, और आपको निश्चित रूप से उनका उपयोग करना चाहिए। हालांकि, पूर्णता के लिए, मैं इन अन्य वैकल्पिक समाधानों को भी दिखाना चाहता था जिनका उपयोग किसी प्रतिबद्धता को वापस करने के लिए भी किया जा सकता है (इस अर्थ में कि आप एक नई प्रतिबद्धता बनाते हैं जो पिछली प्रतिबद्धता में परिवर्तन को 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 [email protected]{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> बाद जोड़े गए हैं।


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

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

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

git reset --hard HEAD~1

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


सावधान! यह आदेश गलती से गलत इतिहास डालता है, अगर उपयोगकर्ता गलती से गलत इतिहास डाल सकता है। हमेशा अपने गिट के अतिरिक्त बैकअप लें, जहां कहीं भी अगर आप गलतियां करते हैं, तो आप थोड़ा सुरक्षित हैं। :)

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

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

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

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

git push -f

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

git reset HEAD~1

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


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

git add -A .
git reset --hard HEAD

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


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

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

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

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

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

git clean -i


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

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

git push origin :develop (note the colon)

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

git reset --hard EFGHIJK

अंत में, फिर से विकास धक्का:

git push origin develop

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

git stash
git stash clear

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

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


सबसे हालिया प्रतिबद्धता पर वापस जाएं और सभी स्थानीय परिवर्तनों को अनदेखा करें:

git reset --hard HEAD

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

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

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

    $ git log -n 4

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

  4. परिवर्तन को धक्का देने के लिए गिट रेपो में परिवर्तन को git push --forceदबाएं।

यदि आप पिछले प्रतिबद्धता के लिए गिट भंडार चाहते हैं

git pull --all
git reset --hard HEAD~1
git push --force

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

git reset --hard origin/master

https://superuser.com/questions/273172/how-to-reset-master-to-origin-master


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

git add . && git checkout master -f

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

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

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

git add . && git reset --hard HEAD

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

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


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

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

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

# 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 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 [email protected]{1}

git commit -m "Revert to 56e05fced"

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

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


इस सटीक संयोजन के अलावा यहां मेरे लिए कुछ भी नहीं किया गया है:

git reset --hard <commit_hash>
git push origin <branch_name> --force

यहां कुंजी पुश को मजबूर कर रही है, कोई अतिरिक्त प्रतिबद्ध / संदेश संदेश आदि नहीं है।


पिछली प्रतिबद्धता से HEAD में परिवर्तनों को रखने और पिछले प्रतिबद्धता पर जाने के लिए, करें:

git reset <SHA>

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

git reset --hard <SHA>

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

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

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

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

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


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

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

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

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


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

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

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

#!/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> नहीं है git revert --to <hash> मेरे बाहर है।


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


  • जब आप pull उपयोग करते हैं, तो गिट स्वचालित रूप से आपके लिए अपना काम करने की कोशिश करता है। यह संदर्भ संवेदनशील है , इसलिए गिट उस शाखा में किसी भी खींची गई मज़े को मर्ज करेगा जो आप वर्तमान में काम कर रहे हैं। pull स्वचालित रूप से आपको उनकी समीक्षा करने के बिना कामों को विलय कर लेती है । यदि आप अपनी शाखाओं का बारीकी से प्रबंधन नहीं करते हैं, तो आप लगातार संघर्ष में भाग ले सकते हैं।

  • जब आप fetch , तो गिट लक्ष्य शाखा से कोई भी काम एकत्र करता है जो आपकी वर्तमान शाखा में मौजूद नहीं है और उन्हें आपके स्थानीय भंडार में संग्रहीत करता है । हालांकि, यह उन्हें आपकी वर्तमान शाखा के साथ विलय नहीं करता है । यह विशेष रूप से उपयोगी होता है यदि आपको अपनी रिपॉजिटरी को अद्यतित रखने की आवश्यकता है, लेकिन कुछ ऐसी चीजों पर काम कर रहे हैं जो आपकी फ़ाइलों को अपडेट करते हैं तो तोड़ सकते हैं। अपनी मास्टर शाखा में काम को एकीकृत करने के लिए, आप merge उपयोग करते हैं।





git git-checkout git-reset git-revert