මගේ අන්තිම X එක Git භාවිතා කරමින් එක කැපවීමකට සම්බන්ධ කරන්නේ කෙසේද?

අත්පොතේgit rebase -i <after-this-commit> විස්තර කර ඇති පරිදි දෙවන හා පසුව සිදුකරන "ස්කොෂ්" හෝ "සවි කිරීම" සමඟ "පික්" භාවිතා කර ප්‍රතිස්ථාපනය කරන්න .

මෙම උදාහරණයේ දී, <after-this-commit>SHA1 හැෂ් හෝ වත්මන් ශාඛාවේ HEAD වෙතින් සාපේක්ෂ පිහිටීම වේ. උදාහරණයක් ලෙස, අතීතයේ දී වර්තමාන HEAD වෙතින් කොමිට් 5 ක් බැලීමට පරිශීලකයා කැමති නම්, විධානය වේ git rebase -i HEAD~5.

ඔබට මෙය නොමැතිව git rebaseහෝ පහසුවෙන් කළ හැකිය git merge --squash. මෙම උදාහරණයේ දී, අපි අවසාන කොමිස් 3 ස්කොෂ් කරමු.

ඔබට මුල සිටම නව බැඳීම් පණිවිඩය ලිවීමට අවශ්‍ය නම්, මෙය ප්‍රමාණවත් වේ:

git reset --soft HEAD~3 &&
git commit

පවත්නා බැඳීම් පණිවිඩ සමඟ සංක්ෂිප්තව නව බැඳීම් පණිවිඩය සංස්කරණය කිරීම ආරම්භ කිරීමට ඔබට අවශ්‍ය නම් (එනම් පික් / ස්කොෂ් / ස්කොෂ් /… / ස්කොෂ් git rebase -iඋපදෙස් ලැයිස්තුවෙන් ඔබ ආරම්භ කරන දෙයට සමාන වේ ), එවිට ඔබට එම පණිවිඩ උපුටා ගෙන සමත් විය යුතුය. ඔවුන් වෙත git commit:

git reset --soft HEAD~3 && 
git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"

මෙම ක්‍රම දෙකම අන්තිම බැඳීම් තුනම එකම ආකාරයකින් නව අළුත් බැඳීමක් බවට පත් කරයි. මෘදු යළි පිහිටුවීම ඔබට ස්කොෂ් කිරීමට අවශ්‍ය නැති අවසාන කැපවීමට HEAD යලි යොමු කරයි. මෘදු යළි පිහිටුවීම මඟින් දර්ශකය හෝ වැඩ කරන ගස ස්පර්ශ නොකෙරෙන අතර, ඔබගේ නව කැපවීම සඳහා දර්ශකය අපේක්ෂිත තත්වයේ තබයි (එනම්, ඔබ දැනටමත් "ඉවත දැමීමට" යන කොමිස් වලින් සියලු වෙනස්කම් දැනටමත් ඇත).

ඔබට git merge --squashමේ සඳහා භාවිතා කළ හැකිය , එය වඩා තරමක් අලංකාරයි git rebase -i. ඔබ ස්වාමියා යැයි සිතමු, ඔබට අවසාන කොමිස් 12 එකකට දැමිය යුතුය.

අවවාදයයි: පළමුව ඔබ ඔබේ කාර්යය ඉටු කරන බවට වග බලා ගන්න git statusclean පිරිසිදු බව පරීක්ෂා කරන්න ( git reset --hardවේදිකාගත කර ඇති සහ වේදිකාගත නොවූ වෙනස්කම් ඉවත දමනු ඇත)

ඉන්පසු:

# Reset the current branch to the commit just before the last 12:
git reset --hard HEAD~12

# HEAD@{1} is where the branch was just before the previous command.
# This command sets the state of the index to be as it would just
# after a merge from that commit:
git merge --squash HEAD@{1}

# Commit those squashed changes.  The commit message will be helpfully
# prepopulated with the commit messages of all the squashed commits:
git commit

මෙම සඳහා ලේඛගතකිරීමgit merge විස්තර කරන --squashවඩාත් විස්තර විකල්පය.

යාවත්කාලීන කිරීම:git reset --soft HEAD~12 && git commit ක්‍රිස් ජොන්සන් විසින් ඔහුගේ පිළිතුරෙන් යෝජනා කර ඇති සරල ක්‍රමයට වඩා මෙම ක්‍රමයේ ඇති එකම සැබෑ වාසිය නම්, ඔබ කොටු කරන සෑම කැපවීමේ පණිවිඩයක් සමඟම සූදානම් කළ බැඳීම් පණිවිඩය ඔබට ලැබීමයි.

git resetහැකි සෑම විටම වළක්වා ගැනීමට මම නිර්දේශ කරමි - විශේෂයෙන් Git-novices සඳහා. කොමිස් ගණනාවක් මත පදනම්ව ක්‍රියාවලියක් ස්වයංක්‍රීය කිරීමට ඔබට අවශ්‍ය නොවන්නේ නම්, අඩු විදේශීය ක්‍රමයක් ඇත ...

1. වැඩ කළ යුතු ශාඛාවක් මත කළ යුතු දේ කරන්න (ඒවා දැනටමත් නොමැති නම්) - මේ සඳහා gitk භාවිතා කරන්න
2. ඉලක්ක ශාඛාව පරීක්ෂා කරන්න (උදා: 'මාස්ටර්')
3. git merge --squash (working branch name)
4. git commit

