पिछले कमिट को कई कमिट में तोड़ें

Question

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

Comments

यह करने के लिए सीखने का एक अच्छा स्रोत प्रो Git G6.4 Git Tools है - "स्प्लिटिंग ए कमिट" खंड में इतिहास को फिर से लिखना ।

उपरोक्त टिप्पणी पर लिंक किए गए डॉक्स उत्कृष्ट हैं, नीचे दिए गए उत्तरों की तुलना में बेहतर बताया गया है।

— Blaisorblade

मेरा सुझाव है कि इस उपनाम का उपयोग करें stackoverflow.com/a/19267103/301717 । यह विभाजित करने के लिए एक का उपयोग कर के लिए प्रतिबद्ध की अनुमति देता हैgit autorebase split COMMIT_ID

— जेरोम Pouiller

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

— विलियम पर्सेल

इससे पहले कि मैं कमिटमेंट में रिबास के दौरान गलती से दो कमिट्स स्क्वैश कर चुका था, मैं इस समस्या में भाग गया। इसे ठीक करने के लिए अपने रास्ते चेकआउट करने के लिए कुचल के लिए प्रतिबद्ध, था git reset HEAD~, git stashहै, तो git cherry-pickपहले स्क्वैश के भीतर, प्रतिबद्ध तो git stash pop। मेरे चेरी ले मामला यहां काफी सटीक है, लेकिन git stashऔर git stash popदूसरों के लिए काफी उपयोगी है।

— SOFe

Answer 1

git rebase -i करूंगा।

सबसे पहले, एक साफ काम करने वाले डायरेक्टरी के साथ शुरू करें: git statusकोई लंबित संशोधन, विलोपन या परिवर्धन नहीं दिखाना चाहिए।

अब, आपको यह तय करना है कि आप किस विभाजन को विभाजित करना चाहते हैं।

ए) सबसे हाल की प्रतिबद्ध विभाजन

अपनी सबसे हाल की प्रतिबद्धताओं को अलग करने के लिए, पहले:

$ git reset HEAD~

अब टुकड़ों को सामान्य रूप से अलग-अलग तरीके से प्रतिबद्ध करें, जितने की जरूरत है उतने ही उत्पादन करें।

बी) एक प्रतिबद्ध आगे पीछे विभाजन

इसके लिए आवश्यक है रिबेसिंग , कि है, इतिहास को फिर से लिखने। सही कमिटमेंट खोजने के लिए, आपके पास कई विकल्प हैं:

• यदि यह तीन वापस आ गया था, तो

  $ git rebase -i HEAD~3
  

  जहां 3यह वापस आता है

• यदि यह पेड़ में वापस गिनती की तुलना में कहीं आगे था, तो

  $ git rebase -i 123abcd~
  

  जहां 123abcdआप विभाजन करना चाहते हैं वहां SHA1 है।

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

  $ git rebase -i master
  

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

$ git reset HEAD~

टुकड़ों को सामान्य रूप से अलग-अलग तरीके से प्रतिबद्ध करें, जितने की जरूरत हो, उतने ही उत्पादन करें

$ git rebase --continue

Comments

इस उत्तर के लिए धन्यवाद। मैं मंचन क्षेत्र में कुछ पहले से प्रतिबद्ध फाइलें रखना चाहता था, इसलिए मेरे लिए निर्देश थोड़ा अलग थे। इससे पहले कि मैं कर सकता git rebase --continue, मैं वास्तव में किया था git add (files to be added), git commitहै, तो git stash(शेष फ़ाइलों के लिए)। उसके बाद git rebase --continue, मुझे git checkout stash .बची हुई फाइलें

— एरिक हू

मनोजर्स के जवाब में वास्तव में गिट- स्कैम के प्रलेखन की यह कड़ी है , जो स्पष्ट रूप से विभाजन की प्रक्रिया को भी स्पष्ट रूप से बताता है।

आप git add -pफ़ाइलों के केवल आंशिक वर्गों को जोड़ने का लाभ उठाना चाहेंगे , संभवतः eसंपादन के विकल्प के साथ केवल कुछ हंक करने के लिए भिन्न होता है। git stashयह भी उपयोगी है यदि आप कुछ काम आगे ले जाना चाहते हैं, लेकिन इसे वर्तमान प्रतिबद्ध से हटा दें।

