विशिष्ट प्रतिबद्ध निकालें

Question

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

तो यहाँ सवाल का एक सरलीकृत संस्करण है:

निम्नलिखित परिदृश्य को देखते हुए, मैं कमिट 2 कैसे निकालूं?

$ mkdir git_revert_test && cd git_revert_test

$ git init
Initialized empty Git repository in /Users/josh/deleteme/git_revert_test/.git/

$ echo "line 1" > myfile

$ git add -A

$ git commit -m "commit 1"
[master (root-commit) 8230fa3] commit 1
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 myfile

$ echo "line 2" >> myfile

$ git commit -am "commit 2"
[master 342f9bb] commit 2
 1 files changed, 1 insertions(+), 0 deletions(-)

$ echo "line 3" >> myfile

$ git commit -am "commit 3"
[master 1bcb872] commit 3
 1 files changed, 1 insertions(+), 0 deletions(-)

अपेक्षित परिणाम है

$ cat myfile
line 1
line 3

यहाँ एक उदाहरण दिया गया है कि मैं कैसे वापस लौटने की कोशिश कर रहा हूं

$ git revert 342f9bb
Automatic revert failed.  After resolving the conflicts,
mark the corrected paths with 'git add <paths>' or 'git rm <paths>'
and commit the result.

Comments

अगर किसी को भी इसी समस्या को खोजते हुए पाया जाता है, तो यहां मैंने ऐसा किया है: कॉपी और पेस्ट। गंभीरता से। काम करने के लिए सुझाए गए समाधानों को प्राप्त करने के लिए 6+ घंटे खर्च किए, कोई फायदा नहीं हुआ। अंत में, मैं समय से बाहर हो गया, मूल को ऊपर खींच लिया, और लगभग 20 फ़ाइलों को कॉपी / पेस्ट किया। 5 मिनट के भीतर लिया गया, और चीजें तब से अब तक ठीक हैं (यहां तक ​​कि जब उन फाइलों को अन्य शाखाओं में परिवर्तन के साथ विलय कर दिया जा रहा है जो इस फियास्को से पहले हुई थीं)। मेरा सुझाव है कि आप इस दृष्टिकोण को भी लें। न केवल यह सबसे सरल है, मुझे यह भी संदेह है कि यह केवल एक चीज है जो काम करती है।

— जोशुआ गाल

मुझे इसी तरह के मुद्दे का सामना करना पड़ा, लेकिन शायद अधिक जटिल: के पास सैकड़ों शाखाएं थीं, जिन्हें मैं स्क्वैश करना चाहता था। दुर्भाग्य से किसी अन्य शाखा से आने वाले समय को एक मध्यवर्ती बिंदु पर शाखा में वापस मिला दिया गया था, इसलिए मुझे स्क्वैश करने से पहले एक "अनमरज" की आवश्यकता थी। मैं नीचे दिए गए tk द्वारा सुझाए गए एक समान रास्ते पर गया (चेरी पिकिंग + रेंज नोटेशन का उपयोग करके), लेकिन इसने कुछ अन्य फाइलों में संघर्ष का उत्पादन किया। अंत में कॉपी और पेस्ट + कुछ मैनुअल एडिट्स सबसे आसान और सबसे अनुमानित मार्ग था। निश्चित रूप से एक विचार के लायक अगर आप खुद को इस पर बहुत अधिक समय खर्च करते हैं।

— फेडरिको

Answer 1

अलग होने की गणना करते समय Git का उपयोग करने वाले एल्गोरिथ्म को इसकी आवश्यकता होती है

1. वापस की जा रही लाइनों को बाद में किए गए किसी भी संशोधन द्वारा संशोधित नहीं किया गया है।
2. इतिहास में बाद में कोई अन्य "आसन्न" नहीं है।

"सन्निकट" की परिभाषा किसी संदर्भ से भिन्न संख्या की डिफ़ॉल्ट संख्या पर आधारित है, जो 3. है। इसलिए यदि 'मायफाइल' का निर्माण इस तरह किया गया है:

$ cat >myfile <<EOF
line 1
junk
junk
junk
junk
line 2
junk
junk
junk
junk
line 3
EOF
$ git add myfile
$ git commit -m "initial check-in"
 1 files changed, 11 insertions(+), 0 deletions(-)
 create mode 100644 myfile

$ perl -p -i -e 's/line 2/this is the second line/;' myfile
$ git commit -am "changed line 2 to second line"
[master d6cbb19] changed line 2
 1 files changed, 1 insertions(+), 1 deletions(-)

$ perl -p -i -e 's/line 3/this is the third line/;' myfile
$ git commit -am "changed line 3 to third line"
[master dd054fe] changed line 3
 1 files changed, 1 insertions(+), 1 deletions(-)

$ git revert d6cbb19
Finished one revert.
[master 2db5c47] Revert "changed line 2"
 1 files changed, 1 insertions(+), 1 deletions(-)

फिर यह सब उम्मीद के मुताबिक काम करता है।

दूसरा जवाब बहुत दिलचस्प था। एक विशेषता है जिसे अभी तक आधिकारिक तौर पर जारी नहीं किया गया है (हालांकि यह Git v1.7.2-rc2 में उपलब्ध है) जिसे रिवर्ट स्ट्रेटेजी कहा जाता है। आप इस तरह git आह्वान कर सकते हैं:

git रिवर्ट - कम्प्रेशन हल <प्रतिबद्ध>

और यह एक बेहतर काम करना चाहिए जो आप का मतलब है। मुझे नहीं पता कि उपलब्ध रणनीतियों की सूची क्या है और न ही मुझे किसी रणनीति की परिभाषा पता है।

Comments

perl -pबहुत ही कम (एक पंक्ति) प्रोग्राम जो पाश और लेखन के लिए उपयोगी है पारित उत्पादन, SED के लिए इसी तरह के माध्यम से अपने इनपुट। जगह मेंperl -i फ़ाइलों को संपादित करने के लिए प्रयोग किया जाता है । मूल्यांकनperl -e करने के लिए कोड कैसे जमा करना है ।

— हैल ईसेन

Answer 2

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

• स्वच्छ रास्ता, पुन: प्रवेश लेकिन लॉग इन में रखें:

  git revert --strategy resolve <commit>
  

• हर्ष रास्ता, पूरी तरह से केवल अंतिम प्रतिबद्ध हटा दें:

  git reset --soft "HEAD^"
  

नोट: git reset --hardआखिरी कम होने के बाद से फाइलों में सभी बदलावों को भी छोड़ दें। यदि --softकाम नहीं करता है, तो प्रयास करें --mixedया --keep।

• रेबेस (अंतिम 5 का लॉग दिखाएं और उन पंक्तियों को हटा दें जिन्हें आप नहीं चाहते हैं, या फिर से चालू करें, या एक में एक से अधिक स्क्वैश करें, या जो आप चाहते हैं और कुछ करें, यह एक बहुत ही बहुमुखी उपकरण है):

  git rebase -i HEAD~5
  

और अगर एक गलती की है:

git rebase --abort

• त्वरित छूट: इसकी आईडी का उपयोग करके केवल एक विशिष्ट कमिट निकालें:

  git rebase --onto commit-id^ commit-id
  

• विकल्प: आप भी कोशिश कर सकते हैं:

  git cherry-pick commit-id
  

• फिर भी एक और विकल्प:

  git revert --no-commit
  

• अंतिम उपाय के रूप में, यदि आपको इतिहास संपादन की पूर्ण स्वतंत्रता की आवश्यकता है (उदाहरण के लिए, क्योंकि git आपको वह संपादन करने की अनुमति नहीं देता है जो आप चाहते हैं), तो आप इस बहुत तेज़ ओपन सोर्स एप्लिकेशन का उपयोग कर सकते हैं : रिपॉजर्जन ।