බැඳීම් පණිවිඩය ස්කොෂ් මත පදනම්ව සකස් කරනු ලැබේ.

ක්‍රිස් ජොන්සන්ගේ පිළිතුර මත පදනම්ව ,

බාෂ් වෙතින් ගෝලීය "ස්කොෂ්" අන්වර්ථයක් එක් කරන්න: (හෝ වින්ඩෝස් හි Git Bash)

git config --global alias.squash '!f(){ git reset --soft HEAD~${1} && git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"; };f'

... හෝ වින්ඩෝස් විධාන විමසුම භාවිතා කිරීම:

git config --global alias.squash "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

ඔබ ~/.gitconfigදැන් මෙම අන්වර්ථය අඩංගු විය යුතුය:

[alias]
    squash = "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

භාවිතය:

git squash N

... ස්වයංක්‍රීයව අන්තිමයන් එකට එකතු කරයි N ඇතුලත්, කරයි.

සටහන: ප්‍රති result ල වශයෙන් බැඳීමේ පණිවිඩය අනුපිළිවෙලින් සියලු වර්ගීකරණය කරන ලද කොමිස් වල එකතුවකි. ඔබ ඒ ගැන නොසතුටින් සිටී නම්, ඔබට එය සැමවිටම git commit --amendඅතින් වෙනස් කළ හැකිය . (නැතහොත්, ඔබේ රුචිකත්වයට ගැලපෙන ලෙස අන්වර්ථය සංස්කරණය කරන්න.)

මෙම හුරුබුහුටි බ්ලොග් සටහනට ස්තූතියි, ඔබට මෙම විධානය භාවිතා කර අවසාන කොමිස් 3 ස්කොෂ් කිරීමට හැකි බව මට පෙනී ගියේය:

git rebase -i HEAD~3

ඔබ ලුහුබැඳීමේ තොරතුරු / දුරස්ථ ගබඩාවක් නොමැති ප්‍රාදේශීය ශාඛාවක සිටියදී පවා මෙය ක්‍රියාත්මක වන බැවින් මෙය පහසුය.

විධානය මඟින් අන්තර්ක්‍රියාකාරී නැවත සැකසුම් සංස්කාරකය විවෘත කරනු ඇති අතර එමඟින් සාමාන්‍ය පරිදි නැවත සකස් කිරීමට, ස්කොෂ් කිරීමට, නැවත සැකසීමට ඉඩ දේ.

අන්තර්ක්‍රියාකාරී නැවත සැකසුම් සංස්කාරකය භාවිතා කිරීම:

අන්තර්ක්‍රියාකාරී ප්‍රතිස්ථාපන සංස්කාරකය අවසාන කොමිස් තුන පෙන්වයි. මෙම සීමාව තීරණය කරනු HEAD~3ලැබුවේ විධානය ක්‍රියාත්මක කිරීමේදී ය git rebase -i HEAD~3.

නවතම කැපවීම, HEADපළමුවන පේළියේ දර්ශනය වේ. A #වලින් ආරම්භ වන රේඛා අදහස් / ලේඛන වේ.

පෙන්වන ලියකියවිලි ඉතා පැහැදිලිය. ඕනෑම රේඛාවක ඔබට pickවිධානය ඔබේ අභිමතය පරිදි වෙනස් කළ හැකිය .

මම විධානය භාවිතා කිරීමට කැමතියි fixupඉහත රේඛාවෙහි ඇති බැඳීමෙහි කැපවීම වෙනස් කරන අතර බැඳීමේ පණිවිඩය බැහැර කරන බැවින් කිරීමට කැමැත්තෙමි.

1 වන පේළියේ ඇති බැඳීම ලෙස HEAD, බොහෝ අවස්ථාවන්හිදී ඔබ මෙය අත්හරිනු ඇත pick. ඔබට භාවිතා කළ නොහැක squashහෝ fixupවෙනත් බැඳීමක් නොමැති නිසා.

ඔබට කොමිස් අනුපිළිවෙලද වෙනස් කළ හැකිය. මෙය කාලානුක්‍රමිකව යාබද නොවන ස්කොෂ් හෝ සවි කිරීම් සිදු කිරීමට ඔබට ඉඩ සලසයි.

ප්‍රායෝගික එදිනෙදා උදාහරණයක්

මම මෑතකදී නව අංගයක් කර ඇත. එතැන් සිට, මම දෝෂ නිවැරදි කිරීම් දෙකක් කර ඇත. නමුත් දැන් මම කළ නව අංගයේ දෝෂයක් (හෝ අක්ෂර වින්‍යාස දෝෂයක්) සොයාගෙන ඇත. කෙතරම් කරදරකාරීද! මගේ කැපවීමේ ඉතිහාසය දූෂණය කරන නව බැඳීමක් මට අවශ්‍ය නැත!

මම කරන පළමු දෙය නම් වැරැද්ද නිවැරදි කර අදහස් දැක්වීම සමඟ නව බැඳීමක් ඇති කිරීමයි squash this into my new feature! .

මම පසුව ධාවනය කර git logහෝ gitkනව අංගයේ SHA ලබා ගනිමි (මේ අවස්ථාවේ දී 1ff9460).