— क्रेग रिंगर

यदि आप विभाजित करना चाहते हैं और फिर से शुरू करते हैं, तो मुझे जो करना पसंद है वह पहले अलग हो जाता है और फिर दूसरी git rebase -i HEAD^3कमांड का उपयोग करके अलग से फिर से चालू होता है । इस तरह यदि विभाजन खराब हो जाता है तो आपको ज्यादा काम करने की जरूरत नहीं है।

— डेविड एम। लॉयड

@kralyk जिन फ़ाइलों को HEAD में नया किया गया था, उन्हें बाद में डिस्क पर छोड़ दिया जाएगा git reset HEAD~। वे हारे नहीं हैं।

— वेन कॉनराड

Answer 2

से Git-रिबेस पुस्तिका (विभाजित अनुभाग कॉम)

इंटरैक्टिव मोड में, आप "संपादित करें" क्रिया के साथ कमिट्स को चिह्नित कर सकते हैं। हालाँकि, इसका मतलब यह नहीं है कि git rebase को उम्मीद है कि इस एडिट का परिणाम ठीक एक कमिट होगा। वास्तव में, आप कमिट को पूर्ववत कर सकते हैं, या आप अन्य कमिट जोड़ सकते हैं। इसका उपयोग कमिट को दो में विभाजित करने के लिए किया जा सकता है:

• एक इंटरेक्टिव रिबेस शुरू करें git rebase -i <commit>^, जहाँ <commit>आप विभाजन करना चाहते हैं। वास्तव में, कोई भी कमिट रेंज तब तक करेगी, जब तक उसमें वह कमिटमेंट शामिल है।

• उस कमिट को चिह्नित करें जिसे आप "एडिट" क्रिया से विभाजित करना चाहते हैं।

• जब उस प्रतिबद्ध को संपादित करने की बात आती है, तो निष्पादित करें git reset HEAD^। इसका प्रभाव यह है कि HEAD एक के बाद एक रिवाइंड होता है और इंडेक्स सूट करता है। हालांकि, काम करने वाला पेड़ वही रहता है।

• अब उस इंडेक्स में बदलाव करें जिसे आप पहले कमिट में रखना चाहते हैं। आप ऐसा करने के लिए git add(संभवतः अंतःक्रियात्मक रूप से) या git gui(या दोनों) का उपयोग कर सकते हैं ।

• जो भी प्रतिबद्ध संदेश है, उसके साथ अब-वर्तमान सूचकांक को प्रतिबद्ध करें।

• आखिरी दो चरणों को दोहराएं जब तक कि आपका काम करने वाला पेड़ साफ न हो।

• के साथ छूट जारी रखें git rebase --continue।

Comments

विंडोज पर आप आप का उपयोग किया है ~के बजाय ^।

— केविन कुज़्की

शब्द सावधानी: इस दृष्टिकोण के साथ मैंने प्रतिबद्ध संदेश खो दिया।

— user420667

@ user420667 हां, बिल्कुल। हम resetकमिट कर रहे हैं , आखिरकार - संदेश भी शामिल है। विवेकपूर्ण बात, यदि आप जानते हैं कि आप एक प्रतिबद्ध विभाजन करने जा रहे हैं, लेकिन इसके कुछ / सभी संदेश रखना चाहते हैं, तो उस संदेश की एक प्रति लेना है। इसलिए, आईएनजी git showसे पहले प्रतिबद्ध rebase, या यदि आप इसे भूल जाते हैं या इसे पसंद करते हैं: बाद में इसके माध्यम से वापस प्राप्त करें reflog। इसमें से कोई भी वास्तव में "खो" नहीं जाएगा जब तक कि यह 2 सप्ताह या जो भी हो, कचरा-संग्रहित न हो।

— अंडरस्कोर_ड

