පෙර බැඳීමක් බහුවිධ කොමිස් වලට කඩා දමන්න

ශාඛාවක් නිර්මාණය නොකර නව ශාඛාවක් මත විනෝදජනක වැඩක් නොකර, දේශීය ගබඩාවට කැපවීමෙන් පසු එක් කැපවීමක් වෙනස් කොමිස් කිහිපයකට බෙදිය හැකිද?

git rebase -i ඒක කරයි.

පළමුව, පිරිසිදු වැඩ කරන නාමාවලියකින් ආරම්භ කරන්න: git statusඅපේක්ෂිත වෙනස් කිරීම්, මකාදැමීම් හෝ එකතු කිරීම් නොපෙන්විය යුතුය.

දැන්, ඔබ බෙදිය යුත්තේ කුමන බැඳීම්ද යන්න තීරණය කළ යුතුය.

අ) නවතම කැපවීම බෙදීම

ඔබගේ නවතම කැපවීම වෙන් කිරීමට, පළමුව:

$ git reset HEAD~

දැන් කෑලි සුපුරුදු ආකාරයට තනි තනිව කරන්න, ඔබට අවශ්‍ය තරම් කොමිස් ප්‍රමාණයක් නිෂ්පාදනය කරන්න.

ආ) බැඳීමක් තව දුරටත් බෙදීම

මේ සඳහා නැවත ප්‍රතිස්ථාපනය කිරීම , එනම් ඉතිහාසය නැවත ලිවීම අවශ්‍ය වේ . නිවැරදි කැපවීම සොයා ගැනීමට, ඔබට තේරීම් කිහිපයක් තිබේ:

• එය නැවත කොමිස් තුනක් නම්, එසේ නම්

  $ git rebase -i HEAD~3
  

  කොහේද 3එය කොපමණ ආපසු ගෙවිය යුතුද යන්න.

• ඔබට ගණන් කිරීමට අවශ්‍ය ප්‍රමාණයට වඩා එය ගසෙහි back තට දිව ගියේ නම්, එසේ නම්

  $ git rebase -i 123abcd~
  

  123abcdඔබට බෙදීමට අවශ්‍ය කැපවීමේ SHA1 කොහිද ?

• ඔබ මාස්ටර් සමඟ ඒකාබද්ධ වීමට අදහස් කරන වෙනත් ශාඛාවක (උදා: විශේෂාංග ශාඛාවක්) සිටී නම්:

  $ git rebase -i master
  

ඔබ නැවත සංස්කරණය කිරීමේ තිරය ලබා ගත් විට, ඔබට වෙන්වීමට අවශ්‍ය කැපවීම සොයා ගන්න. එම පේළියේ ආරම්භයේ දී ( කෙටියෙන්) ආදේශ pickකරන්න . බෆරය සුරකිමින් පිටවන්න. ඔබට සංස්කරණය කිරීමට අවශ්‍ය වූ කැපවීමෙන් පසුව නැවත ප්‍රතිස්ථාපනය නතර වේ. ඉන්පසු:edite

$ git reset HEAD~

කෑලි සුපුරුදු ආකාරයෙන් වෙන් කර, ඔබට අවශ්‍ය තරම් කොමිස් ප්‍රමාණයක් නිෂ්පාදනය කරන්න, එවිට

$ git rebase --continue

සිට GIT-rebase අත්පොත (ස්ප්ලිටිං පාපකාරී කොටස)

අන්තර්ක්‍රියාකාරී ප්‍රකාරයේදී, ඔබට "සංස්කරණය" ක්‍රියාව සමඟ බැඳීම් සලකුණු කළ හැකිය. කෙසේ වෙතත්, මෙම සංස්කරණයේ ප්‍රති result ලය හරියටම එක් කැපවීමක් වනු ඇතැයි git rebase අපේක්ෂා කරන බව මින් අදහස් නොවේ. ඇත්ත වශයෙන්ම, ඔබට බැඳීම අහෝසි කළ හැකිය, නැතහොත් ඔබට වෙනත් කොමිස් එකතු කළ හැකිය. බැඳීමක් දෙකට බෙදීමට මෙය භාවිතා කළ හැකිය:

