ฉันจะสควอช X สุดท้ายของฉันให้คอมมิตด้วย Git ได้อย่างไร?

การใช้งานgit rebase -i <after-this-commit>และแทนที่ "เลือก" ที่กระทำสองและต่อด้วย "สควอช" หรือ "fixup" ที่อธิบายไว้ในคู่มือการใช้งาน

ในตัวอย่าง<after-this-commit>นี้อาจเป็นแฮช SHA1 หรือตำแหน่งสัมพัทธ์จาก HEAD ของสาขาปัจจุบันที่วิเคราะห์คอมมิทสำหรับคำสั่ง rebase ตัวอย่างเช่นหากผู้ใช้ต้องการเพื่อดู 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})"

ทั้งสองวิธีใช้วิธีการสควอชสามครั้งล่าสุดเพื่อคอมมิตใหม่ในลักษณะเดียวกัน ซอฟต์รีเซ็ตเพิ่ง re-points HEAD ไปยังจุดสุดท้ายที่คุณไม่ต้องการสควอช ไม่ว่าจะเป็นดัชนีหรือแผนผังการทำงานจะถูกแตะเบา ๆ โดยปล่อยให้ดัชนีอยู่ในสถานะที่ต้องการสำหรับการกระทำใหม่ของคุณ (เช่นมีการเปลี่ยนแปลงทั้งหมดจากการกระทำที่คุณกำลังจะ "ทิ้ง")

คุณสามารถใช้git merge --squashสิ่งนี้ได้ซึ่งดูสง่างามกว่าเล็กน้อยgit rebase -iเล็กน้อย สมมติว่าคุณอยู่ในระดับปริญญาโทและคุณต้องการที่จะสควอช 12 ครั้งสุดท้ายเป็นหนึ่ง

คำเตือน: ก่อนอื่นให้แน่ใจว่าคุณยอมรับงานของคุณ - ตรวจสอบว่าgit statusสะอาด (ตั้งแต่git reset --hardจะโยนออกไปจัดฉากและการเปลี่ยนแปลง unstaged)

แล้ว:

# 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แนะนำที่ง่ายกว่าของ Chris Johnsen ในคำตอบของเขาคือคุณได้รับข้อความการส่งข้อความที่มีการส่งข้อความยืนยันทั้งหมดที่คุณกำลังส่ง

ฉันขอแนะนำให้หลีกเลี่ยงgit resetเมื่อเป็นไปได้ - โดยเฉพาะอย่างยิ่งสำหรับ Git-novices ถ้าคุณไม่จำเป็นต้องทำให้กระบวนการโดยอัตโนมัติเป็นไปตามจำนวนที่ได้ตกลงไว้มีวิธีแปลกใหม่น้อยกว่า ...

1. ใส่คอมมิตที่จะถูกบีบลงในสาขาที่ทำงาน (หากยังไม่ได้เปิด) - ใช้ gitk สำหรับสิ่งนี้
2. ตรวจสอบสาขาเป้าหมาย (เช่น 'ต้นแบบ')
3. git merge --squash (working branch name)
4. git commit

ข้อความคอมมิชชันจะถูกเติมไว้ล่วงหน้าตามสควอช

ตามคำตอบของ Chris Johnsen ,

เพิ่มนามแฝง "สควอช" ทั่วโลกจาก bash: (หรือ Git Bash บน Windows)

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

... หรือใช้พรอมต์คำสั่งของ Windows:

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กระทำ

หมายเหตุ: ข้อความการคอมมิชชันของผลลัพธ์คือการรวมกันของคอมมิตที่คอมมิตตามลำดับ หากคุณไม่พึงพอใจกับสิ่งนั้นคุณสามารถgit commit --amendแก้ไขได้ด้วยตนเอง (หรือแก้ไขนามแฝงเพื่อให้เข้ากับรสนิยมของคุณ)

ขอบคุณโพสต์บล็อกที่มีประโยชน์นี้ฉันพบว่าคุณสามารถใช้คำสั่งนี้เพื่อกำจัด 3 คอมมิชชันล่าสุด:

git rebase -i HEAD~3

สิ่งนี้มีประโยชน์เนื่องจากสามารถใช้งานได้แม้ในสาขาท้องถิ่นที่ไม่มีข้อมูลการติดตาม / repo ระยะไกล