~और ^अलग-अलग चीजें हैं, यहां तक ​​कि विंडोज पर भी। आप अभी भी कैरेट चाहते हैं ^, इसलिए आपको इसे अपने शेल के लिए उपयुक्त रूप से बचना होगा। PowerShell में, यह है HEAD`^। Cmd.exe के साथ, आप इसे बचने के लिए दोहरा सकते हैं HEAD^^। अधिकांश (सभी?) गोले में, आप जैसे उद्धरणों से घेर सकते हैं "HEAD^"।

— एंड्रयूएफ

आप यह भी कर सकते हैं git commit --reuse-message=abcd123। इसके लिए संक्षिप्त विकल्प है -C।

— j0057

Answer 3

git rebase --interactiveसंपादित करने के लिए उपयोग करें कि पहले प्रतिबद्ध, चलाएं git reset HEAD~, और फिर git add -pकुछ जोड़ने के लिए, फिर एक प्रतिबद्ध करें, फिर कुछ और जोड़ें और एक और प्रतिबद्ध बनाएं, जितनी बार आप चाहें। जब आप काम कर रहे हों, दौड़ें git rebase --continue, और आपके पास पहले से ही अपने ढेर में विभाजित विभाजन होगा।

महत्वपूर्ण : ध्यान दें कि आप अपने आस-पास खेल सकते हैं और अपने इच्छित सभी बदलाव कर सकते हैं, और पुराने परिवर्तनों को खोने के बारे में चिंता करने की ज़रूरत नहीं है, क्योंकि आप हमेशा git reflogअपनी परियोजना में उस बिंदु को खोजने के लिए दौड़ सकते हैं जिसमें आपके इच्छित परिवर्तन हैं, (चलो इसे कॉल करें a8c4ab) , और फिर git reset a8c4ab।

यह कैसे काम करता है, यह दिखाने के लिए यहां कुछ आदेश दिए गए हैं:

mkdir git-test; cd git-test; git init

अब एक फ़ाइल जोड़ें A

vi A

इस पंक्ति को जोड़ें:

one

git commit -am one

फिर इस लाइन को A में जोड़ें:

two

git commit -am two

फिर इस लाइन को A में जोड़ें:

three

git commit -am three

अब फाइल ए इस तरह दिखती है:

one
two
three

और हमारे git logनिम्नलिखित की तरह दिखता है (ठीक है, मैं उपयोग करता हूंgit log --pretty=oneline --pretty="%h %cn %cr ---- %s"

bfb8e46 Rose Perrone 4 seconds ago ---- three
2b613bc Rose Perrone 14 seconds ago ---- two
9aac58f Rose Perrone 24 seconds ago ---- one

चलो का कहना है, हम दूसरे के लिए प्रतिबद्ध विभाजित करना चाहते हैं two।

git rebase --interactive HEAD~2

यह एक संदेश लाता है जो इस तरह दिखता है:

pick 2b613bc two
pick bfb8e46 three

उस कमिट को संपादित pickकरने के लिए पहले बदलें e।

git reset HEAD~

git diff हमें पता चलता है कि हमने केवल दूसरी प्रतिबद्धताओं के लिए की गई प्रतिबद्धताओं को अनसुना कर दिया है:

diff --git a/A b/A
index 5626abf..814f4a4 100644
--- a/A
+++ b/A
@@ -1 +1,2 @@
 one
+two

चलिए उस चरण को बदलते हैं, और फ़ाइल में "और एक तीसरा" उस पंक्ति में जोड़ते हैं A।

git add .

यह आमतौर पर एक इंटरैक्टिव रिबेस के दौरान बिंदु होता है जहां हम दौड़ेंगे git rebase --continue, क्योंकि हम आमतौर पर पहले के कमिट को संपादित करने के लिए अपने कमिट्स के ढेर में वापस जाना चाहते हैं। लेकिन इस बार, हम एक नई प्रतिबद्धता बनाना चाहते हैं। तो हम चलेंगे git commit -am 'two and a third'। अब हम फाइल को एडिट करते हैं Aऔर लाइन को जोड़ते हैं two and two thirds।

git add . git commit -am 'two and two thirds' git rebase --continue

हमारा अपनी प्रतिबद्धता के साथ विरोध है three, इसलिए हम इसे हल करें:

हम बदल देंगे

one
<<<<<<< HEAD
two and a third
two and two thirds
=======
two
three
>>>>>>> bfb8e46... three

सेवा

one
two and a third
two and two thirds
three

git add .; git rebase --continue

अब हमारा git log -pऐसा दिखता है:

commit e59ca35bae8360439823d66d459238779e5b4892
Author: Rose Perrone <[e-mail]>
Date:   Sun Jul 7 13:57:00 2013 -0700

    three

diff --git a/A b/A
index 5aef867..dd8fb63 100644
--- a/A
+++ b/A
@@ -1,3 +1,4 @@
 one
 two and a third
 two and two thirds
+three

commit 4a283ba9bf83ef664541b467acdd0bb4d770ab8e
Author: Rose Perrone <[e-mail]>
Date:   Sun Jul 7 14:07:07 2013 -0700

    two and two thirds

diff --git a/A b/A
index 575010a..5aef867 100644
--- a/A
+++ b/A
@@ -1,2 +1,3 @@
 one
 two and a third
+two and two thirds

commit 704d323ca1bc7c45ed8b1714d924adcdc83dfa44
Author: Rose Perrone <[e-mail]>
Date:   Sun Jul 7 14:06:40 2013 -0700

    two and a third

diff --git a/A b/A
index 5626abf..575010a 100644
--- a/A
+++ b/A
@@ -1 +1,2 @@
 one
+two and a third

commit 9aac58f3893488ec643fecab3c85f5a2f481586f
Author: Rose Perrone <[e-mail]>
Date:   Sun Jul 7 13:56:40 2013 -0700

    one

diff --git a/A b/A
new file mode 100644
index 0000000..5626abf
--- /dev/null
+++ b/A
@@ -0,0 +1 @@
+one

Answer 4

पिछले उत्तरों ने git rebase -iउस कमिट को संपादित करने के उपयोग को कवर किया है जिसे आप विभाजित करना चाहते हैं, और इसे भागों में कर रहे हैं।

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

उस कमिटमेंट के लिए जिसे आप विभाजित करना चाहते हैं, rebase -iइसके लिए उपयोग करना और उसे चिह्नित करना edit, आपके पास दो विकल्प हैं।

1. उपयोग करने के बाद git reset HEAD~, व्यक्तिगत रूप से उन लोगों का git add -pचयन करने के लिए पैच का उपयोग करें, जिन्हें आप चाहते हैं

2. उन परिवर्तनों को हटाने के लिए कार्यशील प्रतिलिपि संपादित करें जिन्हें आप नहीं चाहते हैं; उस अंतरिम राज्य को प्रतिबद्ध; और फिर अगले दौर के लिए पूरी प्रतिबद्धता वापस खींच लें।

विकल्प 2 उपयोगी है यदि आप एक बड़ी प्रतिबद्धता को विभाजित कर रहे हैं, क्योंकि यह आपको यह जांचने देता है कि अंतरिम संस्करण मर्ज के भाग के रूप में ठीक से निर्मित और चल रहे हैं। यह निम्नानुसार आगे बढ़ता है।

उपयोग करने के बाद rebase -iऔर editकमिट का उपयोग करें

git reset --soft HEAD~

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

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

एक बार जब आप खुश हो जाते हैं, आवश्यकतानुसार फाइलों को स्टेज / अनस्टेज कर लेते हैं (मैं इसके लिए उपयोग करना पसंद करता हूं git gui), और UI और कमांड लाइन के माध्यम से बदलाव करता हूं।

git commit

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

$ git status
interactive rebase in progress; onto be83b41
Last commands done (3 commands done):
   pick 4847406 US135756: add debugging to the file download code
   e 65dfb6a US135756: write data and download from remote
  (see more in file .git/rebase-merge/done)
...

इस स्थिति में, मैं जो संपादन कर रहा हूं उसमें sha1 है 65dfb6a। यह जानकर कि, मैं अपनी वर्किंग डायरेक्टरी पर उस कमेटी की सामग्री की जांच कर सकता हूं, git checkoutजिसके फॉर्म का उपयोग करके कमिट और फाइल लोकेशन दोनों लेता है। यहाँ मैं .पूरी वर्किंग कॉपी को बदलने के लिए फाइल लोकेशन के रूप में उपयोग करता हूँ :

git checkout 65dfb6a .

अंत में डॉट याद मत करो!

यह जाँच करेगा, और चरण, वे फ़ाइलें जो वे आपके द्वारा संपादित किए जाने वाले कमिट के बाद थीं, लेकिन आपके द्वारा की गई पिछली कमिट के सापेक्ष, इसलिए आपके द्वारा पहले से किए गए कोई भी बदलाव कमिट का हिस्सा नहीं होंगे।

आप या तो अब आगे बढ़ सकते हैं और इसे कम कर सकते हैं-विभाजन को समाप्त करने के लिए, या फिर से फिर से घूमने के लिए, एक और अंतरिम प्रतिबद्ध बनाने से पहले प्रतिबद्ध के कुछ हिस्सों को हटा दें।

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

git commit --file .git/rebase-merge/message

अंत में, एक बार जब आप सभी परिवर्तन कर लेते हैं,

git rebase --continue

आगे बढ़ेगा और रिबेज ऑपरेशन को पूरा करेगा।

Comments

धन्यवाद!!! यह स्वीकृत उत्तर होना चाहिए। आज मुझे बहुत समय और दर्द बचा लिया होता। यह एकमात्र उत्तर है जहां अंतिम प्रतिबद्ध का परिणाम आपको उसी राज्य में लाता है जहां संपादन के तहत प्रतिबद्ध है।

— डग कोबर्न

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

— सालमंदर

विकल्प 2 का उपयोग करना, जब मैं करता हूं तो git checkout *Sha I'm Editing* .यह हमेशा कहता है Updated 0 paths from *Some Sha That's Not In Git Log*और कोई परिवर्तन नहीं देता है।

— नूमेनन

Answer 5

git rebase --interactiveका उपयोग कमिट को कमिट में विभाजित करने के लिए किया जा सकता है। रिबेस पर Git डॉक्स प्रक्रिया का एक संक्षिप्त पूर्वाभ्यास है - विभाजन करता है :

इंटरैक्टिव मोड में, आप "संपादित करें" कार्रवाई के साथ कमिट्स को चिह्नित कर सकते हैं। हालाँकि, इसका मतलब यह नहीं है कि git rebaseइस सम्पादन के परिणाम की अपेक्षा यह है कि यह वास्तव में एक प्रतिबद्ध हो। वास्तव में, आप कमिट को पूर्ववत कर सकते हैं, या आप अन्य कमिट जोड़ सकते हैं। इसका उपयोग कमिट को दो में विभाजित करने के लिए किया जा सकता है:

• एक इंटरेक्टिव रिबेस शुरू करें git rebase -i <commit>^, जहाँ <commit>आप विभाजन करना चाहते हैं। वास्तव में, कोई भी कमिट रेंज तब तक करेगी, जब तक उसमें वह कमिटमेंट शामिल है।

• उस कमिट को चिह्नित करें जिसे आप "एडिट" क्रिया से विभाजित करना चाहते हैं।

• जब उस प्रतिबद्ध को संपादित करने की बात आती है, तो निष्पादित करें git reset HEAD^। इसका प्रभाव यह है कि HEAD एक के बाद एक रिवाइंड होता है और इंडेक्स सूट करता है। हालांकि, काम करने वाला पेड़ वही रहता है।

• अब उस इंडेक्स में बदलाव करें जिसे आप पहले कमिट में रखना चाहते हैं। ऐसा करने के लिए आप git add(संभवतः अंतःक्रियात्मक रूप से) या गिट गुई (या दोनों) का उपयोग कर सकते हैं ।

• जो भी प्रतिबद्ध संदेश है, उसके साथ अब-वर्तमान सूचकांक को प्रतिबद्ध करें।

• आखिरी दो चरणों को दोहराएं जब तक कि आपका काम करने वाला पेड़ साफ न हो।

• के साथ छूट जारी रखें git rebase --continue।

यदि आप पूरी तरह से आश्वस्त नहीं हैं कि मध्यवर्ती संशोधन सुसंगत हैं (वे git stashपरीक्षण करते हैं, परीक्षा पास करते हैं, इत्यादि) तो आपको प्रत्येक प्रतिबद्ध, परीक्षण के बाद बदलाव नहीं करने के लिए उपयोग करना चाहिए और यदि आवश्यक हो तो संशोधन में संशोधन करना चाहिए। ।

Comments

विंडोज के तहत, याद रखें ^कमांड लाइन के लिए एक एस्केप चरित्र है: इसे दोगुना किया जाना चाहिए। उदाहरण के लिए, git reset HEAD^^इसके बजाय जारी करें git reset HEAD^।

— फ्रैडरिक

@ Frédéric: मैं इस में कभी नहीं चला है। कम से कम पॉवरशेल में ऐसा नहीं है। फिर ^दो बार उपयोग करने से दो हिट चालू हेड से ऊपर हो जाते हैं।

— फ़रवे

@ फ़ारवे, इसे क्लासिक कमांड लाइन में आज़माएँ। पॉवरशेल एक और जानवर है, इसका एस्केप कैरेक्टर बैकटेल है।

— Frédéric

संक्षेप में: "HEAD^"cmd.exe या PowerShell में, HEAD^^cmd.exe में, HEAD`^PowerShell में। यह जानने के लिए उपयोगी है कि कैसे गोले - और आपके विशेष शेल - काम (यानी, कैसे एक आदेश व्यक्तिगत भागों में बदल जाता है जो कार्यक्रम में पास हो जाते हैं) ताकि आप अपने विशेष शेल के लिए सही वर्णों में ऑनलाइन आदेशों को अनुकूलित कर सकें। (विंडोज के लिए विशिष्ट नहीं है।)