ඊළඟට, මම සමඟ අන්තර්ක්‍රියාකාරී නැවත සැකසුම් සංස්කාරකය ගෙන එන්නෙමි git rebase -i 1ff9460~. මෙම ~එම සිදු ෂා පසුව සංස්කාරකයේ සිදු ඇතුළත් කිරීමට කර්තෘ කියයි.

ඊළඟට, මම දෝෂ නිවැරදි අඩංගු (සිදු චලනය fe7f1e0) සිදු විශේෂාංගය යට, සහ වෙනස් කිරීම pickසඳහාfixup .

සංස්කාරකය වසා දමන විට, නිවැරදි කිරීම විශේෂාංගයේ කැපවීම හා මගේ කැපවීමේ ඉතිහාසය ලස්සන හා පිරිසිදු ලෙස පෙනෙනු ඇත!

සියලුම කොමිස් දේශීය වූ විට මෙය හොඳින් ක්‍රියාත්මක වේ, නමුත් ඔබ දැනටමත් දුරස්ථයට තල්ලු කර ඇති ඕනෑම කොමිස් වෙනස් කිරීමට උත්සාහ කරන්නේ නම්, එකම ශාඛාව පරීක්ෂා කර ඇති අනෙකුත් ඩෙව්වරුන්ට ඔබට සැබවින්ම ගැටළු ඇති කළ හැකිය!

ඔබ TortoiseGit භාවිතා කරන්නේ නම්, ඔබට ශ්‍රිතය කළ හැකිය Combine to one commit:

1. TortoiseGit සන්දර්භය මෙනුව විවෘත කරන්න
2. තෝරන්න Show Log
3. ලොග් දර්ශනයේ අදාළ කොමිස් සලකුණු කරන්න
4. Combine to one commitසන්දර්භය මෙනුවෙන් තෝරන්න

මෙම ශ්‍රිතය අවශ්‍ය සියලුම තනි පියවර පියවර ස්වයංක්‍රීයව ක්‍රියාත්මක කරයි. අවාසනාවට වින්ඩෝස් සඳහා පමණි.

මෙය සිදු කිරීම සඳහා ඔබට පහත දැක්වෙන git විධානය භාවිතා කළ හැකිය.

 git rebase -i HEAD~n

n (= 4 මෙහි) යනු අවසාන කැපවීමේ සංඛ්‍යාවයි. එවිට ඔබට පහත විකල්ප ඇත,

pick 01d1124 Message....
pick 6340aaa Message....
pick ebfd367 Message....
pick 30e0ccb Message....

pickඑක් කැපවීමකට පහළින් සහ squashඅනෙක් ඒවා නවතම ඒවාට යාවත්කාලීන කරන්න ,

p 01d1124 Message....
s 6340aaa Message....
s ebfd367 Message....
s 30e0ccb Message....

වැඩි විස්තර සඳහා සබැඳිය ක්ලික් කරන්න

මෙම ලිපිය මත පදනම්ව මෙම ක්‍රමය මගේ භාවිතයට පහසු බව මට පෙනී ගියේය.

මගේ 'දේව්' ශාඛාව කොමිට් 96 කින් 'සම්භවය / දේව්' ට වඩා ඉදිරියෙන් සිටියි (එබැවින් මෙම කොමිස් තවමත් දුරස්ථයට තල්ලු කර නැත).

වෙනස තල්ලු කිරීමට පෙර මෙම බැඳීම් එකකට බෙදීමට මට අවශ්‍ය විය. ශාඛාව 'සම්භවය / දේව්' තත්වයට යලි පිහිටුවීමට මම කැමැත්තෙමි (මෙය 96 කමිටු 96 හි සියලු වෙනස්කම් අස්ථිර වනු ඇත) ඉන්පසු වෙනස්කම් එකවර සිදු කරයි:

git reset origin/dev
git add --all
git commit -m 'my commit message'

ශාඛාව තුළ ඔබ කොමිස් ඒකාබද්ධ කිරීමට කැමති, ධාවනය කරන්න:

git rebase -i HEAD~(n number of commits back to review)

උදාහරණයක්:

git rebase -i HEAD~1

මෙය පෙළ සංස්කාරකය විවෘත කරනු ඇති අතර, මෙම බැඳීම් එකට ඒකාබද්ධ කිරීමට ඔබ කැමති නම්, ඔබ එක් එක් බැඳීම ඉදිරිපිට 'ස්කොෂ්' සමඟ 'පික්' මාරු කළ යුතුය. ප්‍රලේඛනයෙන්:

p, pick = use commit

s, squash = use commit, නමුත් පෙර කැපවීමට ඒකාබද්ධ කරන්න

නිදසුනක් ලෙස, ඔබ සියලු කොමිස් එකකට ඒකාබද්ධ කිරීමට බලාපොරොත්තු වන්නේ නම්, 'පික්' යනු ඔබ කළ පළමු කැපවීම වන අතර අනාගත සියලු දේ (පළමුවැන්නාට පහළින් තබා) 'ස්කොෂ්' ලෙස සැකසිය යුතුය. Vim භාවිතා කරන්නේ නම්, භාවිතා කරන්න : x සංස්කාරකය සුරැකීමට සහ පිටවීමට ඇතුළු කිරීමේ ප්‍රකාරයේදී කරන්න.

ප්‍රතිප්‍රහාරය දිගටම කරගෙන යාමට:

git rebase --continue