नोट: बेशक, ये सभी परिवर्तन स्थानीय स्तर पर किए जाते हैं, आपको git pushबाद में रिमोट में परिवर्तन लागू करना चाहिए । और यदि आपका रेपो कमिट को हटाना नहीं चाहता है ("कोई फास्ट-फॉरवर्ड की अनुमति नहीं है", जो तब होता है जब आप पहले से पुश की गई कमिट को हटाना चाहते हैं), तो आप git push -fपरिवर्तनों को पुश करने के लिए मजबूर कर सकते हैं ।

नोट 2: यदि किसी शाखा पर काम कर रहे हैं और आपको जोर लगाने की आवश्यकता है, तो आपको पूरी तरह से बचना चाहिए git push --forceक्योंकि यह अन्य शाखाओं को अधिलेखित कर सकता है (यदि आपने उनमें परिवर्तन किया है, भले ही आपका वर्तमान चेकआउट किसी अन्य शाखा में हो)। करने के लिए पसंद करते हैं जब आप धक्का मजबूर हमेशा दूरस्थ शाखा निर्दिष्ट : git push --force origin your_branch।

Comments

@ विस्तार के सुझावों के आधार पर: "git rebase -i HEAD ~ 2" करें। अब आपके पास कई विकल्प हैं। विम में आप कुछ टिप्पणी लाइनें देख सकते हैं: उनमें से एक आपको बताता है कि आप बस एक लाइन को हटा सकते हैं (जो आपको चाहिए कि आप छुटकारा पाना चाहते हैं) और यह प्रतिबद्ध आपके इतिहास में लॉग इन होने के साथ हटा दिया जाएगा।

— इलकेर कैट

git रिवर्ट - स्ट्रैटेसी रेज़ॉल्यूशन <कमिट> ।इस कमांड ने मेरे लिए काम किया। धन्यवाद :)

— स्वाथिन

git rebase -i HEAD~5मेरे लिए काम किया। तब मैंने केवल उस कमिट को हटा दिया था जिसकी मुझे आवश्यकता नहीं थी और मैं 30 सेकंड से भी कम समय में समस्या को हल करने में सक्षम था। धन्यवाद।

— lv10

Answer 3

यहाँ एक आसान उपाय है:

git rebase -i HEAD~x

(नोट: xकमिट की संख्या है)

नोटपैड फ़ाइल निष्पादित करने पर खुल जाएगा। dropअपनी प्रतिबद्धता के अलावा दर्ज करें ।
यदि आप विम को नहीं जानते हैं, तो बस उस प्रत्येक शब्द पर क्लिक करें, जिसे आप संपादित करना चाहते हैं और फिर "I" कुंजी (इन्सर्ट मोड के लिए) को हिट करें। एक बार जब आप टाइप कर लेते हैं तो इन्सर्ट मोड से बाहर निकलने के लिए "esc" कुंजी को हिट करें।

और यह बात है, आप कर रहे हैं ... बस git डैशबोर्ड को सिंक करें और परिवर्तनों को दूरस्थ में धकेल दिया जाएगा।

यदि आप जो कमिट करते हैं, वह पहले से ही रिमोट पर है, तो आपको पुश करने के लिए मजबूर होना पड़ेगा। चूंकि --फोर्स हानिकारक माना जाता है , उपयोग करें git push --force-with-lease।

Comments

क्या यह पता लगाने का एक अच्छा तरीका है कि 'x' क्या होना चाहिए अगर आपको केवल प्रश्न में कमिट का हैश पता हो?

— jlewkovich

Cpp-मानसिकता के लोगों के लिए: x (कमिट्स की संख्या) समावेशी है। जैसे HEAD ~ 4 में अंतिम 4 कमिट शामिल हैं।

— हर्पीज़ फ्री इंजीनियर

सही सुझाव। बस जोड़ना चाहते हैं, यह भी गिरा दिया से परिवर्तन को छोड़ दें।

— celerno

