मैं Git में सबसे हाल के स्थानीय कमेंट्स को पूर्ववत कैसे करूं?

Question

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

मैं उन स्थानीय भंडार से कैसे पूर्ववत कर सकता हूं?

Comments

नया उत्तर पोस्ट करने से पहले, विचार करें कि इस प्रश्न के लिए पहले से ही 65+ उत्तर हैं। सुनिश्चित करें कि आपका उत्तर योगदान देता है जो मौजूदा उत्तरों में नहीं है।

— सज्जाद हिसैन खान

तुम्हें पता है कि क्या जरूरत है? git undo, बस। फिर प्रतिष्ठा के लिए हमारे द्वारा की गई गलतियों से निपटने के लिए केवल नश्वर गायब हो जाते हैं। किसी भी gitकमांड को निष्पादित करने से पहले एक गिट स्टैक पर वर्तमान स्थिति को धक्का देकर लागू करें । यह प्रदर्शन को प्रभावित करेगा, इसलिए इसे सक्षम करने के लिए एक कॉन्फ़िगर ध्वज जोड़ना सबसे अच्छा होगा।

— यमिन रोंग

@YiminRong जो Git की aliasसुविधा के साथ किया जा सकता है : git-scm.com/book/en/v2/Git-Basics-Git-Aliases

— Edric

@RomainValeri - समान रूप से हर जगह पूर्ववत काम करता है।

— यमिन रोंग

@ यमीन्रॉन्ग इसे नहीं खरीद रहा है। लोग अभी भी गड़बड़ाएंगे और चीजों को पूर्ववत नहीं करेंगे। लेकिन इससे भी महत्वपूर्ण बात git reflogयह है कि आप जो भी वर्णन करते हैं , वह पहले से ही करीब है, लेकिन उपयोगकर्ता को (अन) किए जाने पर अधिक नियंत्रण प्रदान करता है। लेकिन कृपया, नहीं, "पूर्ववत करें" हर जगह समान काम नहीं करता है, और लोग इस सुविधा को प्राप्त करने के लिए कई अलग-अलग चीजों की अपेक्षा करेंगे । पूर्ववत करें? अंतिम क्रिया पूर्ववत करें? यदि अंतिम क्रिया एक धक्का थी, तो वास्तव में कैसे, (रीसेट और पुश) या (रिवर्ट और पुश)?

— रोमेनैवलेरी

Answer 1

पूर्ववत करें और फिर से करें

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)

1. इसे आप पूर्ववत करना चाहते हैं।
2. यह आपके काम करने वाले पेड़ (डिस्क पर आपकी फ़ाइलों की स्थिति) के लिए कुछ भी नहीं करता है, लेकिन प्रतिबद्ध को कम कर देता है और आपके द्वारा किए गए परिवर्तनों को छोड़ देता है (इसलिए वे "कमिट के लिए नहीं बदले गए" के रूप में प्रकट होंगे git status, इसलिए आपको इसकी आवश्यकता होगी करने से पहले उन्हें फिर से जोड़ें)। यदि आप केवल पिछली प्रतिबद्धताओं में अधिक परिवर्तन जोड़ना चाहते हैं, या प्रतिबद्ध संदेश ^{1 को} बदलना चाहते हैं , तो आप git reset --soft HEAD~इसके बजाय उपयोग कर सकते हैं , जो कि git reset HEAD~² जैसा है, लेकिन आपके मौजूदा परिवर्तनों का मंचन छोड़ देता है।
3. वर्किंग ट्री फ़ाइलों में सुधार करें।
4. git add कुछ भी जो आप अपने नए कमिट में शामिल करना चाहते हैं।
5. पुराने प्रतिबद्ध संदेश का पुन: उपयोग करते हुए परिवर्तन करें। resetपुराने सिर की नकल की .git/ORIG_HEAD; commitके साथ -c ORIG_HEADएक संपादक खोलेगा, जिसमें शुरू में पुरानी प्रतिबद्ध से लॉग संदेश शामिल है और आपको इसे संपादित करने की अनुमति देता है। यदि आपको संदेश को संपादित करने की आवश्यकता नहीं है, तो आप -Cविकल्प का उपयोग कर सकते हैं ।