මේ පිළිබඳ වැඩි විස්තර සහ ඔබගේ බැඳීම් ඉතිහාසය නැවත ලිවීමට වෙනත් ක්‍රම සඳහා මෙම ප්‍රයෝජනවත් ලිපිය බලන්න

Anomies පිළිතුර හොඳයි, නමුත් මට මේ ගැන අනාරක්ෂිත බවක් දැනුණා, ඒ නිසා මම තිරපිටපත් කිහිපයක් එකතු කිරීමට තීරණය කළා.

පියවර 0: git log

ඔබ සිටින්නේ කොහේදැයි බලන්න git log. වැදගත්ම දෙය නම්, ඔබට ස්කොෂ් කිරීමට අවශ්‍ය නැති පළමු කැපවීමේ හෑෂ් සොයා ගන්න . එබැවින්:

පියවර 1: git rebase

git rebase -i [your hash]මගේ නඩුවේ ක්‍රියාත්මක කරන්න :

$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d

පියවර 2: ඔබට අවශ්‍ය දේ තෝරන්න / ස්කොෂ් කරන්න

මගේ නඩුවේදී, මට අවශ්‍ය වන්නේ පළමු වරට කළ කැපවීම මත සියල්ල ස්කොෂ් කිරීමට ය. ඇණවුම මුල සිට අග දක්වා වේ, එබැවින් හරියටම අනෙක් ආකාරයට git log. මගේ නඩුවේ, මට අවශ්යයි:

පියවර 3: පණිවිඩය (ය) සකසන්න

ඔබ එක් කැපවීමක් පමණක් තෝරාගෙන ඉතිරි කොටස කොටු කර ඇත්නම්, ඔබට එක් කැපවීමේ පණිවිඩයක් සකස් කළ හැකිය:

ඒක තමයි. ඔබ මෙය ( :wq) සුරකින ලද පසු , ඔබ අවසන්. ඒ දෙස බලන්න git log.

ක්රියා පටිපාටිය 1

1) කැපවූ කෙටි හැෂ් හඳුනා ගන්න

# git log --pretty=oneline --abbrev-commit
abcd1234 Update to Fix for issue B
cdababcd Fix issue B
deab3412 Fix issue A
....

මෙතන පවා git log --onelineද කෙටි හැෂ් ලබා ගැනීමට භාවිතා කළ හැක.

2) ඔබට ස්කොෂ් කිරීමට අවශ්‍ය නම් (ඒකාබද්ධ කිරීම) අවසාන කැපවීම දෙක

# git rebase -i deab3412 

3) මෙය nanoඒකාබද්ධ කිරීම සඳහා සංස්කාරකයක් විවෘත කරයි . එය පහතින් පෙනේ

....
pick cdababcd Fix issue B
pick abcd1234 Update to Fix for issue B
....

4) පෙර ඇති වචනය pickනැවත squashනම් කරන්න abcd1234. නැවත නම් කිරීමෙන් පසු එය පහත පරිදි විය යුතුය.

....
pick cdababcd Fix issue B
squash abcd1234 Update to Fix for issue B
....

5) දැන් nanoසංස්කාරකය සුරකින්න සහ වසා දමන්න. මාධ්ය ctrl + oහා මුද්රිත මාධ්ය Enterබේරා ගැනීමට. ඉන්පසු ctrl + xසංස්කාරකයෙන් පිටවීමට ඔබන්න .

6) පසුව nanoඅදහස් යාවත්කාලීන කිරීම සඳහා සංස්කාරකය නැවත විවෘත කරයි, අවශ්‍ය නම් එය යාවත්කාලීන කරන්න.

7) දැන් එය සාර්ථකව කොටු වී ඇත, ඔබට ලොග් පරීක්ෂා කිරීමෙන් එය සත්‍යාපනය කළ හැකිය.

# git log --pretty=oneline --abbrev-commit
1122abcd Fix issue B
deab3412 Fix issue A
....

8) දැන් repo වෙත තල්ලු කරන්න. +ශාඛා නාමයට පෙර ලකුණක් එක් කිරීමට සටහන . මෙයින් අදහස් කරන්නේ බලෙන් තල්ලු කිරීමයි.

# git push origin +master

සටහන: මෙය පදනම් වී ඇත්තේ ubuntuෂෙල් මත git භාවිතා කිරීම මත ය . ඔබ විවිධ os ( Windowsහෝ Mac) භාවිතා කරන්නේ නම් ඉහත විධානයන් සංස්කාරකය හැර සමාන වේ. ඔබට වෙනස් සංස්කාරකයක් ලැබෙනු ඇත.

ක්රියා පටිපාටිය 2

1. කැපවීම සඳහා අවශ්‍ය ගොනු පළමුව එක් කරන්න

git add <files>

2. ඉන්පසු --fixupවිකල්පය භාවිතා කරමින් කැපවීම සහ මෙම OLDCOMMITබැඳීම ඒකාබද්ධ කිරීමට (ස්කොෂ්) අවශ්‍ය විය යුතුය.

git commit --fixup=OLDCOMMIT

දැන් මෙය HEAD සමඟ නව බැඳීමක් ඇති කරයි fixup1 <OLDCOMMIT_MSG>.

3. ඉන්පසු පහත දැක්වෙන විධානය ක්‍රියාත්මක කිරීම සඳහා ඒකාබද්ධ කිරීම (ස්කොෂ්) OLDCOMMIT.