• ඔබට බෙදීමට අවශ්‍ය කැපවීම git rebase -i <commit>^කොතැනද <commit>යන්න සමඟ අන්තර්ක්‍රියාකාරී ප්‍රතිමූර්තියක් ආරම්භ කරන්න . ඇත්ත වශයෙන්ම, ඕනෑම කැපවීමේ පරාසයක් එම බැඳීම අඩංගු වන තාක් කල් කරනු ඇත.

• "සංස්කරණය" ක්‍රියාව සමඟ ඔබට බෙදීමට අවශ්‍ය කැපවීම සලකුණු කරන්න.

• එම කැපවීම සංස්කරණය කිරීමේදී, ක්‍රියාත්මක කරන්න git reset HEAD^. මෙහි ප්‍රති is ලය වන්නේ HEAD එකකින් නැවත යථා තත්ත්වයට පත් වන අතර දර්ශකය ද අනුගමනය කරයි. කෙසේ වෙතත්, වැඩ කරන ගස එලෙසම පවතී.

• දැන් පළමු කැපවීමේදී ඔබට අවශ්‍ය දර්ශකයට වෙනස්කම් එක් කරන්න. එය කිරීමට ඔබට git add(සමහර විට අන්තර්ක්‍රියාකාරීව) හෝ git gui(හෝ දෙකම) භාවිතා කළ හැකිය .

• දැන් සුදුසු ඕනෑම පණිවිඩයක් සමඟ දැන් පවතින දර්ශකය කැප කරන්න.

• ඔබේ වැඩ කරන ගස පිරිසිදු වන තුරු අවසාන පියවර දෙක නැවත කරන්න.

• සමඟ නැවත ආරම්භ කිරීම දිගටම කරගෙන යන්න git rebase --continue.

භාවිතය 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

දැන් A ගොනුව මේ වගේ ය:

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 <roseperrone@fake.com>
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 <roseperrone@fake.com>
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 <roseperrone@fake.com>
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 <roseperrone@fake.com>
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

පෙර පිළිතුරු git rebase -iමඟින් ඔබට බෙදීමට අවශ්‍ය කැපවීම සංස්කරණය කිරීම සහ එය කොටස් වශයෙන් සිදු කිරීම ආවරණය කර ඇත.

ලිපිගොනු විවිධ කොමිස් වලට බෙදීමේදී මෙය හොඳින් ක්‍රියාත්මක වේ, නමුත් ඔබට එක් එක් ලිපිගොනු වල වෙනස්කම් වෙන් කිරීමට අවශ්‍ය නම්, ඔබ දැනගත යුතු තවත් බොහෝ දේ ඇත.

ඔබට බෙදීමට අවශ්‍ය කැපවීම, එය භාවිතා කිරීම rebase -iසහ සලකුණු කිරීම edit, ඔබට විකල්ප දෙකක් තිබේ.

1. භාවිතා කිරීමෙන් පසු git reset HEAD~, git add -pඑක් එක් කැපවීම තුළ ඔබට අවශ්‍ය අය තෝරා ගැනීමට තනි තනිව පැච් හරහා යන්න

2. ඔබට අවශ්‍ය නොවන වෙනස්කම් ඉවත් කිරීමට වැඩ කරන පිටපත සංස්කරණය කරන්න; එම අතුරු රාජ්‍යය කරන්න; ඉන්පසු ඊළඟ වටය සඳහා වූ සම්පූර්ණ කැපවීම ආපසු අදින්න.

ඒකාබද්ධයේ කොටසක් ලෙස අන්තර් සංස්කරණ නිසි ලෙස ගොඩනඟා ක්‍රියාත්මක වේදැයි පරීක්ෂා කිරීමට ඉඩ සලසන බැවින්, ඔබ විශාල කැපවීමක් කරන්නේ නම් විකල්ප 2 ප්‍රයෝජනවත් වේ. මෙය පහත පරිදි ඉදිරියට යයි.

කැපවීම භාවිතා කිරීමෙන් rebase -iහා භාවිතා කිරීමෙන් පසු භාවිතා editකරන්න

git reset --soft HEAD~