हालाँकि, खबरदार, कि अगर आपने इंडेक्स में कोई नया बदलाव जोड़ा है, तो उपयोग करके commit --amendउन्हें अपनी पिछली प्रतिबद्धताओं में जोड़ा जाएगा।

यदि कोड आपके सर्वर पर पहले से ही धकेल दिया गया है और आपके पास इतिहास को फिर से लिखने की अनुमति है (तो):

git push origin master --force

आप इस उत्तर को भी देख सकते हैं:

मैं HEAD को पिछले स्थान पर वापस कैसे ले जा सकता हूं? (अलग किया गया सिर) और पूर्ववत करें

उपरोक्त उत्तर आपको दिखाएगा git reflog,कि इसका उपयोग यह पता लगाने के लिए किया जाता है कि SHA-1 क्या है, जिसे आप वापस करना चाहते हैं। एक बार जब आपको वह बिंदु मिल गया, जिसे आप ऊपर बताए अनुसार कमांड के अनुक्रम का उपयोग करने के लिए पूर्ववत करना चाहते हैं।

---

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

^{2 के} HEAD~ रूप में ही है HEAD~1। इसके अलावा, देखें कि git में HEAD क्या है? । यदि आप एक से अधिक कमियों को दूर करना चाहते हैं तो यह उपयोगी है।

Comments

और अगर प्रतिबद्ध गलत शाखा के लिए था, तो आप git checkout theRightBranchसभी परिवर्तन चरणों के साथ हो सकते हैं । जैसा कि मुझे अभी करना था।

— फ्रैंक शीयर

यदि आप डॉस में काम कर रहे हैं, तो इसके बजाय git reset --soft HEAD^आपको उपयोग करने की आवश्यकता होगी git reset --soft HEAD~1। ^ डॉस में एक निरंतरता चरित्र है इसलिए यह ठीक से काम नहीं करेगा। इसके अलावा, --softडिफ़ॉल्ट है, तो आप इसे पसंद कर सकते हैं यदि आप चाहें और बस कहें git reset HEAD~1।

— रयान लूनी

zsh उपयोगकर्ता प्राप्त कर सकते हैं: zsh: no matches found: HEAD^- आपको भागने की आवश्यकता है ^ यानीgit reset --soft HEAD\^

— tnajdek

जवाब सही नहीं है, अगर दुर्घटना से, git commit -aजारी किया गया था जब -aछोड़ दिया जाना चाहिए था। किस मामले में, यह बेहतर नहीं है --soft(जो परिणाम देगा--mixed डिफ़ॉल्ट होगा) और फिर आप उन परिवर्तनों को पुनर्स्थापित कर सकते हैं जो आप करने के लिए थे।

— डेमन्सफील्ड

@IcyBrk git add एक कमांड है। git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p] [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]] [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing] [--chmod=(+|-)x] [--] [<pathspec>…​]

— अशरफ.शाक Feb६

Answer 2

यदि आप नहीं जानते कि यह कैसे काम करता है, तो कमिट करना थोड़ा डरावना है। लेकिन यह वास्तव में आश्चर्यजनक रूप से आसान है यदि आप समझते हैं।

मान लें कि आपके पास यह है, जहां C आपकी HEAD है और (F) आपकी फाइलों की स्थिति है।

   (F)
A-B-C
    ↑
  master

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

git reset --hard HEAD~1

परिणाम है:

 (F)
A-B
  ↑
master

अब B HEAD है। क्योंकि आपने उपयोग किया था --hard, आपकी फ़ाइलें कमिट B पर उनके राज्य में रीसेट हो गई हैं।

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

   (F)
A-B-C
    ↑
  master

आप ऐसा कर सकते हैं --hard:

git reset HEAD~1

इस मामले में परिणाम है:

   (F)
A-B-C
  ↑
master

दोनों ही मामलों में, HEAD नवीनतम प्रतिबद्ध के लिए एक संकेतक है। जब आप एgit reset HEAD~1 , तो आप जीआईटी को HEAD पॉइंटर को वापस करने के लिए कहते हैं। लेकिन (जब तक आप उपयोग नहीं करते --hard) आप अपनी फ़ाइलों को वैसे ही छोड़ देते हैं जैसे वे थे। इसलिए अब git statusउन परिवर्तनों को दिखाता है जिन्हें आपने सी में जांचा था। आपने एक चीज़ नहीं खोई है!

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

git reset --soft HEAD~1

