git - मौजूदा, अप्रचलित कामों को कैसे संशोधित करें?




git-commit git-rewrite-history amend (23)

मैंने एक प्रतिबद्ध संदेश में गलत बात लिखा है। वैकल्पिक रूप से, मैं कुछ फाइलों को शामिल करना भूल गया हूं।

मैं प्रतिबद्ध संदेश / फ़ाइलों को कैसे बदल सकता हूं? प्रतिबद्धता अभी तक धक्का नहीं दी गई है।


Answers

सबसे हालिया प्रतिबद्ध संदेश में संशोधन

git commit --amend

आपके संपादक को खोल देगा, जिससे आप सबसे हालिया प्रतिबद्धता के प्रतिबद्ध संदेश को बदल सकेंगे। इसके अतिरिक्त, आप प्रतिबद्ध संदेश सीधे कमांड लाइन में सेट कर सकते हैं:

git commit --amend -m "New commit message"

... हालांकि, यह बहु-लाइन प्रतिबद्ध संदेश या छोटे सुधारों को दर्ज करने के लिए अधिक बोझिल बना सकता है।

सुनिश्चित करें कि आपके पास ऐसा करने से पहले कोई भी कार्यशील प्रतिलिपि नहीं है या वे भी प्रतिबद्ध होंगे। ( अस्थिर परिवर्तन नहीं किए जाएंगे।)

उस प्रतिबद्धता के संदेश को बदलना जिसे आपने पहले ही अपनी दूरस्थ शाखा में धक्का दिया है

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

git push <remote> <branch> --force
# Or
git push <remote> <branch> -f

चेतावनी: बल-धक्का आपके स्थानीय एक की स्थिति के साथ रिमोट शाखा को ओवरराइट करेगा । यदि रिमोट ब्रांच पर ऐसा लगता है जो आपके पास आपकी स्थानीय शाखा में नहीं है, तो आप उन लोगों को खो देंगे।

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

इंटरैक्टिव रीबेस का प्रयोग करें

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

गिट स्क्वैश करने के लिए, इन चरणों का पालन करें:

// X is the number of commits to the last commit you want to be able to edit
git rebase -i HEAD~X

एक बार जब आप अपनी प्रतिबद्धताओं को स्क्वैश करते हैं - संदेश संपादित करने के लिए e/r चुनें

इंटरेक्टिव रीबेस के बारे में महत्वपूर्ण नोट

जब आप git rebase -i HEAD~X उपयोग करते हैं तो X से अधिक हो सकता है। गिट पिछले X प्रतिबद्धताओं में सभी कामों को "एकत्रित" करेगा और यदि उस सीमा के बीच कहीं विलय हुआ तो आप सभी कामों को भी देखेंगे, इसलिए परिणाम एक्स + होगा।

अच्छा सुझाव:

यदि आपको इसे एक से अधिक शाखाओं के लिए करना है और सामग्री में संशोधन करते समय आपको संघर्ष का सामना करना पड़ सकता है, तो git rerere सेट करें और गिट को स्वचालित रूप से आपके लिए उन संघर्षों को हल करने दें।

🔥 हॉट-टिप

आप अंतिम गिट प्रतिबद्ध संदेश में संशोधन करने और इसे दूरस्थ पर धक्का देने के लिए एक छोटा बैश फ़ंक्शन भी लिख सकते हैं। मुझे हर समय मदद करता है। समारोह यहाँ है; इसे अपने .bashrc या इसी तरह की .zshrc फ़ाइल में रखें और अपना खोल पुनः लोड करें।

# Amend the last commit message
# Push the changes to remote by force
# USAGE: gamend "Your New Commit Msg"
function gamend() {
    git commit --amend -m "[email protected]"
    git push --force
}

प्रलेखन


आप अपने रिमोट शाखा (करने के लिए कोड धक्का दिया नहीं किया है GitHub / Bitbucket ) आप नीचे के रूप में कमांड लाइन पर संदेश के लिए प्रतिबद्ध बदल सकते हैं।

 git commit --amend -m "Your new message"