คำสั่งจะเปิดตัวแก้ไขการรีบูตแบบโต้ตอบซึ่งจะช่วยให้คุณสามารถสั่งซื้อใหม่, สควอช, reword และอื่น ๆ ตามปกติ

การใช้เครื่องมือแก้ไขการรีบูตแบบโต้ตอบ:

ตัวแก้ไขการปฏิเสธแบบโต้ตอบแสดงการยอมรับสามครั้งล่าสุด ข้อ จำกัด นี้ถูกกำหนดโดยHEAD~3เมื่อรันคำสั่งgit rebase -i HEAD~3เมื่อใช้คำสั่ง

การคอมมิชชันล่าสุดHEADจะแสดงเป็นอันดับแรกในบรรทัดที่ 1 บรรทัดที่ขึ้นต้นด้วย a#คือข้อคิดเห็น / เอกสาร

เอกสารที่ปรากฏค่อนข้างชัดเจน ในบรรทัดใดก็ตามที่คุณสามารถเปลี่ยนคำสั่งจากpickเป็นคำสั่งที่คุณเลือก

ฉันชอบที่จะใช้คำสั่ง fixupนี้เป็น "squashes" การเปลี่ยนแปลงการกระทำของการกระทำในบรรทัดข้างต้นและทิ้งข้อความของการกระทำ

ในฐานะที่กระทำในบรรทัดที่ 1 ในกรณีส่วนใหญ่ที่คุณจะออกจากนี้เป็นHEAD pickคุณไม่สามารถใช้squashหรือfixupเนื่องจากไม่มีข้อผูกมัดอื่น ๆ ในการกำจัดการมอบหมาย

คุณสามารถเปลี่ยนลำดับของการคอมมิท สิ่งนี้อนุญาตให้คุณสควอชหรือการแก้ไขที่คอมมิชชันที่ไม่ได้ติดกันตามลำดับเวลา

ตัวอย่างการปฏิบัติในชีวิตประจำวัน

ฉันเพิ่งมุ่งมั่นคุณสมบัติใหม่ ตั้งแต่นั้นมาฉันได้ทำการแก้ไขข้อบกพร่องสองครั้ง แต่ตอนนี้ฉันได้ค้นพบข้อผิดพลาด (หรืออาจเป็นเพียงแค่ข้อผิดพลาดการสะกดคำ) ในคุณสมบัติใหม่ที่ฉันมุ่งมั่น น่ารำคาญมาก! ฉันไม่ต้องการให้คนใหม่สร้างมลภาวะให้กับประวัติการกระทำของฉัน!

สิ่งแรกที่ฉันทำคือแก้ไขข้อผิดพลาดและทำการคอมมิทใหม่ด้วยความคิดเห็น squash this into my new feature!สิ่งแรกที่ผมทำคือการแก้ไขความผิดพลาดและทำให้ใหม่กระทำด้วยการแสดงความคิดเห็น

จากนั้นฉันเรียกใช้git logหรือgitkรับค่า SHA ของคุณลักษณะใหม่ (ในกรณีนี้1ff9460)

ต่อไปผมจะนำมาขึ้นบรรณาธิการ rebase git rebase -i 1ff9460~แบบโต้ตอบกับ ~หลังจากที่กระทำ SHA บอกบรรณาธิการที่จะรวมที่กระทำในการแก้ไข

ต่อไปผมจะย้ายกระทำที่มีการแก้ไข ( fe7f1e0) จะอยู่ภายใต้คุณลักษณะกระทำและการเปลี่ยนแปลงไปpickfixup

เมื่อปิดตัวแก้ไขการแก้ไขจะถูกบีบเข้าสู่คุณลักษณะการส่งมอบและประวัติการส่งมอบของฉันจะดูดีและสะอาด!

สิ่งนี้ใช้ได้ดีเมื่อคอมมิชชันทั้งหมดเป็นโลคัล แต่ถ้าคุณลองเปลี่ยนคอมมิทที่ผลักไปที่รีโมตคุณสามารถสร้างปัญหาให้กับผู้พัฒนารายอื่นที่เช็คสาขาเดียวกัน!

หากคุณใช้ TortoiseGit คุณสามารถใช้ฟังก์ชันCombine to one commit:

1. เปิดเมนูบริบทของ TortoiseGit
2. เลือก Show Log
3. ทำเครื่องหมายข้อผูกพันที่เกี่ยวข้องในมุมมองบันทึก
4. เลือกCombine to one commitจากเมนูบริบท