यह न केवल आपकी फ़ाइलों को अकेला छोड़ देता है, यह आपके सूचकांक को भी छोड़ देता है अकेला । जब आप करते हैं git status, तो आप देखेंगे कि वही फ़ाइलें पहले की तरह सूचकांक में हैं। वास्तव में, इस आदेश के ठीक बाद, आप कर सकते थे git commitऔर आप उसी प्रतिबद्धता को फिर से लागू करेंगे जो आपने अभी-अभी की थी।

एक और बात: मान लीजिए कि आप एक कमिट को नष्ट कर देते हैं पहले उदाहरण के रूप में को , लेकिन फिर पता चलता है कि आपको इसकी आवश्यकता है ? कठिन भाग्य, है ना?

नहीं, अभी भी इसे वापस लाने का एक तरीका है। टाइप करें git reflogऔर आपको (आंशिक) कमिट शॉ (यानी, हैश) की एक सूची दिखाई देगी , जिसे आप चारों ओर ले गए हैं। आपके द्वारा नष्ट की गई प्रतिबद्धता का पता लगाएं, और यह करें:

git checkout -b someNewBranchName shaYouDestroyed

अब आप फिर से जीवित हो गए हैं। कमिट्स वास्तव में कुछ 90 दिनों के लिए गिट में नष्ट नहीं होते हैं, इसलिए आप आमतौर पर वापस जा सकते हैं और एक को छुड़ा सकते हैं जिसका मतलब आपको छुटकारा पाने के लिए नहीं था।

Comments

सावधान! यदि आपकी त्रुटिपूर्ण प्रतिबद्धता एक (तेज़-फ़ॉरवर्ड) मर्ज थी, तो आप ऐसा नहीं कर सकते हैं! यदि आपका सिर एक मर्ज कमिट पर है (उदा: मास्टर में शाखा सुविधा), git reset --hard~1तो मास्टर शाखा को सुविधा शाखा के अंदर अंतिम प्रतिबद्ध के लिए इंगित करेगा। इस मामले में रिश्तेदार कमांड के बजाय विशिष्ट प्रतिबद्ध आईडी का उपयोग किया जाना चाहिए।

— क्रिस Kerekes

एक महत्वपूर्ण बिंदु गुम होना: यदि उक्त प्रतिबद्ध पहले रिमोट से 'पुश' किया गया था, तो कोई भी 'पूर्ववत' ऑपरेशन, चाहे कितना भी सरल हो, बाकी के उपयोगकर्ताओं के लिए भारी दर्द और पीड़ा का कारण होगा, जिनकी स्थानीय प्रति में यह प्रतिबद्ध है, जब वे भविष्य में 'गिट पुल' करते हैं। तो, अगर कमिट पहले ही 'पुश' कर दिया गया था, तो इसके बजाय ऐसा करें: git

— revert <bad-

@ फ्रैक्टलस्पेस, यह "भारी दर्द और पीड़ा का कारण नहीं होगा।" मैंने एक टीम के साथ Git का उपयोग करते समय कुछ बल धक्का दिया है। यह सब संचार है।

— रेयान लुंडी

@Kyralessa मेरे कार्यस्थल में, पूरी टीम के वर्कफ़्लो को गड़बड़ाना और फिर उन्हें यह बताना कि श * ट को कैसे ठीक करना है, इसे 'संचार' नहीं कहा जाता है। git history re-write एक विनाशकारी ऑपरेशन है जिसके परिणामस्वरूप रेपो के कुछ हिस्सों को ट्रैश किया जाता है। इसके उपयोग पर जोर देते हुए, जबकि स्पष्ट और सुरक्षित विकल्प उपलब्ध हैं, बस गैर जिम्मेदाराना है।

— फ्रैक्टलस्पेस

मैं कमिट करना चाहता था और फिर कभी नहीं देखा। मैंने आपके उदाहरण का उपयोग किया, --hardलेकिन मुझे इस बात का अहसास नहीं था कि मेरे काम करने वाले पेड़ में मेरे सारे अस्थिर परिवर्तन भी नोंच जाते हैं! मैं बाद में किए गए कमिट के हिस्से के रूप में इन फाइलों को करने जा रहा था। अब इन फ़ाइलों को वापस पाना असंभव लग रहा है - मैंने आपके द्वारा पोस्ट किए गए समाधान को भी आज़माया reflogथा, लेकिन यह पहले से अप्रभावित परिवर्तनों को पुनर्स्थापित नहीं कर पाया।