— एंड्रयू 22

Answer 6

अब विंडोज पर नवीनतम TortoiseGit में आप इसे बहुत आसानी से कर सकते हैं।

रिबास संवाद खोलें, इसे कॉन्फ़िगर करें , और निम्न चरण करें।

• उस विभाजन पर राइट-क्लिक करें जिसे आप विभाजित करना चाहते हैं और " Edit" चुनें (पिक, स्क्वैश, डिलीट ...) के बीच।
• Startरिबासिंग शुरू करने के लिए " " पर क्लिक करें ।
• एक बार जब यह विभाजन करने के लिए प्रतिबद्ध हो जाता है, तो " Edit/Split" बटन की जांच करें और Amendसीधे " " पर क्लिक करें । प्रतिबद्ध संवाद खुल जाता है।
  
• उन फ़ाइलों को अचयनित करें जिन्हें आप एक अलग कमिट पर रखना चाहते हैं।
• प्रतिबद्ध संदेश संपादित करें, और फिर " commit" पर क्लिक करें ।
• जब तक करने के लिए फाइलें हैं, तब तक कमिट डायलॉग बार-बार खुलेगा। जब कमिट करने के लिए कोई और फाइल नहीं है, तब भी यह आपसे पूछेगा कि क्या आप एक और कमिट जोड़ना चाहते हैं।

