git - मैं गिट में हालिया कामों को पूर्ववत कैसे करूं?




git-commit git-reset (20)

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

इंडेक्स में फ़ाइलों को बदलें:

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

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

git commit --amend

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

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


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

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

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

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

आप गिट को किसी भी प्रतिबद्धता के साथ रीसेट कर सकते हैं:

git reset @~N

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

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

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

यह क्या करता है इसकी बेहतर समझ के लिए, git help reset , विशेष रूप से --soft --mixed और --hard पर --soft --mixed

Reflog

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

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


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

स्थानीय भंडार से उन लोगों को कैसे पूर्ववत किया जा सकता है?


अंतिम प्रतिबद्धता पूर्ववत करें:

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

यह अंतिम प्रतिबद्धता पूर्ववत करेगा।

यहां - --soft मतलब है स्टेजिंग में रीसेट करें।

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

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

git commit --amend -m "message"

यह नई प्रतिबद्धता के साथ अंतिम प्रतिबद्धता को प्रतिस्थापित करेगा।


एक प्रतिबद्धता पूर्ववत करें और फिर से करें

$ 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~ तरह है git reset HEAD~ जहां HEAD~ HEAD~1 जैसा ही है ) लेकिन आपके मौजूदा परिवर्तन चरणबद्ध छोड़ देता है।
  3. पेड़ की फाइलों में काम करने के लिए सुधार करें।
  4. git add कुछ भी git add जो आप अपनी नई प्रतिबद्धता में शामिल करना चाहते हैं।
  5. पुराने प्रतिबद्ध संदेश का पुन: उपयोग करते हुए परिवर्तनों को प्रतिबद्ध करें। reset पुराने सिर को .git/ORIG_HEAD कॉपी किया गया; -c ORIG_HEAD साथ commit एक संपादक खुल जाएगा, जिसमें प्रारंभ में पुराने प्रतिबद्धता से लॉग संदेश होता है और आपको इसे संपादित करने की अनुमति देता है। अगर आपको संदेश को संपादित करने की आवश्यकता नहीं है, तो आप -C विकल्प का उपयोग कर सकते हैं।

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

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

git push origin master --force

आप यह जवाब भी देख सकते हैं:

हेड वापस पिछले स्थान पर कैसे स्थानांतरित करें? (अलग सिर)

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

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


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

git reset --hard HEAD^ 

"काम करने वाले पेड़ से अज्ञात फाइलें साफ़ करें"

git clean    

देखें - गिट त्वरित संदर्भ

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


एक ही आदेश:

git reset --soft 'HEAD^' 

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


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

पिछली प्रतिबद्धता / पिछली प्रतिबद्धताओं को पूर्ववत करने के लिए गिट कमांड:

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

गिट में प्रतिबद्धता को वापस करने के लिए मूल आदेश है:

$ 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 आईडी प्रतिबद्ध हैं।

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

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

$ git reset --hard d81d3f1

या

$ git reset --hard HEAD~1

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

$ git reset --hard be20eb8

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

$ git reset --help

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

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

फिर अपनी रिपोजिटरी की स्थानीय निर्देशिका पर नेविगेट करें और यह आदेश चलाएं:

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

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


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

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

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

आपने पहले ही प्रतिबद्धता को धक्का दिया है

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

इसके बजाए, आपको बिना काम के प्रतिबद्धता करना है (इसे याद रखें- यह विकल्प अंतिम प्रतिबद्धता पर इतिहास को फिर से लिखता है)।


मुझे पता लगाने में थोड़ी देर लग गई, तो शायद यह किसी की मदद करेगा ...

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

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

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

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

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

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 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 के साथ परिणामों की पुष्टि करें


मैं इस नौकरी के लिए 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 reset --hard HEAD~1

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

git reset --soft HEAD~1

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

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

   (F)
A-B-C
    ↑
  master

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

git reset --hard HEAD~1

परिणाम है:

 (F)
A-B
  ↑
master

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

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

   (F)
A-B-C
    ↑
  master

आप यह कर सकते हैं, --hard छोड़कर:

git reset HEAD~1

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

   (F)
A-B-C
  ↑
master

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

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

git reset --soft HEAD~1

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

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

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

git checkout -b someNewBranchName shaYouDestroyed

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


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

git reset --hard HEAD^1

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

git reset --soft HEAD^1

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

git reset HEAD

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

More


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

git reset --soft HEAD~1

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

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

या

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

git revert HEAD

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


सही स्थिति खोजने के लिए रीफ्लॉग का प्रयोग करें

git reflog

रीसेट से पहले रिफ्लॉग करें

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

git reset --hard f3cb6e2

उसके बाद रेपो हेड को हेडिड पर रीसेट कर दिया जाएगा रीसेट के बाद लॉग इन करें

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

अंतिम फाइनल


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

git reset <the previous co>

git revert commit-id प्रयोग करें

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


आखिरी गिट प्रतिबद्धता को पूर्ववत कैसे करें?

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

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

    git reset --hard HEAD^
    
  2. यदि आप अपने परिवर्तन रखना चाहते हैं:

    git reset --soft HEAD^
    

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


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

git reset --soft HEAD~ 




git-revert