— एडम बुर्ले

Answer 3

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

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

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

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.

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

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 मूल बातें - पूर्ववत बातें देखें ।

Comments

मुझे यह उत्तर सबसे स्पष्ट लगा। git revert HEAD^पिछले नहीं है, पिछले के पिछले है। मैंने किया: git revert HEADऔर फिर फिर से धक्का दिया और यह काम किया :)

— nacho4d

अगर Git आपसे पूछता है "अधिक?" जब आप इन आदेशों की कोशिश करते हैं, तो इस उत्तर पर वैकल्पिक वाक्यविन्यास का उपयोग करें: stackoverflow.com/a/14204318/823470

— tar

Answer 4

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

git rm classdir
git add sourcedir

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

git commit --amend

पिछली, त्रुटिपूर्ण प्रतिबद्धताओं को नए सूचकांक राज्य को प्रतिबिंबित करने के लिए संपादित किया जाएगा - दूसरे शब्दों में, यह ऐसा होगा जैसे आपने पहले कभी गलती नहीं की।

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

Comments

FYI करें: यह मेरी सभी फाइलों को हटा देता है और मैंने बदलाव खो दिए हैं।

— egorlitvinenko

UPD: हालाँकि, मैंने इसे फिर से उपयोग करके बहाल कर दिया है। लेकिन प्रारंभिक प्रतिबद्धताओं के लिए रसीद काम नहीं करती थी।

— egorlitvinenko

git rm --cachedफ़ाइलों को फाइलसिस्टम में रखने के लिए उपयोग करें और केवल उन्हें git इंडेक्स से हटाएं!

— xuiqzy

Answer 5

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

या

git reset --hard HEAD~1

चेतावनी: उपरोक्त आदेश स्थायी रूप से उन .javaफ़ाइलों (और किसी भी अन्य फ़ाइलों) के संशोधनों को हटा देगा जो आप करना चाहते थे।

hard resetकरने HEAD-1के लिए प्रतिबद्ध अपने गलत प्रतिबद्ध से पहले राज्य के लिए अपने काम की नकल सेट हो जाएगा।

Comments

git commit -a -m ""या git commit -am ""स्वाभाविक रूप से! :]

— trejder

एक और 'शार्टकट' स्टैश का उपयोग; यदि आप सब कुछ (पूर्ववत जोड़ना) करना चाहते हैं git stash, तो बसgit stash pop

— seanriordan08

Answer 6

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

सूचकांक में फ़ाइलों को बदलें:

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

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

git commit --amend

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

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

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

---

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

---

एक कमिट वापस करने के लिए

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

आप Git को किसी भी कमिट के साथ रीसेट कर सकते हैं:

git reset @~N

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

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

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

बाहर की जाँच करें git help reset, विशेष रूप से वर्गों पर --soft --mixedऔर--hard , यह क्या करता है की एक बेहतर समझ के लिए।

Reflog

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

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

Comments

भविष्य में पढ़ने वालों के लिए - कृपया ध्यान दें कि git revertएक अलग कमांड है - जो मूल रूप से एक एकल स्मारक को 'रीसेट' करता है।

— BKSpurgeon

Answer 7

का उपयोग करें git revert <commit-id>।

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

Comments

इसका क्या मतलब है, चेरी कमिटमेंट लेती है? मेरे मामले में, मैं एक फ़ाइल संपादित करते समय गलत शाखा पर था। मैंने तब यह महसूस किया कि मैं गलत शाखा में था। "Git reset --soft HEAD ~ 1" का उपयोग करने से मुझे कमिट से पहले ही वापस मिल गया, लेकिन अब अगर मैं सही ब्रांच की जांच करूं, तो मैं गलत ब्रांच में फाइल में हुए बदलावों को पूर्ववत कैसे कर दूं, लेकिन उन्हें उसी नाम से बनाऊं फ़ाइल) सही शाखा में?

— खगोलविद

मैंने सिर्फ git revert commit-idएक आकर्षण की तरह काम किया। बेशक तब आपको अपने बदलावों को आगे बढ़ाने की जरूरत होगी।

— केसी रॉबिन्सन