यदि आप एक विशिष्ट शाखा पर काम कर रहे हैं तो यह करें:

git commit --amend -m "BRANCH-NAME: new message"

यदि आपने पहले ही गलत संदेश के साथ कोड को धक्का दिया है, और संदेश बदलने के दौरान आपको सावधान रहना होगा। यही है, जब आप प्रतिबद्ध संदेश बदलते हैं और इसे फिर से दबाकर देखते हैं, तो आप समस्याएं समाप्त करते हैं। इसे चिकनी बनाने के लिए, इन चरणों का पालन करें।

इसे करने से पहले कृपया मेरा पूरा जवाब पढ़ें।

git commit --amend -m "BRANCH-NAME : your new message"

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?

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

 git commit --amend -m "BRANCH-NAME : your new message"
 git pull origin BRANCH-NAME
 git push -f origin BRANCH-NAME

प्रतिबद्ध संदेश बदलते समय यह सबसे अच्छा अभ्यास है, अगर इसे पहले से ही धक्का दिया गया था।


मुझे एहसास हुआ कि मैंने इसमें एक टाइपो के साथ प्रतिबद्धता को धक्का दिया था। पूर्ववत करने के लिए, मैंने निम्न कार्य किया:

git commit --amend -m "T-1000, advanced prototype"
git push --force

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


मैं इस तरह से पसंद करता हूँ।

git commit --amend -c <commit ID>

अन्यथा, एक नई प्रतिबद्ध आईडी के साथ एक नई प्रतिबद्धता होगी


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

git commit --amend -o -m "New commit message"

(यह सुनिश्चित करने के लिए कि आप केवल प्रतिबद्ध संदेश बदलते हैं -o ( --only ) ध्वज का उपयोग कर)


यदि यह एक दफन प्रतिबद्ध है, तो भयानक इंटरैक्टिव रीबेस का उपयोग करें:

git rebase -i @~9   # Show the last 9 commits in a text editor

अपनी इच्छित प्रतिबद्धता पाएं, r ( reword ) में pick बदलें, और फ़ाइल को सेव और बंद करें। किया हुआ!


लघु vim ट्यूटोरियल (या, केवल 8 कीस्ट्रोक 3j cw r Esc ZZ साथ रीबेस कैसे करें):

  • यदि आपके पास समय है तो vimtutor चलाएं
  • h j k l आंदोलन कुंजी के अनुरूप है
  • सभी आदेशों को "रेंज" के साथ उपसर्ग किया जा सकता है, उदाहरण के लिए 3j नीचे 3 लाइनों को 3j है
  • i सम्मिलित मोड दर्ज करने के लिए - आपके द्वारा टाइप किया गया पाठ फ़ाइल में दिखाई देगा
  • डालने मोड से बाहर निकलने के लिए Esc या Ctrl c और "सामान्य" मोड पर वापस आएं
  • u पूर्ववत करने के लिए
  • फिर से करने के लिए Ctrl r
  • dd , dw , dl क्रमशः एक पंक्ति, शब्द, या अक्षर को हटाने के लिए
  • cc , cw , cl क्रमशः एक रेखा, शब्द, या पत्र बदलने के लिए ( dd रूप में ही i )
  • yy , yw , yl क्रमशः एक पंक्ति, शब्द, या अक्षर की प्रतिलिपि बनाने के लिए (" yw ")
  • p या P क्रमशः, या वर्तमान स्थिति से पहले पेस्ट करने के लिए
  • :w फ़ाइल को सहेजने के लिए दर्ज करें (लिखें)
  • :q! सहेजे बिना छोड़ने के लिए दर्ज करें
  • :wq सहेजें और छोड़ने के लिए :wq दर्ज करें या ZZ