බැඳීම අහෝසි කිරීමට, නමුත් කැපවූ ලිපිගොනු දර්ශකයේ තබන්න. ඔබේ ආරම්භක කැපවීම කෙතරම් අවසාන ප්‍රති result ලයට ආසන්නද යන්න මත පදනම්ව --soft අතහැර දැමීමෙන් ඔබට මිශ්‍ර යළි පිහිටුවීමක් කළ හැකිය. එකම වෙනස වන්නේ ඔබ වේදිකාගත කරන ලද සියලුම වෙනස්කම් වලින් ආරම්භ කරනවාද නැත්නම් ඒවා සියල්ලම වේදිකාගත නොවන්නේද යන්නයි.

දැන් ඇතුළට ගොස් කේතය සංස්කරණය කරන්න. ඔබට වෙනස්කම් ඉවත් කිරීමට, එකතු කළ ලිපිගොනු මකා දැමීමට සහ ඔබ සොයන මාලාවේ පළමු කැපවීම ගොඩනැගීමට අවශ්‍ය ඕනෑම දෙයක් කළ හැකිය. ඔබට එය ගොඩනගා ගැනීමට, ක්‍රියාත්මක කිරීමට සහ ඔබට ස්ථිර ප්‍රභවයක් ඇති බව තහවුරු කළ හැකිය.

ඔබ සතුටු වූ පසු, අවශ්‍ය පරිදි ලිපිගොනු වේදිකා ගත කරන්න / ඉවත් කරන්න (මම මේ සඳහා භාවිතා කිරීමට කැමතියි git gui), සහ UI හෝ විධාන රේඛාව හරහා වෙනස්කම් සිදු කරන්න

git commit

පළමු කැපවීම එයයි. දැන් ඔබට අවශ්‍ය වන්නේ ඔබගේ වැඩ කිරීමේ පිටපත ඔබ බෙදී ගිය පසු එය තිබූ තත්වයට යථා තත්වයට පත් කිරීමට ය, එවිට ඔබේ ඊළඟ කැපවීම සඳහා තවත් වෙනස්කම් කළ හැකිය. ඔබ සංස්කරණය කරන කැපවීමේ sha1 සොයා ගැනීමට, භාවිතා කරන්න git status. තත්වයේ පළමු පේළි කිහිපය තුළ, දැනට ක්‍රියාත්මක වන rebase විධානය ඔබට පෙනෙනු ඇත, එමඟින් ඔබේ මුල් බැඳීමේ 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

නැවත ගෙවීමේ ක්‍රියාවලිය ඉදිරියට ගෙන යනු ඇත.

git rebase --interactiveබැඳීමක් කුඩා කොමිස් වලට බෙදීමට භාවිතා කළ හැකිය. මෙම rebase මත Git ලේඛන ක්රියාවලිය පිළිබඳ සංක්ෂිප්ත අයික්මාන්ය ඇති - බෙදීම පාපකාරී :

අන්තර්ක්‍රියාකාරී ප්‍රකාරයේදී, ඔබට "සංස්කරණය" ක්‍රියාව සමඟ බැඳීම් සලකුණු කළ හැකිය. කෙසේ වෙතත්, මෙම git rebaseසංස්කරණයේ ප්‍රති result ලය හරියටම එක් කැපවීමක් අපේක්ෂා කරන බව මින් අදහස් නොවේ . ඇත්ත වශයෙන්ම, ඔබට බැඳීම අහෝසි කළ හැකිය, නැතහොත් ඔබට වෙනත් කොමිස් එකතු කළ හැකිය. බැඳීමක් දෙකට බෙදීමට මෙය භාවිතා කළ හැකිය:

• ඔබට බෙදීමට අවශ්‍ය කැපවීම git rebase -i <commit>^කොතැනද <commit>යන්න සමඟ අන්තර්ක්‍රියාකාරී ප්‍රතිමූර්තියක් ආරම්භ කරන්න . ඇත්ත වශයෙන්ම, ඕනෑම කැපවීමේ පරාසයක් එම බැඳීම අඩංගු වන තාක් කල් කරනු ඇත.