git rebase --interactive --autosquash OLDCOMMIT^

මෙහි ^අර්ථය වන්නේ පෙර කළ කැපවීමයි OLDCOMMIT. මෙම rebaseවිධානය සංස්කාරකයක (vim හෝ නැනෝ) අන්තර්ක්‍රියාකාරී කවුළුවක් විවෘත කරයි, අපට කිසිවක් කිරීමට අවශ්‍ය නොවන අතර ඉතිරි කිරීම සහ පිටවීම ප්‍රමාණවත් වේ. මක්නිසාද යත්, මේ සඳහා ලබා දී ඇති විකල්පය ස්වයංක්‍රීයව නවතම බැඳීම පැරණි බැඳීමට යාබදව ගෙන යන අතර ක්‍රියාකාරිත්වය වෙනස් කරයිfixup (ස්කොෂ් වලට සමාන) . ඉන්පසු නැවත ගෙවීම දිගටම කරගෙන යයි.

ක්රියා පටිපාටිය 3

1. අන්තිම කැපවීමේ ක්‍රමයට නව වෙනස්කම් එක් කිරීමට අවශ්‍ය නම් --amendභාවිතා කළ හැකිය git-commit.

    # git log --pretty=oneline --abbrev-commit
    cdababcd Fix issue B
    deab3412 Fix issue A
    ....
    # git add <files> # New changes
    # git commit --amend
    # git log --pretty=oneline --abbrev-commit
    1d4ab2e1 Fix issue B
    deab3412 Fix issue A
    ....  

මෙන්න --amendනව වෙනස්කම් අන්තිම බැඳීමට ඒකාබද්ධ කර නව බැඳීම් cdababcdහැඳුනුම්පතක් ජනනය කරයි1d4ab2e1

නිගමනය

• 1 වන ක්‍රියා පටිපාටියේ වාසිය නම් බහු කොමිස් ස්කොෂ් කිරීම සහ නැවත සකස් කිරීමයි. නමුත් ඉතා පැරණි බැඳීමකට විසඳුමක් ඒකාබද්ධ කිරීමට අවශ්‍ය නම් මෙම ක්‍රියා පටිපාටිය දුෂ්කර වනු ඇත.
• එබැවින් 2 වන ක්‍රියා පටිපාටිය ඉතා පැරණි බැඳීමකට ඇති බැඳීම පහසුවෙන් ඒකාබද්ධ කිරීමට උපකාරී වේ.
• අවසාන ක්‍රියාමාර්ගය සඳහා නව වෙනස්කම් ස්කොෂ් කිරීමට 3 වන ක්‍රියා පටිපාටිය ප්‍රයෝජනවත් වේ.

අන්තිම කොමිස් 10 තනි කැපවීමකට බෙදීමට:

git reset --soft HEAD~10 && git commit -m "squashed commit"

ඔබට දුරස්ථ ශාඛාව ස්කොෂ් කැපවීම සමඟ යාවත්කාලීන කිරීමට අවශ්‍ය නම්:

git push -f

ඔබ feature-branchරන් ගබඩාවක ( golden_repo_name) ක්ලෝන කරන ලද දුරස්ථ ශාඛාවක (කැඳවනු ලැබේ ) නම්, එවිට ඔබගේ කැපවීම් එකකට බෙදීමේ තාක්ෂණය මෙන්න:

1. රන් ගබඩාව පරීක්ෂා කරන්න

   git checkout golden_repo_name
   

2. එයින් නව ශාඛාවක් සාදන්න (ගෝල්ඩන් රෙපෝ) පහත පරිදි වේ

   git checkout -b dev-branch
   

3. ස්කොෂ් ඔබ දැනටමත් ඇති ඔබේ ප්‍රාදේශීය ශාඛාව සමඟ ඒකාබද්ධ කරන්න

   git merge --squash feature-branch
   

4. ඔබගේ වෙනස්කම් සිදු කරන්න (dev ශාඛාවේ ඇති එකම කැපවීම මෙය වනු ඇත)

   git commit -m "My feature complete"
   

5. ඔබේ දේශීය ගබඩාවට ශාඛාව තල්ලු කරන්න

   git push origin dev-branch
   

සැබවින්ම පහසු විය හැකි දේ:
ඔබට ඉහළින් ස්කොෂ් කිරීමට අවශ්‍ය කැපවීමේ හැෂ් සොයා ගන්න, කියන්න d43e15.

දැන් භාවිතා කරන්න

git reset d43e15
git commit -am 'new commit name'

2020 නැවත සකස් කිරීමකින් තොරව සරල විසඳුම:

git reset --soft HEAD~2

git commit -m "new commit message"

git push --force

2 යන්නෙන් අදහස් කරන්නේ අවසාන කොමිස් දෙක කොටු කරනු ඇති බවයි. ඔබට එය ඕනෑම අංකයකින් ප්‍රතිස්ථාපනය කළ හැකිය

මෙය සුපිරි ඩුපර් ක්ලඩ්ජි, නමුත් එක්තරා ආකාරයක සිසිල් ආකාරයකින්, එබැවින් මම එය වළල්ලට විසි කරන්නෙමි:

GIT_EDITOR='f() { if [ "$(basename $1)" = "git-rebase-todo" ]; then sed -i "2,\$s/pick/squash/" $1; else vim $1; fi }; f' git rebase -i foo~5 foo