यदि आप टेक्स्ट को बहुत संपादित करते हैं, तो ड्वोरोक कीबोर्ड लेआउट पर स्विच करें, स्पर्श-टाइप करना सीखें, और vim सीखें। क्या यह प्रयास के लायक है? हाँ।


ProTip ™: इतिहास को फिर से लिखने वाले "खतरनाक" आदेशों के साथ प्रयोग करने से डरो मत * - गिट डिफ़ॉल्ट रूप से 90 दिनों के लिए आपकी प्रतिबद्धता को हटा नहीं देता है; आप उन्हें रीफ्लॉग में पा सकते हैं:

$ git reset @~3   # go back 3 commits
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~3
2c52489 [email protected]{1}: commit: more changes
4a5246d [email protected]{2}: commit: make important changes
e8571e4 [email protected]{3}: commit: make some changes
... earlier commits ...
$ git reset 2c52489
... and you're back where you started

* विकल्पों के लिए देखें - --force और - --force हालांकि - वे डेटा को त्याग सकते हैं।
* साथ ही, किसी भी शाखा पर इतिहास को फिर से लिखना न करें जिस पर आप सहयोग कर रहे हैं।


git commit --amend -m "your new message"

इस प्रश्न पर बहुत सारे उत्तर हैं लेकिन उनमें से कोई भी सुपर विवरण में बताता है कि वीआईएम का उपयोग करके पुराने प्रतिबद्ध संदेशों को कैसे बदला जाए। मैं इसे खुद करने की कोशिश कर रहा था, इसलिए यहां मैं विस्तार से लिखूंगा कि मैंने यह विशेष रूप से उन लोगों के लिए कैसे किया जिनके पास वीआईएम में कोई अनुभव नहीं है!

मैं अपने पांच नवीनतम कामों को बदलना चाहता था जिन्हें मैंने पहले ही सर्वर पर धक्का दिया था। यह काफी 'खतरनाक' कारण है यदि किसी और ने पहले से ही इसे खींच लिया है तो आप प्रतिबद्ध संदेशों को बदलकर गड़बड़ कर सकते हैं। हालांकि जब आप अपनी छोटी शाखा पर काम कर रहे हैं और सुनिश्चित हैं कि कोई भी इसे खींच नहीं लेता है तो आप इसे इस तरह बदल सकते हैं:

मान लें कि आप अपने पांच नवीनतम कामों को बदलना चाहते हैं, फिर आप इसे टर्मिनल में टाइप करें:

git rebase -i HEAD~5 * जहां 5 उन प्रतिबद्ध संदेशों की संख्या है जिन्हें आप बदलना चाहते हैं। (इसलिए यदि आप 10 वीं को अंतिम प्रतिबद्धता में बदलना चाहते हैं तो आप 10 में टाइप करें)

यह आदेश आपको वीआईएम में ले जाएगा जहां आप अपने प्रतिबद्ध इतिहास को 'संपादित' कर सकते हैं। आप इस तरह के शीर्ष पर अपने आखिरी 5 काम देखेंगे:

pick <commit hash> commit message

pick बजाय आपको reword लिखना होगा। आप इसे टाइप करके वीआईएम में कर सकते हैं, जिससे आप INSERT-मोड में जा सकते हैं। (आप देखते हैं कि आप नीचे INSERT शब्द द्वारा सम्मिलित मोड में हैं) काम करने के बजाय आप pick बजाय reword में प्रकार बदलना चाहते हैं

फिर आपको इस स्क्रीन को सहेजने और छोड़ने की ज़रूरत है, आप इसे एएससी बटन दबाकर पहले 'कमांड-मोड' में जाकर करते हैं। (आप जांच सकते हैं कि आप कमांड मोड में हैं यदि नीचे INSERT शब्द गायब हो गया है) तो आप टाइप करके एक कमांड टाइप कर सकते हैं : सहेजने और छोड़ने का आदेश wq । तो यदि आप टाइप करते हैं :wq आप सही रास्ते पर हैं।