• "සංස්කරණය" ක්‍රියාව සමඟ ඔබට බෙදීමට අවශ්‍ය කැපවීම සලකුණු කරන්න.

• එම කැපවීම සංස්කරණය කිරීමේදී, ක්‍රියාත්මක කරන්න git reset HEAD^. මෙහි ප්‍රති is ලය වන්නේ HEAD එකකින් නැවත යථා තත්ත්වයට පත් වන අතර දර්ශකය ද අනුගමනය කරයි. කෙසේ වෙතත්, වැඩ කරන ගස එලෙසම පවතී.

• දැන් පළමු කැපවීමේදී ඔබට අවශ්‍ය දර්ශකයට වෙනස්කම් එක් කරන්න. ඒ සඳහා ඔබට git add(සමහර විට අන්තර්ක්‍රියාකාරී) හෝ git gui (හෝ දෙකම) භාවිතා කළ හැකිය.

• දැන් සුදුසු ඕනෑම පණිවිඩයක් සමඟ දැන් පවතින දර්ශකය කැප කරන්න.

• ඔබේ වැඩ කරන ගස පිරිසිදු වන තුරු අවසාන පියවර දෙක නැවත කරන්න.

• සමඟ නැවත ආරම්භ කිරීම දිගටම කරගෙන යන්න git rebase --continue.

අතරමැදි සංශෝධන අනුකූල බව ඔබට නිශ්චිතවම විශ්වාස නැත්නම් (ඒවා සම්පාදනය කිරීම, ටෙස්ට් සූට් සමත් වීම යනාදිය) ඔබ කළ යුත්තේ git stashඑක් එක් කැපවීම, පරීක්‍ෂණය සහ බැඳීම් සංශෝධනය කිරීමෙන් පසුව තවමත් සිදු නොවූ වෙනස්කම් ඉවත් කිරීමට ය. .

දැන් වින්ඩෝස් හි නවතම ඉබ්බා ගිට් හි ඔබට එය ඉතා පහසුවෙන් කළ හැකිය.

නැවත සැකසීමේ සංවාදය විවෘත කර එය වින්‍යාස කර පහත පියවරයන් කරන්න.

• ඔබට බෙදීමට අවශ්‍ය කැපවීම දකුණු-ක්ලික් කර තෝරන්න "Edit " (පික්, ස්කොෂ්, මකන්න ...).
• "ක්ලික් කරන්න"Startනැවත ආරම්භ කිරීම ආරම්භ කිරීමට " .
• බෙදීමට ඇති බැඳීමට එය පැමිණි පසු, " Edit/Split" බොත්තම පරීක්ෂා කර Amendකෙලින්ම " " ක්ලික් කරන්න . බැඳීම් සංවාදය විවෘත වේ.
  
• ඔබට වෙනම කැපවීමක් කිරීමට අවශ්‍ය ගොනු තෝරා නොගන්න.
• බැඳීම් පණිවිඩය සංස්කරණය කරන්න, ඉන්පසු " commit" ක්ලික් කරන්න .
• කැපවීමට ලිපිගොනු ලැබෙන තුරු, බැඳීම් සංවාදය නැවත නැවතත් විවෘත වේ. කැපවීමට තවත් ගොනුවක් නොමැති විට, ඔබට තවත් එක් බැඳීමක් එකතු කිරීමට අවශ්‍ය දැයි එය තවමත් ඔබෙන් අසනු ඇත.

ඉතා ප්‍රයෝජනවත්, ස්තූතියි ඉබ්බා ගිට්!

ඔබට අන්තර්ක්‍රියාකාරී ප්‍රතිප්‍රහාරයක් කළ හැකිය git rebase -i . මෑන් පිටුවට ඔබට අවශ්‍ය දේ හරියටම තිබේ:

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

කරුණාකර සටහන් කර ගන්න git reset --soft HEAD^. එය සමාන git reset(පෙරනිමිය --mixed) නමුත් එය දර්ශක අන්තර්ගතය රඳවා ගනී. එබැවින් ඔබ ලිපිගොනු එකතු කර / ඉවත් කර ඇත්නම්, ඒවා දැනටමත් දර්ශකයේ ඇත.