बहुत उपयोगी, धन्यवाद कछुआ!

Answer 7

आप इंटरेक्टिव रिबेस कर सकते हैं git rebase -i। मैन पेज में ठीक वही है जो आप चाहते हैं:

http://git-scm.com/docs/git-rebase#_splitting_commits

Comments

मुद्दों को कैसे सम्‍मिलित करना है, इस पर थोड़ा और संदर्भ देना। सिर्फ आरटीएफएम देना थोड़ा और मददगार होगा।

— जॉर्डन डे-मैट्सन

Answer 8

कृपया ध्यान दें कि वहाँ भी है git reset --soft HEAD^। यह git reset(जो कि चूक --mixed) के समान है, लेकिन यह सूचकांक सामग्री को बरकरार रखता है। ताकि यदि आपने फ़ाइलें जोड़ी / हटा दी हैं, तो आप उन्हें पहले ही सूची में शामिल कर लें।

विशालकाय आवागमन के मामले में यह बहुत उपयोगी साबित होता है।

Answer 9

यहाँ विभाजित करने के लिए कैसे एक में प्रतिबद्ध है IntelliJ विचार , PyCharm , PhpStorm आदि

1. संस्करण नियंत्रण लॉग विंडो में, उस विभाजन का चयन करें जिसे आप विभाजित करना चाहते हैं, राइट क्लिक करें और चयन करें Interactively Rebase from Here