मेरा मानना ​​है कि यह git cherry-pick <<erroneous-commit-sha>>@astronomerdave होगा । श्री, लगभग-2-वर्षों-देर से पार्टी से।

— टॉम हावर्ड

@ क्रिस: चेरी-पिक यूज़ रिबेस के बजाय। क्योंकि यह उन्नत चेरी-पिकिंग है

— यूजेन कोनकोव

यदि मैंने पहले ही अपनी प्रतिबद्धता को धक्का दे दिया है, तो मैं केवल वापस उपयोग करूँगा। अन्यथा, रीसेट एक बेहतर विकल्प है। यह मत भूलो कि उल्टा एक नई प्रतिबद्धता बनाता है, और आमतौर पर यह लक्ष्य नहीं है।

— होला सो ईदु फेलिज नवाडीद

Answer 8

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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

अधिक

Comments

@SMR, आपके उदाहरण में, सभी केवल वर्तमान HEAD में इंगित कर रहे हैं। HEAD ^ = HEAD ^ 1। साथ ही HEAD ^ 1 = HEAD ~ 1। जब आप HEAD ~ 2 का उपयोग करते हैं, तो ~ और ^ प्रतीकों में अंतर होता है। यदि आप ~ 2 का अर्थ है "पहले माता-पिता की पहली संतान," या "दादा-दादी"।

— मधु अय्यासमि

Answer 9

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

Answer 10

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

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 [e-mail]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Comments

एक साझा भंडार पर इतिहास को फिर से लिखना बहुत बुरा विचार है। मुझे लगता है कि आप जानते हैं कि आप क्या कर रहे हैं, मुझे उम्मीद है कि भविष्य के पाठक भी करेंगे।

— ब्रैड कोच

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

— नीनी

"वास्तविक दुनिया की तरह, यदि आप इतिहास को फिर से लिखना चाहते हैं, तो आपको एक साजिश की जरूरत है: हर किसी को साजिश पर 'में' होना होगा (कम से कम हर कोई जो इतिहास के बारे में जानता है, यानी हर कोई जो कभी शाखा से खींच लिया है) । " स्रोत: stackoverflow.com/a/2046748/334451

— मिकको रेंटालिनेन

Answer 11

मैं git rebase -iइस नौकरी के लिए उपयोग करना पसंद करता हूं , क्योंकि एक अच्छी सूची पॉप अप होती है जहां मैं छुटकारा पाने के लिए कमिट चुन सकता हूं। यह कुछ अन्य उत्तरों के रूप में प्रत्यक्ष नहीं हो सकता है, लेकिन यह सही लगता है ।

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

git rebase -i HEAD~3

नमूना सूची

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

फिर Git आपके द्वारा हटाए गए किसी भी लाइन के लिए कमिट निकाल देगा।

Answer 12

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

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

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

बस अपनी शाखा को पिछले स्थान पर रीसेट करें (उदाहरण के लिए, उपयोग gitkया git rebase)। फिर सहेजे गए प्रतिलिपि से अपने परिवर्तनों को पुन: लागू करें। आपके स्थानीय भंडार में कचरा संग्रहण के बाद, यह ऐसा होगा जैसे अवांछित प्रतिबद्ध कभी नहीं हुआ। एक कमांड में वह सब करने के लिए, का उपयोग करें 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)

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

Comments

gitk --all $(git reflog | cut -c1-7)&पिछले संशोधन को खोजने के लिए मददगार हो सकता है यदि आप '--मेंड' को पूर्ववत करना चाहते हैं।

— नोबार

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

— Jherico

मुझे लगता है कि 'निजी' / 'सार्वजनिक' अधिक सही रूप से 'स्थानीय' / 'रिमोट' होगा।

— नोबार

रिमोट रिपॉजिटरी में एक निजी शाखा को ठीक करके भी किया जा सकता हैgit push origin (branch_name) --force

— nobar

Answer 13

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

द्वारा देखी जा सकती है

git log 

तब आप कर सकते हैं -

git reset --hard <commit_id>

git push origin <branch_name> -f

Comments

क्या होगा यदि आप "<प्रतिबद्ध_id>" का उपयोग नहीं करते हैं और बस "गिट रीसेट - भार" का उपयोग करते हैं? मैं आमतौर पर केवल अपने नवीनतम अपडेट से छुटकारा पाना चाहता हूं जो मैंने अभी तक नहीं किए हैं और मैं अपने द्वारा किए गए नवीनतम कमिट पर वापस आ गया हूं, और मैं हमेशा "git रीसेट-hard" का उपयोग करता हूं।