फिर वीआईएम प्रत्येक प्रतिबद्ध संदेश पर जायेगा जिसे आप दोबारा लिखना चाहते हैं, यहां आप वास्तव में प्रतिबद्ध संदेश बदल सकते हैं। आप इसे INSERT-मोड में जाकर, प्रतिबद्ध संदेश बदलकर, कमांड मोड में जाकर सहेजकर छोड़ देंगे। यह 5 बार करो और आप वीआईएम से बाहर हैं!

फिर, यदि आपने पहले से ही अपनी गलत प्रतिबद्धताओं को धक्का दिया है, तो आपको उन्हें ओवरराइट करने के लिए git push --force को git push --force करने की आवश्यकता है। याद रखें कि git push --force करना एक खतरनाक चीज है, इसलिए सुनिश्चित करें कि सर्वर से कोई भी खींचा नहीं गया है क्योंकि आपने अपनी गलत प्रतिबद्धताओं को धक्का दिया है!

अब आपने अपने प्रतिबद्ध संदेश बदल दिए हैं!

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


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

Commit/Amend Last Commit

संशोधन

आपके पास यहां कुछ विकल्प हैं। तुम कर सकते हो

git commit --amend

जब तक यह आपकी आखिरी प्रतिबद्धता है।

इंटरेक्टिव रीबेस

अन्यथा यदि यह आपकी आखिरी प्रतिबद्धता नहीं है तो आप एक इंटरैक्टिव रिबेस कर सकते हैं,

git rebase -i [branched_from] [hash before commit]

फिर इंटरैक्टिव रीबेस के अंदर आप बस उस प्रतिबद्धता में संपादन जोड़ते हैं। जब यह आता है तो एक git commit --amend करें - प्रतिबद्ध संदेश को संशोधित करें और संशोधित करें। यदि आप उस प्रतिबद्ध बिंदु से पहले वापस रोल करना चाहते हैं तो आप git reflog का भी उपयोग कर सकते हैं और केवल उस प्रतिबद्धता को हटा सकते हैं। फिर आप फिर से एक git commit करते हैं।


मुझे निम्नलिखित का उपयोग करना पसंद है:

  1. git status
  2. git add --all
  3. git commit -am "message goes here about the change"
  4. git pull <origin master>
  5. git push <origin master>

यदि आपको कई शाखाओं पर एक पुराना प्रतिबद्ध संदेश बदलना है (यानी, गलत शाखाओं के साथ प्रतिबद्धता कई शाखाओं में मौजूद है) तो आप इसका उपयोग करना चाहेंगे:

git filter-branch -f --msg-filter \
'sed "s/<old message>/<new message>/g"' -- --all

गिट रीफ्रेटिंग के लिए अस्थायी निर्देशिका बनाएगा और अतिरिक्त refs/original/ में पुराने संदर्भों का बैकअप देगा।

  • -f ऑपरेशन के निष्पादन को लागू करेगा। यह आवश्यक है यदि अस्थायी निर्देशिका पहले से मौजूद है या यदि पहले से ही refs/original तहत संग्रहीत संदर्भ हैं। यदि ऐसा नहीं है, तो आप इस ध्वज को छोड़ सकते हैं।

  • -- संशोधन विकल्पों से फिल्टर-शाखा विकल्पों को अलग करता है।

  • --all सभी सुनिश्चित करेंगे कि सभी शाखाएं और टैग फिर से लिखे गए हैं।

अपने पुराने संदर्भों के बैकअप के कारण, आप आदेश को निष्पादित करने से पहले आसानी से राज्य में वापस जा सकते हैं।

कहें, आप अपने मास्टर को पुनर्प्राप्त करना चाहते हैं और शाखा old_master में इसे एक्सेस करना चाहते हैं:

git checkout -b old_master refs/original/refs/heads/master

एक पंक्ति में नए प्रतिबद्ध संदेश के साथ अपना अंतिम गलत प्रतिबद्ध संदेश अपडेट करें:

git commit --amend -m "your new commit message"

या, नीचे की तरह गिट रीसेट करने का प्रयास करें:

# You can reset your head to n number of commit
# NOT a good idea for changing last commit message
# but you can get an idea to split commit into multiple commits
git reset --soft HEAD^

# it will reset you last commit. Now, you
# can re-commit it with new commit message.

विभाजित करने के लिए रीसेट का उपयोग छोटे कामों में करता है

git reset आपको कई प्रतिबद्धताओं में एक प्रतिबद्धता को तोड़ने में भी मदद कर सकता है:

# reset your head. I am resetting to last commits:
git reset --soft HEAD^
# (you can reset multiple commit by doing HEAD~2(no. of commits)

# Now, reset your head for splitting it to multiple commits
git reset HEAD

# add and commit your files seperately to make multiple commits: e.g
git add app/
git commit -m "add all files in app directory"

git add config/
git commit -m "add all files in config directory"

यहां आपने दो प्रतिबद्धताओं में अपनी आखिरी प्रतिबद्धता सफलतापूर्वक तोड़ दी है।


यदि आप नवीनतम प्रतिबद्ध उपयोग को संपादित करना चाहते हैं:

git commit --amend

या

git commit --amend -m 'one line message'

लेकिन यदि आप पंक्ति में कई कामों को संपादित करना चाहते हैं तो आपको इसके बजाय रीबेजिंग का उपयोग करना चाहिए:

git rebase -i <hash of one commit before the wrong commit>

ऊपर की तरह एक फ़ाइल में संपादन / ई या अन्य विकल्प में से एक लिखें और सहेजें और बाहर निकलें।

अब आप पहली गलत प्रतिबद्धता पर होंगे। फ़ाइलों में परिवर्तन करें, और वे आपके लिए स्वचालित रूप से चरणबद्ध हो जाएंगे। प्रकार

git commit --amend

बचाओ और बाहर निकलें और टाइप करें

git rebase --continue 

अपने सभी चयनों के साथ समाप्त होने तक अगले चयन में जाने के लिए।

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


यदि आप केवल अपना अंतिम संदेश बदलना चाहते हैं तो आपको - केवल ध्वज या इसके शॉर्टकट का उपयोग करना चाहिए -o commit --amend साथ -o

git commit --amend -o -m "New commit message"

यह सुनिश्चित करता है कि आप चरणबद्ध सामग्री के साथ गलती से अपनी प्रतिबद्धता को बढ़ाएं। बेशक यह उचित $EDITOR कॉन्फ़िगरेशन होना सर्वोत्तम है। फिर आप -m विकल्प को छोड़ सकते हैं, और गिट पुराने संदेश के साथ प्रतिबद्ध संदेश को पूर्व-भर देगा। इस तरह इसे आसानी से संपादित किया जा सकता है।


  1. यदि आप केवल अपने अंतिम प्रतिबद्ध संदेश को संशोधित करना चाहते हैं, तो करें:

    git commit --amend
    

    यह आपको आपके टेक्स्ट एक्सिटर में छोड़ देगा और आपको अंतिम प्रतिबद्ध संदेश बदलने देगा।

  2. यदि आप अंतिम 3 प्रतिबद्ध संदेशों को बदलना चाहते हैं, या उस बिंदु तक के किसी भी प्रतिबद्ध संदेश को बदलना चाहते हैं, तो git rebase -i आदेश में HEAD~3 आपूर्ति करें:

    git rebase -i HEAD~3
    

आप गिट रिबेजिंग का उपयोग कर सकते हैं। उदाहरण के लिए, यदि आप bbc643cd को प्रतिबद्ध करने के लिए वापस संशोधित करना चाहते हैं, तो चलाएं

$ git rebase bbc643cd^ --interactive

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

$ git add <filepattern>

अब आप इसका उपयोग कर सकते हैं

$ git commit --amend