යෝධ කොමිස් වලදී ඉතා ප්‍රයෝජනවත් වේ.

IntelliJ IDEA , PyCharm , PhpStorm යනාදී එක් බැඳීමක් බෙදන්නේ කෙසේද යන්න මෙන්න

1. අනුවාද පාලක ලොග් කවුළුව තුළ, ඔබ බෙදීමට කැමති බැඳීම තෝරන්න, දකුණු ක්ලික් කර තෝරන්න Interactively Rebase from Here

2. ඔබට බෙදීමට අවශ්‍ය එකක් ලෙස සලකුණු editකරන්න, ක්ලික් කරන්නStart Rebasing

3. කහ පැහැති ටැගයක් තබා ඇති බව ඔබ දැක ගත යුතුය. එම කැපවීම මත දකුණු ක්ලික් කරන්න, තෝරන්නUndo Commit

4. දැන් එම කොමිස් නැවත වේදිකා ගත වන ස්ථානයට පැමිණ ඇත, එවිට ඔබට ඒවා වෙන වෙනම කළ හැකිය. සියලු වෙනස්කම් සිදු කිරීමෙන් පසුව, පැරණි කැපවීම අක්‍රිය වේ.

අන්තර්ක්‍රියාකාරී ප්‍රතිප්‍රහාරයකින් තොරව කළ හැකි පහසුම දෙය නම් (බොහෝ විට) ඔබට බෙදීමට අවශ්‍ය බැඳීමට පෙර නව ශාඛාවක් සෑදීම, චෙරි-පික්-කැපවීම, යළි පිහිටුවීම, ගබඩා කිරීම, ලිපිගොනු ගෙනයාම, තොගය නැවත අයදුම් කිරීම සහ වෙනස්කම් සිදු කරන්න, ඉන්පසු එක්කෝ කලින් ශාඛාව සමඟ ඒකාබද්ධ කරන්න හෝ පසුව සිදු කළ කොමිස් චෙරි තෝරා ගන්න. (ඉන්පසු කලින් ශාඛාවේ නම වත්මන් හිසට මාරු කරන්න.) (MBOs උපදෙස් පිළිපැදීම හා අන්තර්ක්‍රියාකාරී ප්‍රතිප්‍රහාරයක් කිරීම වඩා හොඳය.)

මම හිතන්නේ මම භාවිතා කරන හොඳම ක්‍රමය git rebase -iඑයයි. බැඳීමක් බෙදීමේ පියවර පෙන්වීමට මම වීඩියෝවක් නිර්මාණය කළෙමි: https://www.youtube.com/watch?v=3EzOz7e1ADI

අවශ්‍ය විධානයන් පිළිබඳ ඉක්මන් සඳහනක්, මන්ද මා මූලික වශයෙන් කුමක් කළ යුතු දැයි දන්නා නමුත් නිවැරදි වාක්‍ය ඛණ්ඩය සැමවිටම අමතක කරයි:

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

එම්මානුවෙල් බර්නාඩ්ගේ බ්ලොග් සටහනට බැර කිරීම් .

ඔබට මෙය තිබේ නම්:

A - B <- mybranch

B හි ඔබ යම් අන්තර්ගතයක් කර ඇති තැන:

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

නමුත් ඔබට B - C - D ලෙස බෙදීමට අවශ්‍ය වන අතර මෙම ප්‍රති result ලය ලබා ගන්න:

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"

එය වසර 8 කට වඩා වැඩි කාලයක් ගතවී ඇත, නමුත් සමහර විට යමෙකුට එය කෙසේ හෝ ප්‍රයෝජනවත් වේවි. මට උපක්‍රමය නොමැතිව කළ හැකි විය rebase -i. අදහස නම්, ඔබ කළ පෙර පැවති තත්වයටම git යොමු කිරීමයි 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:අතර ඔබේ ගබඩාව ඔබ මෙම ලිපිගොනු සියල්ලම කිරීමට සූදානම්ව සිටින තත්වයක පවතී. මෙතැන් සිට ඔබ සාමාන්‍යයෙන් මෙන් නැවත පහසුවෙන් එය කළ හැකිය. එය උපකාරී වේ යැයි සිතමි.