— जैम मोंटोया

@JaimeMontoya आपके द्वारा नवीनतम परिवर्तनों को पूर्ववत करने के लिए git reset --hard, लेकिन अगर आपको अंतिम "n" निकालना है तो आप SHA

— गरीब

Answer 14

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

git reset --soft HEAD~1

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

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

या

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

git revert HEAD

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

Comments

मैं 2 के मामले में हूं, लेकिन जब मैं "git रिवर्ट HEAD" करता हूं तो यह कहता है कि "एरर: कमिट [आईडी] एक मर्ज है लेकिन कोई -m विकल्प नहीं दिया गया था। घातक: रिवर्ट फेल"। कोई सुझाव?

— मेटाफ़ॉर्ग

संभवत: यह ध्यान देने योग्य है कि जब आप एक से अधिक प्रतिबद्ध 'पूर्ववत्' करने की आवश्यकता के HEAD~1अनुसार वास्तविक हैश का उपयोग कर सकते हैं git log --statया इसके द्वारा प्रदर्शित किया जा सकता है git reflog।

— ccpizza

Answer 15

पर 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.

Answer 16

एक एकल आदेश:

git reset --soft 'HEAD^' 

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

Comments

मुझे डबल उद्धरण के साथ git रीसेट --soft "HEAD ^" लिखने की आवश्यकता थी, क्योंकि मैं इसे विंडोज कमांड प्रॉम्प्ट से लिखता हूं।

— एना

Answer 17

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

git reset --soft HEAD~1

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

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

Answer 18

पिछले Git को पूर्ववत कैसे करें?

पिछली प्रतिबद्धता से पहले सब कुछ वापस करने के लिए, हमें HEAD से पहले कमिट में रीसेट करना होगा।

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

   git reset --hard HEAD^
   

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

   git reset --soft HEAD^
   

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

Answer 19

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

git reset --hard HEAD^ 

"कार्यशील पेड़ से अज्ञात फ़ाइलों को साफ करें"

git clean    

देखें - Git Quick Reference

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

Answer 20

एक सही स्थिति का पता लगाने के लिए reflog का उपयोग करें

git reflog

फिर से पढ़ें परिणाम प्राप्त करें

सही रीफ़्लॉग (मेरे मामले में f3cb6e2) का चयन करें और टाइप करें

git reset --hard f3cb6e2

उसके बाद रेपो HEAD उस HEADID AF AFTER RESET पर रीसेट हो जाएगा

अंत में नीचे दी गई तस्वीर की तरह रिफ्लग दिखता है

REFLOG फाइनल

Answer 21

प्रथम रन:

git reflog

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

फिर करो:

git reset --hard ActionIdFromRefLog

Answer 22

अंतिम वचन पूर्ववत करें:

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

यह आखिरी प्रतिबद्ध होगा।

यहाँ --softमंचन में रीसेट का मतलब है।

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

---

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

git commit --amend -m "message"

यह नई कमेटी के साथ आखिरी कमिटमेंट को बदल देगा।

Answer 23

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

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

फिर अपनी रिपॉजिटरी की स्थानीय निर्देशिका पर जाएँ और इस कमांड को चलाएँ:

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

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

Answer 24

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

git reset <the previous co>

Answer 25

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

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 से सत्यापित करें

Answer 26

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

git reset --soft HEAD~ 

Answer 27

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

अंतिम कमिट / पिछले कमिट्स को पूर्ववत करने के लिए Git कमांड:

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

Git में कमिट वापस करने का मूल आदेश है:

$ 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 id हैं।

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

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

$ git reset --hard d81d3f1

या

$ git reset --hard HEAD~1

मान लीजिए कि आप 'be20eb8' कमिट करना चाहते हैं:

$ git reset --hard be20eb8

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

$ git reset --help

Comments

git reset --hard HEAD~1है बहुत खतरनाक ! यह न केवल 'अंतिम प्रतिबद्ध को रद्द' करेगा, बल्कि रेपो को पूरी तरह से पिछली प्रतिबद्धताओं में वापस लौटा देगा। तो आप अंतिम प्रतिबद्ध में किए गए सभी परिवर्तनों को खो देंगे!