प्रतिबद्धता को संशोधित करने के लिए, और उसके बाद

$ git rebase --continue

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


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

इसके अलावा, git rebase -i origin/master एक अच्छा मंत्र है जो हमेशा आपको मास्टर के शीर्ष पर किए गए कामों के साथ पेश करेगा, और आपको संशोधन, हटाने, पुन: क्रमबद्ध करने या स्क्वैश करने का विकल्प देगा। पहले हैश को पकड़ने की जरूरत नहीं है।


पिछली प्रतिबद्धता में संशोधन करने के लिए, इच्छित परिवर्तन करें और उन परिवर्तनों को चरणबद्ध करें, और फिर चलाएं

git commit --amend

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

पिछली प्रतिबद्धता में संशोधन करने और एक ही लॉग संदेश रखने के लिए, चलाएं

git commit --amend -C HEAD

इसे पूरी तरह से हटाकर पिछली प्रतिबद्धता को ठीक करने के लिए, चलाएं

git reset --hard HEAD^

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

git rebase -i HEAD~commit_count

(प्रतिबद्धताओं की संख्या के साथ commit_count बदलें जिसे आप संपादित करना चाहते हैं।) यह आदेश आपके संपादक को लॉन्च करता है। "पिक" के बजाय "एडिट" के रूप में पहली प्रतिबद्धता (जिसे आप बदलना चाहते हैं) को चिह्नित करें, फिर अपने संपादक को सहेजें और बाहर निकलें। वह परिवर्तन करें जिसे आप प्रतिबद्ध करना चाहते हैं और फिर चलाएं

git commit --amend
git rebase --continue

नोट: आप git commit --amend द्वारा खोले गए संपादक से "इच्छित परिवर्तन करें" भी कर सकते हैं


वाह, तो ऐसा करने के कई तरीके हैं।

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

git reset --soft HEAD~1
git commit -m 'New and corrected commit message'

अगर मैं फाइल जोड़ना या बदलाव करना भूल जाता हूं तो मैं हमेशा ऐसा करता हूं।

--soft बजाय --soft को निर्दिष्ट करना याद रखें , अन्यथा आप पूरी तरह से प्रतिबद्धता खो देते हैं।


आप इसके लिए गिट filter-branch का भी उपयोग कर सकते हैं।

git filter-branch -f --msg-filter "sed 's/errror/error/'" $flawed_commit..HEAD

यह एक छोटी सी git commit --amend रूप में आसान नहीं है - लेकिन यह विशेष रूप से उपयोगी है, अगर आपके पास पहले से ही आपके ग़लत संदेश के बाद कुछ विलय हो।

ध्यान दें कि यह HEAD और त्रुटिपूर्ण प्रतिबद्धता के बीच हर प्रतिबद्धता को फिर से लिखने का प्रयास करेगा, इसलिए आपको अपना msg-filter कमांड बहुत बुद्धिमान चुनना चाहिए ;-)


उपयोग

git commit --amend

इसे विस्तार से समझने के लिए, एक उत्कृष्ट पोस्ट है 4. गिट इतिहास को पुनर्लेखन । यह git commit --amend का उपयोग न करने के बारे में भी बात करता है।


आप git-rebase-reword उपयोग कर सकते हैंgit-rebase-reword

यह किसी भी प्रतिबद्धता (केवल अंतिम नहीं) को संपादित करने के लिए डिज़ाइन किया गया है commit --amend

$ git rebase-reword <commit-or-refname>

इसका नाम एक प्रतिबद्धता में संशोधन करने के लिए इंटरैक्टिव रिबेज पर कार्रवाई के बाद किया गया है: "शब्द"। इस पोस्ट और man सेक्शन इंटरैक्टिव मोड देखें-

उदाहरण:

$ git rebase-reword b68f560
$ git rebase-reword HEAD^

गिट को पूर्ववत करने के लिए उपयोग करें

git reset filename





git git-commit git-rewrite-history amend