පරිවර්තනය: git සඳහා නව "සංස්කාරකයක්" ලබා දෙන්න, එය සංස්කරණය කළ යුතු ගොනු නාමය නම් git-rebase-todo(අන්තර්ක්‍රියාකාරී ප්‍රතිස්ථාපන විමසුම) පළමු "තේරීම" හැර "ස්කොෂ්" ලෙස සියල්ල වෙනස් කරයි, එසේ නොමැතිනම් විම් හට ගනී - එවිට ඔබෙන් විමසනු ඇත ස්කොෂ් කළ කැපවීමේ පණිවිඩය සංස්කරණය කිරීමට, ඔබට විකාරයක් ලැබේ. .

මාක් ලොන්ගෙයාර් යෝජනා කළ දේ මම බොහෝ විට කරන්නෙමි .

සෑම කැපවීමක්ම තනි කැපවීමකට ලක් කිරීමට ඔබට අවශ්‍ය නම් (උදා: පළමු වරට ව්‍යාපෘතියක් ප්‍රසිද්ධියේ නිකුත් කරන විට), උත්සාහ කරන්න:

git checkout --orphan <new-branch>
git commit

මා සිතන්නේ මෙය කිරීමට ඇති පහසුම ක්‍රමය වන්නේ මාස්ටර් මත පදනම්ව නව ශාඛාවක් සෑදීම සහ merge --squashවිශේෂාංග ශාඛාවෙන් එකක් කිරීමයි.

git checkout master
git checkout -b feature_branch_squashed
git merge --squash feature_branch

එවිට ඔබට සියලු වෙනස්කම් කිරීමට සූදානම්.

උදාහරණයක් ලෙස ඔබට ශාඛාවක (දුරස්ථ නිධිය) තනි කැපවීමකට අවසන් කැපීම් 3 ක් ස්කොෂ් කිරීමට අවශ්‍ය නම්: https://bitbucket.org

මම කළේ එයයි

1. git reset --soft Head~3
2. git commit
3. git push origin <branch_name> --force

සෑම විටම ක්‍රියාත්මක වන සරල එක්-ලයිනර්, ඔබ දැනට ස්කොෂ් කිරීමට අවශ්‍ය ශාඛාවේ සිටින නිසා, ස්වාමියා එය ආරම්භ කළ ශාඛාව වන අතර, නවතම කැපවීම තුළ ඔබ භාවිතා කිරීමට කැමති කැපවීමේ පණිවිඩය සහ කතුවරයා ඇතුළත් වේ:

git reset --soft $(git merge-base HEAD master) && git commit --reuse-message=HEAD@{1}

AR අවවාදයයි: "මගේ අන්තිම X කොමිස්" අපැහැදිලි විය හැකිය.

  (MASTER)  
Fleetwood Mac            Fritz
      ║                    ║
  Add Danny  Lindsey     Stevie       
    Kirwan  Buckingham    Nicks                                              
      ║         ╚═══╦══════╝     
Add Christine       ║          
   Perfect      Buckingham
      ║           Nicks            
    LA1974══════════╝                                    
      ║                  
      ║                  
    Bill <══════ YOU ARE EDITING HERE
  Clinton        (CHECKED OUT, CURRENT WORKING DIRECTORY)              

Https://github.com/fleetwood-mac/band-history ගබඩාවේ මෙම ඉතා සංක්ෂිප්ත ඉතිහාසය තුළ, බිල් ක්ලින්ටන් මුල් ( MASTER) ෆ්ලීට්වුඩ් මැක් බැඳීමට බැඳී ඇති බිල් ක්ලින්ටන් සමඟ ඒකාබද්ධ කිරීම සඳහා ඔබ ඉල්ලීමක් විවෘත කර තිබේ .

ඔබ අදින්න ඉල්ලීමක් විවෘත කළ අතර GitHub හි මෙය ඔබට පෙනේ:

කොමිස් හතරක්:

• ඩැනී කිර්වන් එක් කරන්න
• ක්‍රිස්ටීන් පරිපූර්ණ එකතු කරන්න
• LA1974
• බිල් ක්ලින්ටන්

සම්පුර්ණ නිධිය ඉතිහාසය කියවීමට කිසිවෙකු උනන්දු නොවනු ඇතැයි සිතීම. (ඇත්ත වශයෙන්ම ගබඩාවක් තිබේ, ඉහත සබැඳිය ක්ලික් කරන්න!) ඔබ මෙම කොමිස් ස්කොෂ් කිරීමට තීරණය කරයි. ඉතින් ඔයා ගිහින් දුවන්න git reset --soft HEAD~4 && git commit. git push --forceඔබේ PR පිරිසිදු කිරීම සඳහා ඔබ එය GitHub වෙත යොමු කරයි.

මොකද වෙන්නේ? ඔබ ෆ්‍රිට්ස් සිට බිල් ක්ලින්ටන් දක්වා තනි කැපවීමක් කළා. ඊයේ ඔබ මෙම ව්‍යාපෘතියේ බකිංහැම් නික්ස් අනුවාදයේ වැඩ කරමින් සිටි බව ඔබට අමතක වූ බැවිනි. හා git logඔබ GitHub දකින දේ හා නොගැලපේ.

OR කතන්දරයේ සදාචාරය