— अर्निस जुरगा

सही है, इसे पूर्ववत करने के लिए आप उपयोग कर सकते हैंgit push -f <remote> HEAD@{1}:<branch>

— बेनी

दुर्भाग्य से, मैं उपयोग करता हूं - भार, और मेरी फ़ाइलें हटा दी गई हैं! मैंने पहले टिप्पणी की जांच नहीं की क्योंकि यह ढह गई है। यदि आप नहीं जानते कि आप क्या कर रहे हैं - तो प्रयोग न करें!

— अनाम

Answer 28

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

git reset --soft HEAD~1

या यदि आपको ठीक से याद नहीं है कि यह किसमें है, तो आप उपयोग कर सकते हैं

git rm --cached <file>

एक धक्का दिया के लिए

रिपॉजिटरी इतिहास से फ़ाइलों को हटाने का उचित तरीका उपयोग कर रहा है git filter-branch। अर्थात्,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

लेकिन मुझे लगता है कि आप इस कमांड का उपयोग सावधानी से करेंगे। गिट-फिल्टर-शाखा (1) मैनुअल पेज पर अधिक पढ़ें ।

Answer 29

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

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

यदि समस्या अतिरिक्त फाइलें थीं जो आपने शुरू की थीं (और आप रिपॉजिटरी पर नहीं चाहते हैं), तो आप उनका उपयोग करके हटा सकते हैं git rmऔर फिर साथ आ सकते हैं--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 भंडार से भी लिया जाएगा।

आपने पहले ही कमिट को धक्का दे दिया

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

इसके बजाय, आपको इसके बिना --amendकमिटमेंट करना होगा (इस बारे में याद रखें -amend`: वह विकल्प आखिरी कमिट पर इतिहास को फिर से लिखता है)।

Answer 30

पिछले संशोधन में रीसेट करने के लिए, स्थायी रूप से सभी अपरिष्कृत परिवर्तनों को हटाना:

git reset --hard HEAD~1

Comments

हो सकता है कि आप एक नोट / चेतावनी पर कह सकते हैं कि उनकी आज्ञा बिना किसी से पूछे बिना प्रतिबद्ध और कार्य निर्देशिका में परिवर्तन को फेंक देगी ।

— cr7pt0gr4ph7

यदि आप दुर्घटना से ऐसा करते हैं, तो सभी को खोना नहीं है, हालांकि। Stackoverflow.com/questions/10099258/… , stackoverflow.com/questions/15479501/… और stackoverflow.com/questions/7374069/undo-git-reset-hard/7376959 देखें ।

— cr7pt0gr4ph7

उपयोग --softके रूप में अपने परिवर्तनों को बनाए रखने के लिए uncommitted changes, --hardपरमाणु पूरी तरह से और एक करके अपनी भूल सुधार वापस करते हैं। केवल परिवर्तनों पर ऐसे ऑपरेशन करना याद रखें, जिन्हें अभी तक धक्का नहीं दिया गया है।

— यूनुस नेदिम मेहेल

@ ज़ाज़: आप सही कह रहे हैं; शायद मुझे यह स्पष्ट करना चाहिए था। केवल फ़ाइलें / परिवर्तन जो या तो सूचकांक (/ मंचन) में जोड़े गए हैं या प्रतिबद्ध हैं, संभवतः पुनर्प्राप्त किए जा सकते हैं। जैसा कि आपने कहा , अनकही, अस्थिर परिवर्तन हैं , पूरी तरह से दूर फेंक दिया git reset --hard।

— cr7pt0gr4ph7

एक सिडेनोट के रूप में: हर बार एक फ़ाइल का मंचन किया जाता है, gitअपने ऑब्जेक्ट को अपने ऑब्जेक्ट डेटाबेस में संग्रहीत करता है। संग्रहित सामग्री को तभी हटाया जाता है जब कचरा संग्रहण निष्पादित होता है। इसलिए एक फ़ाइल के अंतिम चरणबद्ध संस्करण को पुनर्प्राप्त करना संभव है जिसे वर्तमान git reset --hardमें निष्पादित नहीं किया गया था (अधिक जानकारी के लिए ऊपर दिए गए पोस्ट देखें)।

— cr7pt0gr4ph7