3 कमिट्स को वापस करने की कोशिश की: git rebase -i HEAD-3 को त्रुटि मिली: एक एकल संशोधन को अपस्ट्रीम 'HEAD-3' की आवश्यकता है

— Ustin

@ यूस्टिन यह ~ 3 नहीं -3

— JD-V

Answer 4

आपकी पसंद के बीच है

1. त्रुटि रखते हुए और एक फिक्स शुरू करने और
2. त्रुटि को दूर करने और इतिहास को बदलने।

आपको (1) चुनना चाहिए, यदि त्रुटिपूर्ण परिवर्तन किसी और ने लिया है और (2) यदि त्रुटि एक निजी अन-पुश शाखा तक सीमित है।

Git रिवर्ट करना (1) करने के लिए एक स्वचालित उपकरण है, यह पिछली कुछ प्रतिबद्ध को पूर्ववत करते हुए एक नई प्रतिबद्ध बनाता है। आपको प्रोजेक्ट इतिहास में त्रुटि और निष्कासन दिखाई देगा, लेकिन आपके रिपॉजिटरी से खींचने वाले लोग अपडेट होने पर समस्याओं में नहीं चलेंगे। यह अपने उदाहरण में एक स्वचालित ढंग से काम कर रहे हैं ताकि आप संपादन 'myFile' करने की जरूरत नहीं है (लाइन 2 दूर करने के लिए), कर git add myfileऔर git commitसंघर्ष से निपटने के लिए। फिर आप अपने इतिहास में चार कमिट्स के साथ 4 कमिटिंग कमिट 2 करेंगे।