1. ඔබ ලබා ගැනීමට අවශ්ය වූ නිශ්චිත ගොනු සොයා ගැනීමට , සහ git checkoutඔවුන්
2. නිශ්චිත පෙර ඔබ ඉතිහාසයේ තබා ගැනීමට අවශ්ය සිදු, සහ සොයා git reset --softබව
3. පවතින බවට git commitවෙතින් සෘජු warps බව සිට වෙත කිරීමට

අතර ඇති බැඳීම් පණිවිඩ ගැන ඔබ තැකීමක් නොකරන්නේ නම්, ඔබට භාවිතා කළ හැකිය

git reset --mixed <commit-hash-into-which-you-want-to-squash>
git commit -a --amend

ඔබ GitLab සමඟ වැඩ කරන්නේ නම්, පහත දැක්වෙන පරිදි ඒකාබද්ධ කිරීමේ ඉල්ලීමෙහි ඇති ස්කොෂ් විකල්පය ක්ලික් කළ හැකිය. බැඳීමේ පණිවිඩය ඒකාබද්ධ කිරීමේ ඉල්ලීමේ මාතෘකාව වනු ඇත.

git rebase -i HEAD^^

මෙහි s හි ගණන X වේ

(මේ අවස්ථාවේ දී, අවසන් කොමිස් දෙක ස්කොෂ් කරන්න)

වෙනත් විශිෂ් answer පිළිතුරු වලට අමතරව git rebase -i, කැපවීමේ අනුපිළිවෙල සමඟ මා නිතරම ව්‍යාකූල වන්නේ කෙසේද යන්න එක් කිරීමට මම කැමතියි - අලුත් ඒවාට වඩා පැරණි හෝ අනෙක් අතට? ඉතින් මෙය මගේ කාර්ය ප්‍රවාහයයි:

1. git rebase -i HEAD~[N], ෙමහිදී N මම, බැඳීමට අවශ්ය අනාචාරයේ සංඛ්යාව වේ වඩාත් ම මෑත එක් සිට බලපැවැත්වෙන . ඒ නිසාgit rebase -i HEAD~5 "අන්තිම කොමිස් 5 නව එකක් බවට ස්කොෂ් කරන්න";
2. මට ඒකාබද්ධ කිරීමට අවශ්‍ය කොමිස් ලැයිස්තුව පෙන්වමින් සංස්කාරකය මතු වේ. දැන් ඒවා ප්‍රතිලෝම අනුපිළිවෙලින් දර්ශනය වේ : පැරණි බැඳීම ඉහළින් තිබේ. පළමු / පැරණි එක හැර එහි ඇති සියලුම කොමිස් "ස්කොෂ්" හෝ "එස්" ලෙස සලකුණු කරන්න : එය ආරම්භක ස්ථානයක් ලෙස භාවිතා කරනු ඇත. සංස්කාරකය සුරකින්න සහ වසා දමන්න;
3. සංස්කාරකය නව කැපවීම සඳහා පෙරනිමි පණිවිඩයක් සමඟ නැවත මතු වේ: එය ඔබගේ අවශ්‍යතාවන්ට වෙනස් කරන්න, සුරකින්න සහ වසා දමන්න. ස්කොෂ් සම්පූර්ණයි!

ප්‍රභවයන් සහ අමතර කියවීම්: # 1 , # 2 .

මේ වගේ වැඩ ප්‍රවාහයකට අදාළ ප්‍රශ්නයට පිළිතුරක් ගැන කුමක් කිව හැකිද?

1. බොහෝ දේශීය කොමිස්, මාස්ටර් වෙතින් බහු ඒකාබද්ධ කිරීම් සමඟ මිශ්‍ර වී ඇත ,
2. අවසානයේ දුරස්ථයට තල්ලු කිරීම,
3. PR සහ සමාලෝචකයා විසින් මාස්ටර් ඒකාබද්ධ කරන්න . (ඔව්, merge --squashPR ට පසුව සංවර්ධකයාට පහසු වනු ඇත , නමුත් කණ්ඩායම සිතුවේ එය ක්‍රියාවලිය මන්දගාමී වනු ඇති බවයි.)

මම මේ පිටුවේ ඒ වගේ වැඩ ප්‍රවාහයක් දැකලා නැහැ. (එය මගේ ඇස් විය හැකිය.) මම rebaseනිවැරදිව තේරුම් ගන්නේ නම් , බහුවිධ ඒකාබද්ධ කිරීම් සඳහා ගැටුම් නිරාකරණ අවශ්‍ය වේ . මට ඒ ගැන හිතන්නවත් අවශ්‍ය නැහැ!

ඉතින්, මෙය අපට වැඩ කරන බව පෙනේ.

1. git pull master
2. git checkout -b new-branch
3. git checkout -b new-branch-temp
4. දේශීයව බොහෝ දේ සංස්කරණය කර කැප කරන්න, නිතිපතා ස්වාමියා ඒකාබද්ධ කරන්න
5. git checkout new-branch
6. git merge --squash new-branch-temp // සියලු වෙනස්කම් වේදිකාවේ තබයි
7. git commit 'one message to rule them all'
8. git push
9. විචාරකයා PR කරන අතර මාස්ටර් සමඟ ඒකාබද්ධ වේ.

1. git reset --soft HEAD~n

   සමග nස්කොෂ් සඳහා අනාචාරයේ සංඛ්යාව වීම