ฟังก์ชั่นนี้ดำเนินการขั้นตอน git เดียวที่จำเป็นโดยอัตโนมัติ น่าเสียดายที่มีเฉพาะสำหรับ Windows

ในการทำเช่นนี้คุณสามารถใช้คำสั่ง 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....

สำหรับรายละเอียดคลิกที่ลิงค์

จากบทความนี้ฉันพบว่าวิธีนี้ง่ายสำหรับ usecase ของฉัน

สาขา 'dev' ของฉันอยู่ก่อนหน้า 'origin / dev' โดย 96 commits (ดังนั้นคอมมิชชันเหล่านี้ยังไม่ได้ถูกผลักไปที่รีโมท)

ฉันต้องการกำจัดสิ่งเหล่านี้ให้เป็นหนึ่งก่อนผลักดันการเปลี่ยนแปลง ฉันจะรีเซ็ตสาขาเป็นสถานะของ 'ต้นทาง / dev' (นี่จะทำให้การเปลี่ยนแปลงทั้งหมดจาก 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 = ใช้กระทำ

s, squash = ใช้การคอมมิต แต่รวมเข้ากับการคอมมิชชันก่อนหน้า

ตัวอย่างเช่นหากคุณต้องการรวมการกระทำทั้งหมดเข้าด้วยกันการเลือกคือสิ่งแรกที่คุณทำและสิ่งที่จะเกิดขึ้นในอนาคตทั้งหมด หากใช้เป็นกลุ่มให้ใช้: xในโหมดแทรกเพื่อบันทึกและออกจากโปรแกรมแก้ไข

จากนั้นให้ดำเนินการ rebase ต่อ:

git rebase --continue

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีนี้และวิธีอื่น ๆ ในการเขียนประวัติการส่งข้อความของคุณดูโพสต์ที่มีประโยชน์นี้

คำตอบที่ผิดปกติเป็นสิ่งที่ดี แต่ฉันรู้สึกไม่แน่ใจเกี่ยวกับเรื่องนี้ดังนั้นฉันจึงตัดสินใจที่จะเพิ่มภาพหน้าจอสองสามภาพ

ขั้นตอนที่ 0: บันทึก git

git logดูที่ที่คุณอยู่ด้วย สำคัญที่สุดค้นหาแฮชการคอมมิชชันของการคอมมิชชันแรกที่คุณไม่ต้องการสควอช ดังนั้นเฉพาะ:

ขั้นตอนที่ 1: การรีคอมไพล์ git

ดำเนินการ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

หมายเหตุ: สิ่งนี้ขึ้นอยู่กับการใช้ git บนubuntuเชลล์ หากคุณใช้ระบบปฏิบัติการอื่น ( WindowsหรือMac) คำสั่งด้านบนจะเหมือนกันยกเว้นเครื่องมือแก้ไข คุณอาจได้รับการแก้ไขที่แตกต่างกัน

ขั้นตอนที่ 2

1. ก่อนอื่นให้เพิ่มไฟล์ที่จำเป็นสำหรับการคอมมิท

git add <files>

2. จากนั้นส่งคอมมิชชันที่ใช้--fixupตัวเลือกและสิ่งOLDCOMMITที่เราควรจะรวม (สควอช) สิ่งนี้

git commit --fixup=OLDCOMMIT

fixup1 <OLDCOMMIT_MSG>ตอนนี้จะสร้างใหม่กระทำที่ด้านบนของหัว

3. จากนั้นดำเนินการดังต่อไปนี้คำสั่งเพื่อผสาน (สควอช) OLDCOMMITใหม่กระทำเพื่อ

git rebase --interactive --autosquash OLDCOMMIT^

นี่หมายความว่าก่อนหน้านี้กระทำการ^ คำสั่งOLDCOMMITนี้จะrebaseเปิดหน้าต่างโต้ตอบบนเครื่องมือแก้ไข (vim หรือ nano) ที่เราไม่จำเป็นต้องทำอะไรเลยเพียงแค่บันทึกและออกก็เพียงพอแล้ว เนื่องจากตัวเลือกที่ส่งไปยังสิ่งนี้จะย้ายการส่งล่าสุดไปยังถัดจากการส่งเก่าโดยอัตโนมัติและเปลี่ยนการดำเนินการเป็นfixup (เทียบเท่ากับสควอช) จากนั้นการรีบูตจะดำเนินต่อไปและเสร็จสิ้น

ขั้นตอนที่ 3

1. หากจำเป็นต้องเพิ่มการเปลี่ยนแปลงใหม่ไปยังหน้าล่าสุดกระทำหมายถึงสามารถใช้กับ--amendgit-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และสร้าง ID การยอมรับใหม่1d4ab2e1

ข้อสรุป

• ข้อดีของขั้นตอนที่ 1 คือการสควอชหลายคอมมิทและสั่งใหม่ แต่ขั้นตอนนี้จะเป็นเรื่องยากถ้าเราจำเป็นต้องรวมการแก้ไขเพื่อคอมมิชชันเก่ามาก
• ดังนั้นขั้นตอนที่ 2 ช่วยผสานความมุ่งมั่นกับความมุ่งมั่นที่เก่ามากได้อย่างง่ายดาย
• และขั้นตอนที่ 3 มีประโยชน์ในกรณีที่จะสควอชการเปลี่ยนแปลงใหม่เพื่อกระทำล่าสุด

หากต้องการสควอช 10 ครั้งสุดท้ายให้คอมมิชชันเดียว:

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

หากคุณต้องการอัปเดตสาขาระยะไกลด้วยสควอชคอมมิต:

git push -f

หากคุณอยู่ในสาขาระยะไกล (เรียกว่าfeature-branch) ที่ถูกโคลนจากพื้นที่เก็บข้อมูลทองคำ ( golden_repo_name) แล้วนี่เป็นเทคนิคในการสควอชคอมมิชชันของคุณเป็นหนึ่ง:

1. ชำระเงิน repo ทอง

   git checkout golden_repo_name
   

2. สร้างสาขาใหม่จาก (repo ทองคำ) ดังนี้

   git checkout -b dev-branch
   

3. สควอชผสานกับสาขาท้องถิ่นของคุณที่คุณมีอยู่แล้ว

   git merge --squash feature-branch
   

4. กระทำการเปลี่ยนแปลงของคุณ (นี่จะเป็นสิ่งเดียวที่กระทำใน dev-branch)

   git commit -m "My feature complete"
   

5. ผลักสาขาไปยังพื้นที่เก็บข้อมูลในท้องถิ่นของคุณ

   git push origin dev-branch
   

สิ่งที่สามารถจะสะดวกจริงๆ: ค้นหากระทำกัญชาคุณต้องการสควอชที่ด้านบนของการพูด
d43e15

ตอนนี้ใช้

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

นี่เป็น kludgy สุดยอด แต่เป็นวิธีที่ยอดเยี่ยมดังนั้นฉันจะโยนมันเข้าไปในวงแหวน:

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-rebase-todo(พรอมต์รีบูตแบบโต้ตอบ) เปลี่ยนทั้งหมดยกเว้น "เลือก" ครั้งแรกเป็น "สควอช" และอื่น ๆ วางไข่เป็นกลุ่ม - ดังนั้นเมื่อคุณถูกถาม ในการแก้ไขข้อความคอมมิชชันคุณได้รับเสียงเรียกเข้า (และเห็นได้ชัดว่าฉันถูกบีบห้าครั้งสุดท้ายในสาขา foo แต่คุณสามารถเปลี่ยนแปลงได้ตามที่คุณต้องการ)

ผมอาจจะทำในสิ่งที่มาร์ค Longair ปัญหาแม้ว่า

หากคุณต้องการ squish ทุกการกระทำในการกระทำเดียว (เช่นเมื่อปล่อยโครงการสาธารณะเป็นครั้งแรก) ให้ลอง:

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

ฉันคิดว่าวิธีที่ง่ายที่สุดในการทำเช่นนี้คือการทำให้สาขาใหม่หลุดจากต้นแบบและทำการผสาน - ถอนออกจากสาขาฟีเจอร์

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

จากนั้นคุณมีการเปลี่ยนแปลงทั้งหมดพร้อมที่จะกระทำ

2563โซลูชั่นง่าย ๆโดยไม่ต้องรีบูต:

git reset --soft HEAD~2

git commit -m "new commit message"

git push --force

2 หมายความว่าคอมมิชชันสุดท้ายจะถูกแบน คุณสามารถแทนที่ด้วยหมายเลขใดก็ได้

Simple one-liner ที่ใช้งานได้ตลอดเวลาเนื่องจากคุณอยู่ในสาขาที่คุณต้องการสควอชมาสเตอร์เป็นสาขาที่มาจากการกระทำล่าสุดและคอมมิชชันล่าสุดประกอบด้วยข้อความคอมมิทและผู้แต่งที่คุณต้องการใช้:

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

หากตัวอย่างเช่นคุณต้องการสควอช 3 ครั้งล่าสุดจะคอมมิชชันเดียวในสาขา (ที่เก็บข้อมูลระยะไกล) ในตัวอย่าง: https://bitbucket.org

สิ่งที่ฉันทำคือ

1. รีเซ็ต git - ซอฟต์เฮด ~ 3 &&
2. คอมไพล์
3. git push กำเนิด (branch_name) - บังคับ

⚠️คำเตือน: "การยอมรับครั้งสุดท้ายของฉัน" อาจไม่ชัดเจน

  (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 repository คุณได้เปิดคำขอดึงเพื่อรวมเข้าไว้ใน Bill Clinton กระทำในต้นฉบับ ( MASTER) Fleetwood Mac ส่งมอบ

คุณเปิดคำขอดึงและใน GitHub คุณเห็นสิ่งนี้:

สี่กระทำ:

• เพิ่ม Danny Kirwan
• เพิ่มคริสตินที่สมบูรณ์แบบ
• LA1974
• บิลคลินตัน

กำลังคิดว่าจะไม่มีใครสนใจอ่านประวัติที่เก็บข้อมูลแบบเต็ม (ที่จริงมีที่เก็บคลิกที่ลิงค์ด้านบน!) คุณตัดสินใจที่จะกำจัดสิ่งเหล่านี้ git reset --soft HEAD~4 && git commitดังนั้นคุณจะไปและวิ่ง จากนั้นคุณgit push --forceก็ไปที่ GitHub เพื่อล้างค่า PR ของคุณ

แล้วจะเกิดอะไรขึ้น คุณเพิ่งทำคอมมิชชันที่ได้รับจาก Fritz ไปยัง Bill Clinton เพราะคุณลืมไปว่าเมื่อวานนี้คุณกำลังทำงานกับ Buckingham Nicks เวอร์ชันของโครงการนี้ และgit logไม่ตรงกับสิ่งที่คุณเห็นใน GitHub

OR คุณธรรมของเรื่องราว

1. ค้นหาไฟล์ที่คุณต้องการที่จะได้รับไปและgit checkoutพวกเขา
2. ค้นหาคำมั่นสัญญาที่แน่นอนที่คุณต้องการเก็บไว้ในประวัติศาสตร์และgit reset --softสิ่งนั้น
3. ทำให้git commitwarps นั้นโดยตรงจากจากไปสู่

หากคุณไม่สนใจเกี่ยวกับข้อความคอมมิทของคอมมิทที่อยู่ระหว่างคอมมิชชันคุณสามารถใช้

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

หากคุณทำงานกับ GitLab คุณสามารถคลิกตัวเลือกสควอชในคำขอรวมที่แสดงด้านล่าง ข้อความยืนยันจะเป็นชื่อของคำขอรวม

git rebase -i HEAD^^

โดยที่จำนวน ^ คือ X

(ในกรณีนี้สควอชทั้งสองกระทำล่าสุด)

นอกจากคำตอบที่ยอดเยี่ยมอื่น ๆ ฉันต้องการเพิ่มgit rebase -iความสับสนให้กับคำสั่งการมอบหมาย - เก่าไปใหม่กว่าหนึ่งหรือในทางกลับกันได้อย่างไร นี่คือขั้นตอนการทำงานของฉัน:

1. git rebase -i HEAD~[N]ซึ่ง N คือจำนวนของการกระทำที่ฉันต้องการที่จะเข้าร่วมเริ่มต้นจากหนึ่งล่าสุด ดังนั้นgit rebase -i HEAD~5จะหมายถึง "สควอชสุดท้าย 5 คอมมิชชันเป็นอันใหม่";
2. ตัวแก้ไขปรากฏขึ้นโดยแสดงรายการข้อผูกพันที่ฉันต้องการผสาน ตอนนี้พวกเขาจะแสดงในลำดับย้อนกลับ : การกระทำที่เก่ากว่าอยู่ด้านบน ทำเครื่องหมายว่า "สควอช" หรือ "s" ทั้งหมดที่กระทำในนั้นยกเว้นอันแรก / อันที่เก่ากว่า : มันจะถูกใช้เป็นจุดเริ่มต้น บันทึกและปิดเครื่องมือแก้ไข
3. บรรณาธิการจะปรากฏขึ้นอีกครั้งพร้อมข้อความเริ่มต้นสำหรับการส่งข้อความใหม่: เปลี่ยนตามความต้องการของคุณบันทึกและปิด สควอชเสร็จแล้ว!

แหล่งที่มาและเพิ่มเติมอ่าน: # 1 , # 2

สิ่งที่เกี่ยวกับคำตอบสำหรับคำถามที่เกี่ยวข้องกับเวิร์กโฟลว์เช่นนี้?

1. กระทำในท้องถิ่นจำนวนมากผสมกับการผสานหลายอย่างจากต้นแบบ ,
2. ในที่สุดก็ผลักไปที่ระยะไกล
3. การประชาสัมพันธ์และการผสานการต้นแบบโดยวิจารณ์ (ใช่มันจะง่ายกว่าสำหรับผู้พัฒนาmerge --squashหลังจาก PR แต่ทีมคิดว่าจะทำให้กระบวนการช้าลง)

ฉันไม่เห็นเวิร์กโฟลว์แบบนี้ในหน้านี้ (นั่นอาจเป็นนัยน์ตาของฉัน) หากฉันเข้าใจ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. ผู้ตรวจทานทำการประชาสัมพันธ์และผสานรวมกับผู้เชี่ยวชาญ

ฉันพบวิธีแก้ปัญหาทั่วไปเพิ่มเติมไม่ได้ระบุการยอมรับ 'N' แต่เป็น branch / commit-id ที่คุณต้องการสควอชด้านบน นี่เป็นข้อผิดพลาดน้อยกว่าการนับคอมมิทถึงการคอมมิทเฉพาะ - เพียงระบุแท็กโดยตรงหรือถ้าคุณต้องการนับคุณสามารถระบุ HEAD ~ N

ในเวิร์กโฟลว์ของฉันฉันเริ่มสาขาและความมุ่งมั่นแรกของฉันที่สาขาสรุปเป้าหมาย ฉันต้องการที่จะทำคือgit squash masterกลับไปที่ข้อความแรกจากนั้นฉันก็พร้อมที่จะผลักดัน

ฉันใช้นามแฝง:

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

สิ่งนี้จะถ่ายโอนข้อมูลประวัติที่ถูกบีบอัดก่อนที่จะทำเช่นนี้ซึ่งจะช่วยให้คุณมีโอกาสกู้คืนได้โดยการดึงรหัสยืนยันเก่าออกจากคอนโซลหากคุณต้องการเปลี่ยนกลับ (ผู้ใช้โซลาริสทราบว่าใช้-iตัวเลือกGNU sed ผู้ใช้ Mac และ Linux ควรใช้สิ่งนี้)

ในคำถามมันอาจคลุมเครือในสิ่งที่มีความหมายโดย "ล่าสุด"

เช่น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 แต่ในลักษณะที่แตกต่างจากนั้นในคนอื่น ๆ กล่าวถึงคำตอบ:

rebase -i HEAD~2

ตัวเลือกนี้จะแสดงตัวเลือกให้คุณ (ดังที่ได้กล่าวไว้ในคำตอบอื่น ๆ ):

pick B1
pick B0
pick H0

ใส่สควอชแทนที่จะเลือกเป็น H0:

pick B1
pick B0
s H0

หลังจากบันทึกและออกจากการรีบูตจะมีผลบังคับใช้ในการเปิดหลังจาก H1 นั่นหมายความว่ามันจะขอให้คุณแก้ไขข้อขัดแย้งอีกครั้ง (โดยที่ HEAD จะเป็น H1 ในตอนแรกและจากนั้นจึงรวบรวมคอมมิชชันตามที่ใช้)

หลังจาก rebase จะเสร็จสิ้นคุณสามารถเลือกข้อความสำหรับ squashed 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'

จากนั้นคุณสควอชเข้าสู่การเปลี่ยนแปลง B0 ของ H0, H1, H2 (การสูญเสียกระทำอย่างสมบูรณ์สำหรับการเปลี่ยนแปลงหลังจากการแยกและก่อนที่จะรวม

1) รีเซ็ต git - soft HEAD ~ n

n - จำนวนการคอมมิต, ต้องสควอช

2) คอมไพล์คอมมิท -m "ข้อความคอมมิทใหม่"

3) git push ต้นกำเนิด branch_name --force