अगर किसी को परवाह नहीं है कि आपका इतिहास बदलता है, तो आप इसे फिर से लिख सकते हैं और प्रतिबद्ध 2 (पसंद 2) को हटा सकते हैं। ऐसा करने का आसान तरीका उपयोग करना है git rebase -i 8230fa3। यह आपको एक संपादक में गिरा देगा और आप कमिटमेंट को हटाकर गलत कमिटमेंट को शामिल नहीं करना चुन सकते हैं (और दूसरे कमिट मैसेज के बगल में "पिक" रख सकते हैं। ऐसा करने के नतीजों पर पढ़ें ।

Comments

Rebase मुश्किल हो सकता है, क्योंकि यह लगता है जैसे कोई मर्ज हो गया है।

— कास्केबेल

git rebase -i 8230fa3, और मेरे स्थानीय-केवल परिवर्तनों के साथ कमिट की लाइन को हटा देना मेरे लिए बहुत काम आया। धन्यवाद!

— शमूएल

Answer 5

दृष्टिकोण १

पहले कमिट हैश (उदा: 1406cd61) प्राप्त करें जिसे आपको वापस करना है। साधारण फिक्स कमांड के नीचे होगा,

$ git revert 1406cd61

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

दृष्टिकोण २

कृपया कार्रवाई के विवरण के नीचे का पालन करें, क्योंकि हम उपयोग कर रहे हैं - प्रवर्तन आपको ऐसा करने के लिए git रेपो पर व्यवस्थापक अधिकार रखने की आवश्यकता है ।

चरण 1: आप जिस कमिटमेंट को हटाना चाहते हैं उससे पहले कमिटमेंट का पता लगाएंgit log

चरण 2: चेकआउट जो प्रतिबद्ध हैgit checkout <commit hash>

चरण 3: अपने वर्तमान चेकआउट कमिट का उपयोग करके एक नई शाखा बनाएंgit checkout -b <new branch>

चरण 4: अब आपको हटाए गए कमिट के बाद कमिट जोड़ने की आवश्यकता हैgit cherry-pick <commit hash>

चरण 5: अब उन सभी अन्य कमिटों के लिए चरण 4 को दोहराएं जिन्हें आप रखना चाहते हैं।

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

चरण 7: अपनी टूटी शाखा पर स्विच करेंgit checkout <broken branch>

चरण 8: अब टूटी हुई शाखा पर एक हार्ड रीसेट करें जिसे आप हटाना चाहते हैंgit reset --hard <commit hash>

चरण 9: अपनी निश्चित शाखा को इस शाखा में मिलाएंgit merge <branch name>

चरण 10: मर्ज किए गए परिवर्तनों को वापस मूल में धकेलें। चेतावनी: यह दूरस्थ रेपो को अधिलेखित कर देगा!git push --force origin <branch name>

आप चरण 8 के साथ चरण 2 और 3 को प्रतिस्थापित करके एक नई शाखा बनाए बिना प्रक्रिया कर सकते हैं और फिर चरण 7 और 9 को न चलाएं।

Comments

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

— सुआरसेंगर

Answer 6

आप के साथ अवांछित कमियों को दूर कर सकते हैं git rebase। मान लें कि आपने अपने विषय शाखा में एक सहकर्मी की विषय शाखा से कुछ कमिट शामिल किए हैं, लेकिन बाद में तय करते हैं कि आप उन कमिटों को नहीं चाहते हैं।

git checkout -b tmp-branch my-topic-branch  # Use a temporary branch to be safe.
git rebase -i master  # Interactively rebase against master branch.

इस बिंदु पर आपका टेक्स्ट एडिटर इंटरेक्टिव रिबेस व्यू को खोलेगा। उदाहरण के लिए

1. उन पंक्तियों को हटा दें जिन्हें आप अपनी लाइनें हटाकर नहीं चाहते हैं
2. सेव करके छोड़ो

यदि रिबास सफल नहीं हुआ, तो अस्थायी शाखा हटाएं और दूसरी रणनीति आज़माएं। अन्यथा निम्नलिखित निर्देशों के साथ जारी रखें।

git checkout my-topic-branch
git reset --hard tmp-branch  # Overwrite your topic branch with the temp branch.
git branch -d tmp-branch  # Delete the temporary branch.

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

Comments

क्या आप 'एक और रणनीति आज़माने' का उदाहरण दे सकते हैं?

— pfabri

@pfabri आप उदाहरण के लिए चेरी की दो श्रेणियों को चुन सकते हैं जहां आप खराब प्रतिबद्ध छोड़ देते हैं। आप खराब प्रतिबद्ध वापस कर सकते हैं। आप मैन्युअल रूप से परिवर्तनों को पूर्ववत् करने, या खराब प्रतिबद्ध के बिना एक नई शाखा से शुरू करने और मैन्युअल रूप से अच्छे परिवर्तनों को फिर से शुरू करने से एक गीट समाधान का उपयोग करने से बच सकते हैं। यदि खराब प्रतिबद्ध में संवेदनशील डेटा है, तो आपको अधिक सावधान रणनीति की आवश्यकता होगी: help.github.com/en/articles/…

— डेनिस

Answer 7

यहाँ अन्य उत्तरों से, मैं एक उलझन में था कि git rebase -iकिसी कमिट को निकालने के लिए कैसे इस्तेमाल किया जा सकता है, इसलिए मुझे उम्मीद है कि यहां मेरे टेस्ट केस को (ओपी के समान) नीचे लिख देना ठीक है।

यहाँ एक bashस्क्रिप्ट है जिसे आप /tmpफ़ोल्डर में टेस्ट रिपॉजिटरी बनाने के लिए पेस्ट कर सकते हैं :

set -x

rm -rf /tmp/myrepo*
cd /tmp

mkdir myrepo_git
cd myrepo_git
git init
git config user.name me
git config user.email [e-mail]

mkdir folder
echo aaaa >> folder/file.txt
git add folder/file.txt
git commit -m "1st git commit"

echo bbbb >> folder/file.txt
git add folder/file.txt
git commit -m "2nd git commit"

echo cccc >> folder/file.txt
git add folder/file.txt
git commit -m "3rd git commit"

echo dddd >> folder/file.txt
git add folder/file.txt
git commit -m "4th git commit"

echo eeee >> folder/file.txt
git add folder/file.txt
git commit -m "5th git commit"

इस बिंदु पर, हमारे पास file.txtइन सामग्रियों के साथ है:

aaaa
bbbb
cccc
dddd
eeee

इस बिंदु पर, HEAD 5 वीं प्रतिबद्ध है, HEAD ~ 1 का 4 वां होगा - और HEAD ~ 4 का पहला कमिट होगा (इसलिए HEAD ~ 5 मौजूद नहीं होगा)। मान लें कि हम तीसरी प्रतिबद्धता को हटाना चाहते हैं - हम इस आदेश को myrepo_gitनिर्देशिका में जारी कर सकते हैं :

git rebase -i HEAD~4

( ध्यान दें कि git rebase -i HEAD~5के साथ परिणाम। "घातक: जरूरत एक भी संशोधन; अमान्य नदी के ऊपर HEAD ~ 5" ) एक पाठ संपादक (में स्क्रीनशॉट देखें @Dennis 'जवाब ) इन सामग्री के साथ खुल जाएगा:

pick 5978582 2nd git commit
pick 448c212 3rd git commit
pick b50213c 4th git commit
pick a9c8fa1 5th git commit

# Rebase b916e7f..a9c8fa1 onto b916e7f
# ...

तो हम सभी प्रतिबद्ध पाने के बाद से (लेकिन सहित नहीं ) हमारे अनुरोध किया HEAD ~ 4। लाइन हटाएं pick 448c212 3rd git commitऔर फ़ाइल को सहेजें; आपको यह प्रतिक्रिया मिलेगी git rebase:

error: could not apply b50213c... 4th git commit

When you have resolved this problem run "git rebase --continue".
If you would prefer to skip this patch, instead run "git rebase --skip".
To check out the original branch and stop rebasing run "git rebase --abort".
Could not apply b50213c... 4th git commit

इस बिंदु पर folder/file.txtएक पाठ संपादक में myrepo_git / खोलें ; आप देखेंगे कि इसे संशोधित कर दिया गया है:

aaaa
bbbb
<<<<<<< HEAD
=======
cccc
dddd
>>>>>>> b50213c... 4th git commit

मूल रूप से, gitदेखता है कि जब HEAD को द्वितीय वचन मिला, तब aaaa+ की सामग्री थी bbbb; और फिर इसमें जोड़ा cccc+ का एक पैच है ddddजो यह नहीं जानता कि मौजूदा सामग्री को कैसे जोड़ा जाए ।

तो यहाँ gitआप के लिए तय नहीं कर सकते हैं - यह आप है जो एक निर्णय करना है: 3 जी प्रतिबद्ध को हटाने के द्वारा, आप या तो इसके द्वारा प्रस्तुत परिवर्तन (यहाँ, लाइन cccc) - या आप नहीं रखते हैं। आप नहीं करते हैं, बस अतिरिक्त लाइनें हटाने - सहित ccccमें - folder/file.txt, एक पाठ संपादक का उपयोग तो यह इस तरह दिखता है:

aaaa
bbbb
dddd

... और फिर बचाना folder/file.txt। अब आप myrepo_gitनिर्देशिका में निम्नलिखित आदेश जारी कर सकते हैं :

$ nano folder/file.txt  # text editor - edit, save
$ git rebase --continue
folder/file.txt: needs merge
You must edit all merge conflicts and then
mark them as resolved using git add

आह - ताकि हम संघर्ष को हल कर सकें, यह चिह्नित करने के लिए, हमें ऐसा git add करने folder/file.txtसे पहले git rebase --continue:

$ git add folder/file.txt
$ git rebase --continue

यहां एक पाठ संपादक फिर से खुलता है, लाइन दिखा रहा है 4th git commit- यहां हमारे पास प्रतिबद्ध संदेश को बदलने का मौका है (जो इस मामले में सार्थक रूप से 4th (and removed 3rd) commitया इसी तरह बदला जा सकता है )। मान लें कि आप नहीं चाहते हैं - तो बिना सहेजे पाठ संपादक से बाहर निकलें; एक बार जब आप ऐसा करेंगे, तो आपको मिलेगा:

$ git rebase --continue
[detached HEAD b8275fc] 4th git commit
 1 file changed, 1 insertion(+)
Successfully rebased and updated refs/heads/master.

इस बिंदु पर, अब आपके पास इस तरह का एक इतिहास है (जो कि आप मूल gitk .सामग्री के folder/file.txtसमय पर अपरिवर्तित टाइमस्टैम्प की सामग्री के साथ या अन्य उपकरणों के साथ कह सकते हैं )

1st git commit  |  +aaaa
----------------------------------------------
2nd git commit  |   aaaa
                |  +bbbb
----------------------------------------------
4th git commit  |   aaaa
                |   bbbb
                |  +dddd
----------------------------------------------
5th git commit  |   aaaa
                |   bbbb
                |   dddd
                |  +eeee

और अगर पहले, हमने लाइन रखने का फैसला किया था cccc(3 जीआईटी कमिट की सामग्री जिसे हमने हटा दिया था), हमारे पास होगा:

1st git commit  |  +aaaa
----------------------------------------------
2nd git commit  |   aaaa
                |  +bbbb
----------------------------------------------
4th git commit  |   aaaa
                |   bbbb
                |  +cccc
                |  +dddd
----------------------------------------------
5th git commit  |   aaaa
                |   bbbb
                |   cccc
                |   dddd
                |  +eeee

खैर, इस तरह की पठन मुझे उम्मीद थी कि मुझे मिल जाएगा, कमिटिंग शुरू करने के लिए कि कैसे git rebaseकमिट / रिविज़न हटाने के मामले में काम करता है; इसलिए उम्मीद है कि यह दूसरों की भी मदद कर सकता है ...

Comments

एक अमूल्य वॉक-थ्रू - मैं जिस सटीक उपयोग के मामले से जूझ रहा था, इससे मुझे काफी मदद मिली।

— पीफब्री

Answer 8

तो ऐसा लगता है कि किसी बिंदु पर मर्ज कमिट में खराब प्रतिबद्ध को शामिल किया गया था। क्या आपका मर्ज कमिट किया गया है? यदि हाँ, तो आप उपयोग करना चाहते हैं git revert; आपको अपने दांतों को पीसना होगा और संघर्षों के माध्यम से काम करना होगा। यदि नहीं, तो आप गर्भधारण कर सकते हैं या तो रिबेस या रिवर्ट कर सकते हैं, लेकिन आप मर्ज कमिट करने से पहले ऐसा कर सकते हैं , फिर मर्ज को फिर से करें।

वास्तव में हम आपको पहले मामले के लिए बहुत मदद नहीं दे सकते। रिवर्ट की कोशिश करने के बाद, और यह पाते हुए कि स्वचालित विफल हो गया, आपको संघर्षों की जांच करनी होगी और उन्हें उचित रूप से ठीक करना होगा। यह ठीक वैसी ही प्रक्रिया है जैसे मर्ज टकराव को ठीक करना; आप यह git statusदेखने के लिए उपयोग कर सकते हैं कि संघर्ष कहाँ हैं, अनमैरिड फ़ाइलों को संपादित करें, विवादित हंक ढूंढें, उनका पता लगाएँ कि उन्हें कैसे हल करें, विवादित फ़ाइलों को जोड़ें, और अंत में कमिट करें। यदि आप git commitस्वयं (नहीं -m <message>) का उपयोग करते हैं , तो आपके संपादक में जो संदेश आता है, वह टेम्पलेट द्वारा बनाया गया संदेश होना चाहिए git revert; आप इस बारे में एक नोट जोड़ सकते हैं कि आपने संघर्षों को कैसे तय किया, फिर सहेजें और प्रतिबद्ध होने के लिए छोड़ दें।

दूसरे मामले के लिए, अपने मर्ज से पहले समस्या को ठीक करना , दो उप-मामले हैं, यह इस बात पर निर्भर करता है कि आपने मर्ज के बाद से अधिक काम किया है या नहीं। यदि आपने ऐसा नहीं किया है, तो आप git reset --hard HEAD^मर्ज को खटखटा सकते हैं, वापस कर सकते हैं, फिर मर्ज को फिर से कर सकते हैं। लेकिन मैं अनुमान लगा रहा हूं कि आपके पास है। तो, आप कुछ इस तरह से करेंगे:

• मर्ज के ठीक पहले एक अस्थायी शाखा बनाएं, और इसे देखें
• रिवर्ट करें (या git rebase -i <something before the bad commit> <temporary branch>खराब प्रतिबद्ध को हटाने के लिए उपयोग करें)
• मर्ज को फिर से करें
• अपने बाद के काम को वापस करें: git rebase --onto <temporary branch> <old merge commit> <real branch>
• अस्थायी शाखा को हटा दें

Answer 9

तो आपने कुछ काम किया और इसे आगे बढ़ाया, उन्हें ए और बी कॉल करने दिया। आपके सहकर्मी ने भी कुछ काम किया, सी और डी। आपने अपने सहकर्मियों के काम को आप में मिला दिया (मर्ज कमिट ई), फिर काम करना जारी रखा, जो भी (एफ), और पता चला कि आपके सहकर्मी ने कुछ चीजें बदल दीं जो उसके पास नहीं होनी चाहिए।

तो आपका प्रतिबद्ध इतिहास इस तरह दिखता है:

A -- B -- C -- D -- D' -- E -- F

आप वास्तव में C, D, और D 'से छुटकारा पाना चाहते हैं। चूँकि आप कहते हैं कि आपने अपने सहकर्मियों को अपने काम में मिला लिया है, ये पहले से ही "बाहर" हैं, इसलिए उदाहरण के तौर पर git rebase का उपयोग करते हुए कमिट्स को हटाना एक नहीं है। मेरा विश्वास करो, मैंने कोशिश की है।

अब, मुझे दो तरीके दिखाई देते हैं:

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

  git reset D'
  

  (डी 'को वास्तविक कमिट हैश से बदलें जिसे आप ए से प्राप्त कर सकते हैं git log

  इस बिंदु पर, ई और एफ चले जाते हैं और परिवर्तन आपके स्थानीय कार्यक्षेत्र में फिर से परिवर्तन नहीं किए जाते हैं। इस बिंदु पर मैं उन्हें एक शाखा में ले जाऊंगा या उन्हें एक पैच में बदल दूंगा और बाद में इसे सहेजूंगा। अब, अपने सहकर्मी के काम को वापस करें, या तो स्वचालित git revertरूप से या मैन्युअल रूप से। जब आपने ऐसा कर लिया है, तो उस शीर्ष पर अपना काम फिर से करें। हो सकता है कि आपके पास संघर्ष हो, लेकिन कम से कम वे आपके सहकर्मी के कोड के बजाय आपके द्वारा लिखे गए कोड में होंगे।

• यदि आपने अपने सहकर्मी के आने के बाद पहले से काम को धक्का दे दिया है, तो आप अभी भी कोशिश कर सकते हैं और "रिवर्स पैच" प्राप्त कर सकते हैं या तो मैन्युअल रूप से या उपयोग कर सकते हैं git revert, लेकिन चूंकि आपका काम "रास्ते में" है, इसलिए बोलने के लिए आपको शायद मिलेगा अधिक विलय संघर्ष और अधिक भ्रमित करने वाले। ऐसा लगता है कि आप में क्या खत्म हो गया है ...

Answer 10

git रिवर्ट - कम्फ़र्टेबल रिज़ॉल्यूशन अगर कमिट है तो मर्ज है: git revert --strategy solution -m १