2. git commit -m "new commit message"
3. git push origin <branch_name> --force

මට වඩා සාමාන්‍ය විසඳුමක් වන්නේ 'එන්' කොමිස් නියම කිරීම නොව, ඔබට ඉහළින් ස්කොෂ් කිරීමට අවශ්‍ය ශාඛාව / කැපවීමේ හැඳුනුම්පතයි. නිශ්චිත බැඳීමක් දක්වා වූ ගණන් කිරීමකට වඩා මෙය අඩු දෝෂ සහිත වේ the ටැගය කෙලින්ම සඳහන් කරන්න, නැතහොත් ඔබට ඇත්තටම ගණන් කිරීමට අවශ්‍ය නම් ඔබට HEAD ~ N නියම කළ හැකිය.

මගේ කාර්ය ප්‍රවාහයේ දී, මම ශාඛාවක් ආරම්භ කරන අතර, එම ශාඛාව පිළිබඳ මගේ පළමු කැපවීම ඉලක්කය සාරාංශ කරයි (එනම් සාමාන්‍යයෙන් එය පොදු නිධිය වෙත විශේෂාංගය සඳහා වන 'අවසාන' පණිවිඩය ලෙස මම තල්ලු කරමි.) එබැවින් මම අවසන් වූ විට, සියල්ල මට කරන්න ඕන git squash master පළමු පණිවිඩය වෙත ආපසු යාම සහ පසුව මම තල්ලු කිරීමට සූදානම්.

මම අන්වර්ථය භාවිතා කරමි:

squash = !EDITOR="\"_() { sed -n 's/^pick //p' \"\\$1\"; sed -i .tmp '2,\\$s/^pick/f/' \"\\$1\"; }; _\"" git rebase -i

මෙය ඉතිහාසය පෙරළා දැමීමට පෙර ඉවත දමනු ඇත - මෙය ඔබට ආපසු හැරවීමට අවශ්‍ය නම් පැරණි බැඳීම් හැඳුනුම්පතක් කොන්සෝලය වෙතින් උදුරා ගැනීමෙන් ඔබට යථා තත්වයට පත්වීමට අවස්ථාවක් ලබා දෙයි. (සොලාරිස් පරිශීලකයින් එය GNU sed -iවිකල්පය භාවිතා කරන බව සලකයි , මැක් සහ ලිනක්ස් භාවිතා කරන්නන් මේ සමඟ හොඳින් සිටිය යුතුය.)

ප්රශ්නය එය "අන්තිම" යන්නෙන් අදහස් කරන්නේ කුමක්ද යන්න අපැහැදිලි විය හැකිය.

උදාහරණයක් ලෙස git log --graphපහත සඳහන් ප්‍රතිදානයන් (සරල කරන ලද):

* commit H0
|
* merge
|\
| * commit B0
| |
| * commit B1
| | 
* | commit H1
| |
* | commit H2
|/
|

කාලය අනුව අවසන් වරට සිදු කරනුයේ H0, ඒකාබද්ධ කිරීම, B0 ය. ඒවා ස්කොෂ් කිරීම සඳහා ඔබ ඒකාබද්ධ කළ ශාඛාව H1 මත නැවත ප්‍රතිස්ථාපනය කිරීමට සිදුවේ.

ගැටළුව වන්නේ H0 හි H1 සහ H2 අඩංගු වීමයි (සහ සාමාන්‍යයෙන් ඒකාබද්ධ වීමට පෙර සහ අතු බෙදීමෙන් පසුව වැඩි වැඩියෙන්) B0 නොමැති අතර. එබැවින් ඔබ අවම වශයෙන් H0, ඒකාබද්ධ කිරීම, H1, H2, B0 වෙතින් වෙනස්කම් කළමනාකරණය කළ යුතුය.

නැවත භාවිතා කිරීම භාවිතා කළ හැකි නමුත් වෙනස් ආකාරයකින් අනෙක් අය පිළිතුරු සඳහන් කර ඇත:

rebase -i HEAD~2

මෙය ඔබට තේරීම් විකල්ප පෙන්වනු ඇත (වෙනත් පිළිතුරු වල සඳහන් පරිදි):

pick B1
pick B0
pick H0

H0 වෙත තෝරා ගැනීම වෙනුවට ස්කොෂ් දමන්න:

pick B1
pick B0
s H0

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

නැවත සකස් කිරීම අවසන් වූ පසු ඔබට ස්කොෂ් කළ H0 සහ B0 සඳහා පණිවිඩයක් තෝරා ගත හැකිය:

* commit squashed H0 and B0
|
* commit B1
| 
* commit H1
|
* commit H2
|

PS ඔබ BO වෙත යම්කිසි යළි පිහිටුවීමක් කළහොත්: (නිදසුනක් ලෙස, එය භාවිතා reset --mixedකිරීම වඩාත් විස්තරාත්මකව මෙහි විස්තර කර ඇත https://stackoverflow.com/a/18690845/2405850 ):

git reset --mixed hash_of_commit_B0
git add .
git commit -m 'some commit message'

ඉන්පසු ඔබ H0, H1, H2 හි B0 වෙනස්කම් වලට ස්කොෂ් කරයි (අතු බෙදීමෙන් පසුව හා ඒකාබද්ධ වීමට පෙර වෙනස්කම් සඳහා සම්පූර්ණයෙන්ම අහිමි වේ.