2. जिसको आप विभाजित करना चाहते हैं उसे चिह्नित editकरें, क्लिक करेंStart Rebasing

3. आपको यह देखना चाहिए कि पीले रंग का टैग लगाया गया है जिसका अर्थ है कि HEAD उस कमिट पर सेट है। उस कमेट पर राइट क्लिक करें, सेलेक्ट करेंUndo Commit

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

Answer 10

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

Comments

एसओ स्टैंडर्स के अनुसार इन दिनों यह एक जवाब के रूप में योग्य होना चाहिए; लेकिन यह अभी भी दूसरों के लिए मददगार हो सकता है, इसलिए यदि आपको कोई आपत्ति नहीं है, तो कृपया इसे मूल पोस्ट की टिप्पणियों में स्थानांतरित करें

— यकॉव

@YakovL उचित लगता है। न्यूनतम कार्रवाई के प्रिंसिपल पर, मैं जवाब नहीं हटाऊंगा, लेकिन अगर कोई और करता है तो मुझे कोई आपत्ति नहीं होगी।

— विलियम पर्सल

यह सभी rebase -iसुझावों की तुलना में बहुत आसान होगा । मुझे लगता है कि किसी भी स्वरूपण की कमी के कारण इस पर ज्यादा ध्यान नहीं दिया गया। हो सकता है कि आप इसकी समीक्षा करें, अब आपके पास 126k अंक हैं और शायद एसओ को पता है। ;)

— एरिकबवर्क

Answer 11

मुझे लगता है कि सबसे अच्छा तरीका मैं उपयोग करता हूं git rebase -i। मैंने एक कमिट को विभाजित करने के लिए चरण दिखाने के लिए एक वीडियो बनाया: https://www.youtube.com/watch?v=3EzOz7e1ADI

Answer 12

यदि आपके पास यह है:

A - B <- mybranch

जहाँ आपने कमिट B में कुछ सामग्री दी है:

/modules/a/file1
/modules/a/file2
/modules/b/file3
/modules/b/file4

लेकिन आप B को C - D में विभाजित करना चाहते हैं, और यह परिणाम प्राप्त करते हैं:

A - C - D <-mybranch

आप उदाहरण के लिए इस तरह की सामग्री को विभाजित कर सकते हैं (अलग-अलग निर्देशिकाओं की सामग्री अलग-अलग कमिट में) ...

विभाजन करने से पहले शाखा को वापस कमेट पर रीसेट करें:

git checkout mybranch
git reset --hard A

पहला कमेट बनाएँ (C):

git checkout B /modules/a
git add -u
git commit -m "content of /modules/a"

दूसरी प्रतिबद्ध बनाएँ (D):

git checkout B /modules/b
git add -u
git commit -m "content of /modules/b"

Comments

यदि B के ऊपर कमिट हैं तो क्या होगा?

— कूलमाइंड

Answer 13

यह 8 साल से अधिक हो गया है, लेकिन शायद किसी को यह वैसे भी मददगार मिलेगा। मैं बिना चाल के कर पा रहा था rebase -i। आपके द्वारा किए जाने से पहले उसी स्थिति में जीआईटी का नेतृत्व करने का विचार है git commit:

# first rewind back (mind the dot,
# though it can be any valid path,
# for instance if you want to apply only a subset of the commit)
git reset --hard <previous-commit> .

# apply the changes
git checkout <commit-you-want-to-split>

# we're almost there, but the changes are in the index at the moment,
# hence one more step (exactly as git gently suggests):
# (use "git reset HEAD <file>..." to unstage)
git reset

इसके बाद आपको यह चमकदार दिखाई देगा Unstaged changes after reset:और आपका रेपो ऐसी स्थिति में होगा जैसे आप इन सभी फ़ाइलों को करने वाले हैं। अब से आप इसे आसानी से दोबारा कर सकते हैं जैसे आप आमतौर पर करते हैं। आशा है ये मदद करेगा।

Answer 14

आवश्यक आदेशों का एक त्वरित संदर्भ, क्योंकि मैं मूल रूप से जानता हूं कि क्या करना है लेकिन हमेशा सही सिंटैक्स भूल जाते हैं:

git rebase -i <sha1_before_split>
# mark the targeted commit with 'edit'
git reset HEAD^
git add ...
git commit -m "First part"
git add ...
git commit -m "Second part"
git rebase --continue

इमैनुएल बर्नार्ड के ब्लॉग पोस्ट का श्रेय ।