Git เวิร์กโฟลว์และคำถาม rebase vs ผสาน


971

ตอนนี้ฉันใช้ Git มาสองสามเดือนกับโปรเจ็กต์กับผู้พัฒนารายอื่น ฉันมีประสบการณ์หลายปีกับSVNดังนั้นฉันเดาว่าฉันจะนำสัมภาระจำนวนมากมาสู่ความสัมพันธ์

ฉันได้ยินมาว่า Git นั้นยอดเยี่ยมสำหรับการแยกและรวมเข้าด้วยกันและจนถึงตอนนี้ฉันไม่เห็นเลย แน่นอนว่าการแตกแขนงนั้นง่ายมาก แต่เมื่อฉันพยายามที่จะรวมทุกอย่างเข้าสู่นรก ตอนนี้ฉันคุ้นเคยกับเรื่องนี้จาก SVN แต่สำหรับฉันแล้วฉันเพิ่งแลกเปลี่ยนระบบเวอร์ชันย่อยแบบหนึ่งสำหรับอีกระบบหนึ่ง

คู่ของฉันบอกฉันว่าปัญหาของฉันเกิดจากความปรารถนาของฉันที่จะผสานความจำเจและฉันควรใช้ rebase แทนการรวมในหลาย ๆ สถานการณ์ ตัวอย่างเช่นนี่คือขั้นตอนการทำงานที่เขาวางลง:

clone the remote repository
git checkout -b my_new_feature
..work and commit some stuff
git rebase master
..work and commit some stuff
git rebase master
..finish the feature
git checkout master
git merge my_new_feature

โดยพื้นฐานแล้วสร้างสาขาฟีเจอร์เสมอ rebase จากต้นแบบไปยังสาขาและผสานจากสาขากลับสู่ต้นแบบ สิ่งสำคัญที่ควรทราบคือสาขาจะยังคงอยู่ในพื้นที่เสมอ

นี่คือขั้นตอนการทำงานที่ฉันเริ่มต้นด้วย

clone remote repository
create my_new_feature branch on remote repository
git checkout -b --track my_new_feature origin/my_new_feature
..work, commit, push to origin/my_new_feature
git merge master (to get some changes that my partner added)
..work, commit, push to origin/my_new_feature
git merge master
..finish my_new_feature, push to origin/my_new_feature
git checkout master
git merge my_new_feature
delete remote branch
delete local branch

มีความแตกต่างที่สำคัญสองประการ (ฉันคิดว่า): ฉันใช้การผสานเสมอแทนที่จะเป็นการรีบูทและฉันดันสาขาคุณลักษณะของฉัน (และสาขาฟีเจอร์ของฉันมุ่งมั่น) ไปยังที่เก็บระยะไกล

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

เหตุผลของฉันสำหรับการผสานแทนการ rebase นั้นดูเหมือนว่าการผสานจะเป็นแบบมาตรฐานและการ rebase นั้นดูเหมือนจะเป็นคุณสมบัติขั้นสูง ความรู้สึกของฉันคือสิ่งที่ฉันพยายามทำไม่ใช่การตั้งค่าขั้นสูงดังนั้นการรีบูตจึงไม่จำเป็น ฉันได้อ่านหนังสือ Pragmatic Programming เล่มใหม่บน Git แล้วและมันครอบคลุมการผสานอย่างกว้างขวางและแทบจะพูดถึงการรีบูต

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

เวิร์กโฟลว์ "ถูกต้อง" คืออะไรสำหรับสิ่งนี้ Git ควรจะทำการแยกและรวมกันเป็นเรื่องง่ายและฉันแค่ไม่เห็นมัน

อัปเดต 2011-04-15

นี่ดูเหมือนจะเป็นคำถามยอดนิยมดังนั้นฉันคิดว่าฉันจะอัปเดตด้วยประสบการณ์สองปีนับตั้งแต่ที่ฉันถามครั้งแรก

ปรากฎว่าเวิร์กโฟลว์ดั้งเดิมนั้นถูกต้องอย่างน้อยในกรณีของเรา กล่าวอีกนัยหนึ่งนี่คือสิ่งที่เราทำและใช้งานได้:

clone the remote repository
git checkout -b my_new_feature
..work and commit some stuff
git rebase master
..work and commit some stuff
git rebase master
..finish the feature, commit
git rebase master
git checkout master
git merge my_new_feature

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

clone the remote repository
git checkout -b my_new_feature
..work and commit some stuff
git rebase master
..work and commit some stuff
git rebase master
..finish the feature, commit
git rebase master
git checkout master
git merge --squash my_new_feature
git commit -m "added my_new_feature"
git branch -D my_new_feature

Squash Merge Controversy - เนื่องจากมีผู้วิจารณ์หลายคนชี้ให้เห็นว่าการรวมสควอชจะทำให้ประวัติศาสตร์ทั้งหมดในฟีเจอร์ของคุณหมดไป ตามที่ชื่อบอกถึงมันจะทำการคอมมิตทั้งหมดลงไปในอันเดียว สำหรับคุณสมบัติขนาดเล็กสิ่งนี้เหมาะสมแล้วที่รวมไว้ในแพ็คเกจเดียว สำหรับคุณสมบัติที่มีขนาดใหญ่ขึ้นอาจไม่ใช่ความคิดที่ดีโดยเฉพาะอย่างยิ่งหากการกระทำของแต่ละบุคคลของคุณมีอะตอมอยู่แล้ว มันลงมาตามความชอบส่วนตัว

Github และ Bitbucket (อื่น ๆ ?) คำขอดึง - ในกรณีที่คุณสงสัยว่าการรวม / rebase เกี่ยวข้องกับคำขอดึงข้อมูลฉันขอแนะนำให้ทำตามขั้นตอนทั้งหมดข้างต้นจนคุณพร้อมที่จะผสานกลับไปเป็นหลัก แทนที่จะรวมกับ git ด้วยตนเองคุณเพียงแค่ยอมรับ PR โปรดทราบว่าสิ่งนี้จะไม่ทำการรวมสควอช (อย่างน้อยก็ไม่ใช่สควอช) แต่การสควอชที่ไม่ใช่สควอชไปข้างหน้านั้นเป็นรูปแบบการผสานที่ยอมรับในชุมชนคำขอดึงข้อมูล (เท่าที่ฉันรู้) โดยเฉพาะมันทำงานดังนี้:

clone the remote repository
git checkout -b my_new_feature
..work and commit some stuff
git rebase master
..work and commit some stuff
git rebase master
..finish the feature, commit
git rebase master
git push # May need to force push
...submit PR, wait for a review, make any changes requested for the PR
git rebase master
git push # Will probably need to force push (-f), due to previous rebases from master
...accept the PR, most likely also deleting the feature branch in the process
git checkout master
git branch -d my_new_feature
git remote prune origin

ฉันรัก Git และไม่ต้องการกลับไปที่ SVN หากคุณกำลังดิ้นรนเพียงติดกับมันและในที่สุดคุณจะเห็นแสงที่ปลายอุโมงค์


31
น่าเสียดายที่หนังสือ Pragmstic Programming เล่มใหม่ส่วนใหญ่เขียนจากการใช้ Git ในขณะที่ยังคิดอยู่ใน SVN และในกรณีนี้มันทำให้คุณเข้าใจผิด ใน Git การลดลงจะช่วยให้สิ่งต่าง ๆ ง่ายขึ้นเมื่อพวกเขาสามารถ ประสบการณ์ของคุณสามารถบอกคุณได้ว่าเวิร์กโฟลว์ของคุณไม่ทำงานใน Git ไม่ใช่ Git ที่ไม่ทำงาน
พอล

18
ฉันจะไม่แนะนำการรวมสควอชในกรณีนี้เนื่องจากไม่มีการบันทึกข้อมูลเกี่ยวกับสิ่งที่ถูกผสาน (เช่นเดียวกับ svn แต่ไม่มี mergeinfo ที่นี่)
Marius K

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

6
หลังจากที่คุณทำคุณสมบัตินี้เสร็จแล้วคุณไม่ควรรีบูตเป็นครั้งสุดท้ายก่อนที่จะรวม new_feature ไปเป็นผู้เชี่ยวชาญหรือไม่
softarn

17
ขั้นตอนการทำงานของคุณสูญเสียประวัติการกระทำทั้งหมดจากสาขาที่ถูกลบ :(
Max Nanasy

คำตอบ:


371

"ความขัดแย้ง" หมายถึง "การวิวัฒนาการแบบคู่ขนานของเนื้อหาเดียวกัน" ดังนั้นถ้ามัน "ไปสู่นรก" ในระหว่างการรวมนั่นหมายความว่าคุณมีวิวัฒนาการขนาดใหญ่ในไฟล์ชุดเดียวกัน

สาเหตุที่การคืนเงินนั้นดีกว่าการรวมกันคือ:

  • คุณเขียนประวัติการกระทำในท้องถิ่นของคุณกับเจ้านายคนหนึ่ง (จากนั้นนำงานของคุณไปใช้ใหม่แก้ไขข้อขัดแย้งใด ๆ แล้ว)
  • การรวมครั้งสุดท้ายจะเป็น "การกรอไปข้างหน้า" อย่างแน่นอนเพราะมันจะมีประวัติการกระทำของนายทั้งหมดรวมทั้งการเปลี่ยนแปลงของคุณเท่านั้นที่จะนำไปใช้ใหม่

ผมยืนยันว่าขั้นตอนการทำงานที่ถูกต้องในกรณีที่ว่า (วิวัฒนาการในการตั้งค่าทั่วไปของไฟล์) เป็นrebase แรกแล้วผสาน

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


ในหัวข้อนั้น (rebase แล้วรวมเวิร์กโฟลว์), barrapontoกล่าวถึงในความคิดเห็นสองโพสต์ที่น่าสนใจทั้งจากrandyfay.com :

ใช้เทคนิคนี้การทำงานของคุณเสมอไปที่ด้านบนของสาขาที่สาธารณะเช่นแพทช์ที่มี up-to-date HEADกับปัจจุบัน

(มีเทคนิคที่คล้ายคลึงกันสำหรับตลาดสด )


27
สำหรับเทคนิคที่ช่วยให้การรีบูตและการแบ่งปันดูsoftwareswirl.blogspot.com/2009/04/…
mhagger

2
randyfay.com/node/91และrandyfay.com/node/89ที่ยอดเยี่ยมอ่าน บทความเหล่านี้ทำให้ฉันเข้าใจว่าเวิร์กโฟลว์ของฉันทำงานอย่างไรและเวิร์กโฟลว์ในอุดมคตินั้นเป็นอย่างไร
Capi Etheriel

เพียงเพื่อให้มันตรงการรีบูทจากสาขาหลักไปยังท้องถิ่นของคุณนั้นเป็นพื้นฐานในการอัปเดตประวัติศาสตร์ใด ๆ ที่ท้องถิ่นของคุณอาจพลาดไปว่าเจ้านายมีความรู้เกี่ยวกับการรวมกลุ่มใด ๆ
hellatan

@dtan สิ่งที่ฉันอธิบายที่นี่คือการรีบูตเครื่องที่ด้านบนของต้นแบบ คุณไม่ได้อัปเดตประวัติในท้องถิ่นอย่างแน่นอน แต่ควรนำประวัติท้องถิ่นไปใช้ใหม่ที่ด้านบนของต้นแบบเพื่อแก้ไขความขัดแย้งภายในสาขาท้องถิ่น
VonC

386

TL; DR

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


เวิร์กโฟลว์ Rebase ไม่ดีกว่าสำหรับการแก้ไขข้อขัดแย้ง!

ฉันเป็นมืออาชีพมากสำหรับการล้างประวัติ อย่างไรก็ตามถ้าฉันมีข้อขัดแย้งฉันจะยกเลิกการรีบูททันทีและทำการผสานแทน! มันฆ่าฉันจริง ๆ ว่าผู้คนกำลังแนะนำเวิร์กโฟลว์การปฏิเสธเป็นทางเลือกที่ดีกว่าในการรวมเวิร์กโฟลว์สำหรับการแก้ไขข้อขัดแย้ง (ซึ่งเป็นสิ่งที่คำถามนี้เกี่ยวกับ)

ถ้ามันไป "all to hell" ในระหว่างการรวมมันจะไป "all to นรก" ในระหว่างการ rebase และอาจเป็นนรกอีกด้วย! นี่คือเหตุผล:

เหตุผล # 1: แก้ไขข้อขัดแย้งหนึ่งครั้งแทนที่จะเป็นหนึ่งครั้งสำหรับแต่ละการกระทำ

เมื่อคุณรีบูตแทนที่จะรวมคุณจะต้องทำการแก้ไขข้อขัดแย้งได้บ่อยเท่าที่คุณตกลงที่จะทำการรีบูทเพื่อความขัดแย้งแบบเดียวกัน!

สถานการณ์จริง

ฉันแยกสาขาออกจากต้นแบบเพื่อปรับโครงสร้างวิธีที่ซับซ้อนในสาขา งานการปรับโครงสร้างใหม่ของฉันประกอบด้วยงานทั้งหมด 15 ชิ้นเนื่องจากฉันทำงานเพื่อปรับโครงสร้างใหม่และรับการตรวจสอบโค้ด ส่วนหนึ่งของการเปลี่ยนโครงสร้างของฉันเกี่ยวข้องกับการแก้ไขแท็บและช่องว่างที่มีอยู่ในต้นแบบก่อนหน้านี้ สิ่งนี้จำเป็น แต่น่าเสียดายที่มันขัดแย้งกับการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นหลังจากนั้นกับวิธีการนี้ในต้นแบบ ในขณะที่ฉันกำลังทำงานเกี่ยวกับวิธีการนี้ใครบางคนทำการเปลี่ยนแปลงที่เรียบง่ายและถูกต้องตามกฎหมายกับวิธีเดียวกันในสาขาหลักที่ควรจะผสานกับการเปลี่ยนแปลงของฉัน

เมื่อถึงเวลาที่จะรวมสาขาของฉันกลับกับอาจารย์ฉันมีสองตัวเลือก:

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

git rebase: ฉันได้รับความขัดแย้งกับความมุ่งมั่นครั้งแรกของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับการกระทำที่สองของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่สามของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่สี่ของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่ห้าของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่หกของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับเจ็ดของฉันผูกมัด ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่แปดของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่เก้าของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับการกระทำที่สิบของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับการกระทำที่สิบเอ็ดของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่สิบสองของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่สิบสามของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับที่สิบสี่ของฉันผูกมัด ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป ฉันได้รับความขัดแย้งกับความมุ่งมั่นที่สิบห้าของฉัน ฉันแก้ไขข้อขัดแย้งและดำเนินการลดระดับต่อไป

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

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

เหตุผลที่ # 2: ด้วยการ rebase ไม่มีการเลิกทำ!

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

เมื่อคุณรวมสาขา git จะสร้างการคอมมิชชันที่สามารถยกเลิกหรือแก้ไขได้หากการแก้ไขข้อขัดแย้งไม่ดี แม้ว่าคุณได้ผลักการผสานที่ไม่ถูกต้องไปยัง repo สาธารณะ / เผด็จการคุณสามารถใช้git revertเพื่อเลิกทำการเปลี่ยนแปลงที่นำเสนอโดยการผสานและทำซ้ำการผสานอย่างถูกต้องในการกระทำที่ผสานใหม่

เมื่อคุณทำการรีบูทสาขาในกรณีที่มีแนวโน้มว่าการแก้ไขข้อขัดแย้งนั้นผิดพลาด ตอนนี้การคอมมิชชันทั้งหมดมีการผสานที่ไม่ดีและคุณไม่สามารถทำซ้ำ rebase * ได้ ที่ดีที่สุดคุณต้องย้อนกลับและแก้ไขข้อผูกพันที่ได้รับผลกระทบแต่ละรายการ ไม่สนุก.

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

* เป็นไปได้ที่จะยกเลิกการรีบูตถ้าคุณสามารถขุด refs เก่าออกจากบันทึกภายในของคอมไพล์หรือถ้าคุณสร้างสาขาที่สามซึ่งชี้ไปที่การคอมมิทครั้งล่าสุดก่อนทำการรีบูต

นำนรกออกจากการแก้ไขความขัดแย้ง: ใช้ diff3

ยกตัวอย่างความขัดแย้งนี้:

<<<<<<< HEAD
TextMessage.send(:include_timestamp => true)
=======
EmailMessage.send(:include_timestamp => false)
>>>>>>> feature-branch

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

diff3 เพื่อช่วยเหลือ!

git config --global merge.conflictstyle diff3

เมื่อคุณใช้ diff3 ความขัดแย้งใหม่แต่ละรายการจะมีส่วนที่ 3 ซึ่งเป็นบรรพบุรุษร่วมที่ผสาน

<<<<<<< HEAD
TextMessage.send(:include_timestamp => true)
||||||| merged common ancestor
EmailMessage.send(:include_timestamp => true)
=======
EmailMessage.send(:include_timestamp => false)
>>>>>>> feature-branch

ก่อนอื่นให้ตรวจสอบบรรพบุรุษที่รวมกัน จากนั้นเปรียบเทียบแต่ละด้านเพื่อพิจารณาเจตนาของแต่ละสาขา คุณจะเห็นว่า HEAD เปลี่ยน EmailMessage เป็น TextMessage ความตั้งใจของมันคือการเปลี่ยนคลาสที่ใช้เป็น TextMessage ผ่านพารามิเตอร์เดียวกัน นอกจากนี้คุณยังสามารถเห็นได้ว่าเจตนาของสาขาคุณลักษณะคือการส่งผ่านเท็จแทนที่จะเป็นจริงสำหรับตัวเลือก: include_timestamp หากต้องการรวมการเปลี่ยนแปลงเหล่านี้ให้รวมความตั้งใจของทั้งสอง:

TextMessage.send(:include_timestamp => false)

โดยทั่วไป:

  1. เปรียบเทียบบรรพบุรุษร่วมกับแต่ละสาขาและพิจารณาว่าสาขาใดมีการเปลี่ยนแปลงที่ง่ายที่สุด
  2. ใช้การเปลี่ยนแปลงแบบง่ายกับโค้ดเวอร์ชันของสาขาอื่นเพื่อให้มีทั้งการเปลี่ยนแปลงที่ง่ายและซับซ้อนยิ่งขึ้น
  3. ลบส่วนทั้งหมดของรหัสความขัดแย้งนอกเหนือจากส่วนที่คุณเพิ่งรวมการเปลี่ยนแปลงเข้าด้วยกัน

ทางเลือก: แก้ไขโดยใช้การเปลี่ยนแปลงของสาขาด้วยตนเอง

ในที่สุดความขัดแย้งบางอย่างก็น่ากลัวที่จะเข้าใจแม้จะเป็น diff3 สิ่งนี้เกิดขึ้นโดยเฉพาะอย่างยิ่งเมื่อ diff พบว่ามีสายร่วมกันที่ไม่ได้มีความหมายร่วมกัน (เช่น. กิ่งทั้งสองเกิดขึ้นจะมีบรรทัดว่างในที่เดียวกัน!) ตัวอย่างเช่นสาขาหนึ่งเปลี่ยนการเยื้องของร่างกายของคลาสหรือจัดลำดับวิธีการที่คล้ายกัน ในกรณีเหล่านี้กลยุทธ์การแก้ปัญหาที่ดีกว่าสามารถตรวจสอบการเปลี่ยนแปลงจากด้านใดด้านหนึ่งของการผสานและใช้ diff กับไฟล์อื่นด้วยตนเอง

เรามาดูกันว่าเราอาจแก้ไขข้อขัดแย้งในสถานการณ์ที่การรวมorigin/feature1ที่lib/message.rbขัดแย้งกันที่ไหน

  1. ตัดสินใจว่าสาขาที่เราเช็คเอาต์ในปัจจุบัน ( HEADหรือ--ours) หรือสาขาที่เรากำลังรวมอยู่ ( origin/feature1หรือ--theirs) เป็นการเปลี่ยนแปลงที่ง่ายกว่าในการใช้ การใช้ diff กับ triple dot ( git diff a...b) แสดงการเปลี่ยนแปลงที่เกิดขึ้นbนับตั้งแต่ความแตกต่างครั้งล่าสุดจากaหรือในคำอื่น ๆ เปรียบเทียบบรรพบุรุษของ a และ b กับ b

    git diff HEAD...origin/feature1 -- lib/message.rb # show the change in feature1
    git diff origin/feature1...HEAD -- lib/message.rb # show the change in our branch
    
  2. ตรวจสอบไฟล์เวอร์ชันที่ซับซ้อนมากขึ้น สิ่งนี้จะลบเครื่องหมายความขัดแย้งทั้งหมดและใช้ด้านที่คุณเลือก

    git checkout --ours -- lib/message.rb   # if our branch's change is more complicated
    git checkout --theirs -- lib/message.rb # if origin/feature1's change is more complicated
    
  3. เมื่อตรวจสอบการเปลี่ยนแปลงที่ซับซ้อนแล้วให้ดึงส่วนต่างของการเปลี่ยนแปลงที่ง่ายขึ้น (ดูขั้นตอนที่ 1) ใช้การเปลี่ยนแปลงต่าง ๆ จากสิ่งนี้กับไฟล์ที่ขัดแย้งกัน


4
การผสานความขัดแย้งทั้งหมดในครั้งเดียวจะทำงานได้ดีกว่าความมุ่งมั่นของแต่ละบุคคลอย่างไร ฉันได้รับปัญหาจากการรวมคอมมิทเดี่ยว (โดยเฉพาะจากคนที่ไม่ยอมแบ่งเป็นโลจิคัลส่วนและให้การทดสอบที่เพียงพอสำหรับการตรวจสอบ) นอกจากนี้การ rebase ก็ไม่ได้แย่ไปกว่าการผสานเมื่อมันมาถึงตัวเลือกการสำรองข้อมูลการใช้ rebase แบบโต้ตอบที่ชาญฉลาดและเครื่องมือเช่น tortoisegit (ซึ่งช่วยให้การเลือกที่รวมไว้) จะช่วยได้มาก
prusswan

8
ฉันรู้สึกว่าฉันพูดถึงเหตุผลใน # 1 หากการกระทำของแต่ละบุคคลไม่สอดคล้องกันอย่างมีเหตุผลเหตุผลทั้งหมดที่จะรวมสาขาที่สอดคล้องกันอย่างมีเหตุผลเพื่อให้คุณสามารถเข้าใจถึงความขัดแย้งได้จริง หากกระทำ 1 เป็นบั๊กและกระทำ 2 แก้ไขการรวมกระทำ 1 จะทำให้สับสน มีเหตุผลที่ถูกกฎหมายที่คุณอาจได้รับข้อขัดแย้ง 15 ข้อติดต่อกันอย่างที่ฉันได้กล่าวไว้ข้างต้น อาร์กิวเมนต์ของคุณสำหรับการปฏิเสธไม่เลวก็ค่อนข้างไม่มีมูลความจริง Rebase ผสมผสานการผสานที่ไม่ดีเข้ากับความมุ่งมั่นดั้งเดิมและไม่ทิ้งความมุ่งมั่นที่ดีไว้เพื่อให้คุณลองใหม่ ผสานทำ
Edward Anderson

6
ฉันเห็นด้วยกับคุณอย่างสมบูรณ์ nilbus โพสต์ที่ยอดเยี่ยม; ที่ล้างบางสิ่งบางอย่าง ฉันสงสัยว่า rerere จะช่วยได้ที่นี่แม้ว่า นอกจากนี้ขอขอบคุณสำหรับข้อเสนอแนะในการใช้ diff3 ฉันจะเปลี่ยนมันทันที
derick

45
+1 สำหรับการบอกฉันเกี่ยวกับ diff3 เพียงอย่างเดียว - บ่อยครั้งที่มองหาความขัดแย้งที่ไม่สามารถเข้าใจได้ว่าใครก็ตามที่รับผิดชอบจะไม่บอกฉันว่าบรรพบุรุษร่วมกันพูดอะไร ขอบคุณมาก.
จอห์น

4
นี่ควรเป็นคำตอบที่ยอมรับได้ เวิร์กโฟลว์การ rebase นั้นน่ากลัวเช่นกันเพราะมันซ่อนข้อเท็จจริงที่ว่ามีความแตกต่างกันอย่างมากใน codebase ในบางช่วงเวลาซึ่งอาจมีประโยชน์ที่จะรู้ว่าถ้าคุณต้องการที่จะเข้าใจวิธีการเขียนโค้ดที่คุณกำลังดูอยู่ ควรแยกกิ่งก้านสาขาเล็ก ๆ ที่ไม่ขัดแย้งกันเท่านั้น
Robert Rüger

32

ในเวิร์กโฟลว์ของฉันฉัน rebase มากที่สุด (และฉันพยายามทำบ่อย ๆ ไม่ปล่อยให้ความคลาดเคลื่อนสะสมมากลดจำนวนและความรุนแรงของการชนระหว่างกิ่ง)

อย่างไรก็ตามแม้จะอยู่ในขั้นตอนการทำงานที่ยึดตามการรีบูตเป็นส่วนใหญ่ แต่ก็มีที่สำหรับการผสาน

จำได้ว่าการผสานสร้างโหนดที่มีสองพาเรนต์จริง ตอนนี้ให้พิจารณาสถานการณ์ต่อไปนี้: ฉันมีคุณลักษณะอิสระสองอย่างคือการทำให้ A และ B เป็นอิสระและตอนนี้ต้องการพัฒนาเนื้อหาในสาขา C ซึ่งขึ้นอยู่กับทั้ง A และ B ในขณะที่ A และ B กำลังได้รับการตรวจสอบ

สิ่งที่ฉันทำคือต่อไปนี้:

  1. สร้าง (และชำระเงิน) สาขา C ด้านบนของ A
  2. รวมเข้ากับ B

ตอนนี้สาขา C รวมถึงการเปลี่ยนแปลงจาก A และ B และฉันสามารถพัฒนาต่อไปได้ ถ้าฉันทำการเปลี่ยนแปลงใด ๆ กับ A ดังนั้นฉันจะสร้างกราฟของกิ่งใหม่ด้วยวิธีต่อไปนี้:

  1. สร้างสาขา T ที่ด้านบนใหม่ของ A
  2. ผสาน T กับ B
  3. รีบูต C บน T
  4. ลบสาขา T

วิธีนี้ฉันสามารถรักษากราฟของกิ่งโดยพลการได้ แต่สิ่งที่ซับซ้อนกว่าสถานการณ์ที่อธิบายข้างต้นนั้นซับซ้อนเกินไปเนื่องจากไม่มีเครื่องมืออัตโนมัติที่จะทำการรีบูทเมื่อผู้ปกครองเปลี่ยน


1
คุณสามารถบรรลุเป้าหมายเดียวกันได้ด้วยการคืนเงินเพียงครั้งเดียว การผสานไม่จำเป็นจริงๆที่นี่ (ยกเว้นถ้าคุณไม่ต้องการทำซ้ำคอมมิชชัน - แต่ฉันแทบจะไม่เห็นว่าเป็นข้อโต้แย้ง)
odwl

1
แน่นอนฉันไม่ต้องการที่จะทำซ้ำการกระทำ ฉันต้องการรักษาโครงสร้างการทำงานของฉันให้สะอาดที่สุดเท่าที่จะทำได้ แต่นั่นเป็นเรื่องของรสนิยมส่วนตัวและไม่จำเป็นสำหรับทุกคน
Alex Gontmakher

ฉันเห็นด้วย 100% กับย่อหน้าแรก (@ คำตอบของเอ็ดเวิร์ดทำงานในกรณีที่ไม่เป็นเช่นนั้น แต่ฉันอยากให้โครงการทั่วโลกทำงานเหมือนที่คุณแนะนำ) ส่วนที่เหลือของคำตอบดูเหมือนว่าบิตลึกซึ้งในความรู้สึกว่าการทำงานใน C ขณะที่ A และ B มีความคืบหน้าเป็นที่เรียบร้อยแล้วเรียงลำดับของความเสี่ยง (อย่างน้อยเท่าที่มันจริงๆขึ้นอยู่กับ A และ B) และแม้กระทั่งในที่สุดคุณ อาจไม่คงการรวมตัวไว้ (C จะได้รับการลดระดับจากด้านบนสุด & ที่ยิ่งใหญ่ที่สุด)
Alois Mahdal

23

อย่าใช้ต้นกำเนิดการพุชแบบคอมไพล์ - มิเรอร์ภายใต้วงจรทั้งหมด

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

http://twitter.com/dysinger/status/1273652486


6
หรือไม่ทำสิ่งที่คุณไม่แน่ใจว่าผลลัพธ์จะเป็นอย่างไร เครื่องที่ฉันเคยดูแลระบบมี Instructions to this machine may lead to unintended consequences, loss of work/data, or even death (at the hands of the sysad). Remember that you are solely responsible for the consequences of your actions ใน MOTD
richo

ใช้มันหากคุณมี repo ที่มิเรอร์ (แม้ว่าในกรณีของฉันมันจะถูกเรียกใช้งานโดยผู้ใช้พิเศษที่ repo ต้นทางบน hook post-receive)
prusswan

14

ฉันมีคำถามหนึ่งข้อหลังจากอ่านคำอธิบายของคุณ: เป็นไปได้ไหมว่าคุณไม่เคยทำ

git checkout master
git pull origin
git checkout my_new_feature

ก่อนทำ 'git rebase / merge master' ในสาขาฟีเจอร์ของคุณ?

เนื่องจากสาขาหลักของคุณจะไม่อัปเดตโดยอัตโนมัติจากที่เก็บของเพื่อนของคุณ git pull originคุณจะต้องทำอย่างนั้นด้วย คือบางทีคุณอาจจะปฏิเสธจากสาขาหลักในท้องถิ่นที่ไม่มีวันเปลี่ยนแปลงเสมอไป? และจากนั้นมาเวลาผลักดันคุณกำลังผลักดันในพื้นที่เก็บข้อมูลที่มี (ท้องถิ่น) มุ่งมั่นที่คุณไม่เคยเห็นและทำให้การผลักดันล้มเหลว


13

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

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

คุณยังคงสามารถผลักดันสาขาการพัฒนาส่วนตัวของคุณไปยังที่เก็บระยะไกลเพื่อประโยชน์ในการสำรองข้อมูล แต่ผู้อื่นไม่ควรถือว่าสาขา "สาธารณะ" เนื่องจากคุณจะทำการรีบูท BTW คำสั่งที่ง่ายสำหรับการทำเช่นนี้คือgit push --mirror originคำสั่งที่ง่ายสำหรับการทำเช่นนี้คือ

บทความ ซอฟต์แวร์บรรจุภัณฑ์ที่ใช้ Gitนั้นเป็นงานที่ค่อนข้างดีที่อธิบายการแลกเปลี่ยนในการรวมกับการรีบูต มันเป็นบริบทที่แตกต่างกันเล็กน้อย แต่ผู้ว่าจ้างเหมือนกัน - โดยทั่วไปแล้วมันลงมาว่าสาขาของคุณเป็นสาธารณะหรือส่วนตัวและคุณวางแผนที่จะรวมพวกเขาเข้ากับการฉีดยา


1
ลิงก์ไปยังซอฟต์แวร์บรรจุภัณฑ์โดยใช้ git ไม่ทำงานอีกต่อไป ฉันหาลิงค์ที่ดีเพื่อแก้ไขคำตอบดั้งเดิมไม่ได้
Chetan

คุณไม่ควรทำมิเรอoriginร์คุณควรทำมิเรอร์ไปยังแหล่งเก็บข้อมูลสำรองเฉพาะชุดที่สาม
Miral

12

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

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

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

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


คุณหมายถึงว่า OP มีการปฏิเสธหรือผิดพลาดที่ยังไม่ได้เปิดในกระบวนการของเขาใช่ไหม?
krosenvold

8

“ แม้ว่าคุณจะเป็นนักพัฒนาเพียงคนเดียวที่มีสาขาเพียงไม่กี่แห่ง แต่ก็คุ้มค่าที่จะต้องใช้นิสัยในการใช้ rebase และผสานอย่างเหมาะสมรูปแบบการทำงานพื้นฐานจะมีลักษณะดังนี้:

  • สร้างสาขาใหม่ B จากสาขา A ที่มีอยู่

  • เพิ่ม / กระทำการเปลี่ยนแปลงในสาขา B

  • ปฏิเสธการอัปเดตจากสาขา A

  • รวมการเปลี่ยนแปลงจากสาขา B เข้ากับสาขา A "

https://www.atlassian.com/git/tutorials/merging-vs-rebasing/


7

จากสิ่งที่ฉันสังเกตเห็นการรวมคอมไพล์มีแนวโน้มที่จะแยกกิ่งไม้แม้หลังจากการรวมในขณะที่ rebase แล้วผสานรวมเป็นสาขาเดียว หลังออกมาสะอาดกว่ามากในขณะที่ในอดีตมันจะง่ายกว่าที่จะค้นหาว่าคอมมิชชันใดเป็นของสาขาใดแม้หลังจากรวมกันแล้ว


4

ด้วย Git ไม่มีกระบวนการทำงานที่ "ถูกต้อง" ใช้สิ่งที่ลอยเรือของคุณ อย่างไรก็ตามหากคุณได้รับความขัดแย้งอย่างต่อเนื่องเมื่อรวมสาขาเข้าด้วยกันบางทีคุณควรประสานความพยายามของคุณให้ดีขึ้นกับเพื่อนนักพัฒนาของคุณ? เสียงเหมือนคุณสองคนคอยแก้ไขไฟล์เดียวกัน นอกจากนี้ระวังคำหลักช่องว่างและการโค่นล้ม (เช่น "$ Id $" และอื่น ๆ )


0

ฉันใช้เวิร์กโฟลว์แบบ rebase เท่านั้นเพราะเห็นได้ชัดกว่า (ไม่ใช่เฉพาะใน GitKraken แต่ยังอยู่ใน Intellij และ In gitkแต่ฉันแนะนำให้ใช้ลำดับแรกสุด): คุณมีสาขามันมาจากต้นแบบและกลับไปยังต้นแบบ . เมื่อแผนภาพที่สะอาดและสวยงามคุณจะรู้ว่าอะไรจะไปนรกเลยทีเดียว

ป้อนคำอธิบายรูปภาพที่นี่

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

rebaseทำงานบนพื้นฐานของการกระทำแต่ละอย่าง

ซึ่งหมายความว่าหากคุณมี 15 คอมมิชชันที่เปลี่ยนบรรทัดเดียวกันกับ masterคุณต้องตรวจสอบ 15 ครั้งถ้าคุณไม่สควอช แต่สิ่งที่สำคัญคือผลลัพธ์สุดท้ายใช่ไหม?

ดังนั้นขั้นตอนการทำงานทั้งหมด:

  1. ชำระเงินmasterและดึงเพื่อให้แน่ใจว่าคุณมีเวอร์ชันล่าสุด

  2. จากนั้นสร้างสาขาใหม่

  3. ทำงานของคุณที่นั่นคุณสามารถทำหลาย ๆ ครั้งอย่างอิสระและผลักดันจากระยะไกลไม่ต้องกังวลเพราะเป็นสาขาของคุณ

  4. หากมีคนบอกคุณว่า "เฮ้การอนุมัติ PR / MR ของฉันได้รับการอนุมัติแล้วตอนนี้มันถูกรวมเข้ากับข้อมูลหลัก" คุณสามารถดึงข้อมูล / ดึงพวกเขาได้ คุณสามารถทำได้ทุกที่ทุกเวลาหรือในขั้นตอนที่ 6

  5. หลังจากทำงานทั้งหมดของคุณให้คอมมิชชันและถ้าคุณมีหลายคอมมิชชันให้สควอชพวกเขา (คืองานทั้งหมดของคุณและกี่ครั้งที่คุณเปลี่ยนบรรทัดของรหัสไม่สำคัญ; สิ่งสำคัญเพียงอย่างเดียวคือเวอร์ชันสุดท้าย) ผลักหรือไม่มันไม่สำคัญ

  6. Checkout เพื่อmaster, pullอีกครั้งเพื่อให้แน่ใจว่าคุณมีการล่าสุดmasterในท้องถิ่น แผนภาพของคุณควรคล้ายกับสิ่งนี้:

ป้อนคำอธิบายรูปภาพที่นี่

อย่างที่คุณเห็นคุณอยู่ในสาขาท้องถิ่นของคุณซึ่งมาจากสถานะที่ล้าสมัยในmasterขณะที่master(ทั้งในท้องถิ่นและระยะไกล) ได้ก้าวไปข้างหน้าพร้อมกับการเปลี่ยนแปลงของเพื่อนร่วมงานของคุณ

  1. ชำระเงินกลับไปที่สาขาของคุณและ rebase to master ตอนนี้คุณจะมีหนึ่งคอมมิชชันเท่านั้นดังนั้นคุณจึงแก้ข้อขัดแย้งได้เพียงครั้งเดียว (และใน GitKraken คุณต้องลากสาขาของคุณไปที่masterและเลือก "Rebase" อีกเหตุผลที่ฉันชอบมัน) หลังจากนั้นคุณจะ ชอบ:

ป้อนคำอธิบายรูปภาพที่นี่

  1. ดังนั้นตอนนี้คุณมีการเปลี่ยนแปลงทั้งหมดในล่าสุดmasterรวมกับการเปลี่ยนแปลงในสาขาของคุณ ตอนนี้คุณสามารถกดไปที่รีโมตของคุณและถ้าคุณกดมาก่อนคุณจะต้องกด Git จะบอกคุณว่าคุณไม่สามารถเดินหน้าอย่างรวดเร็ว เป็นเรื่องปกติเนื่องจากการ rebase คุณได้เปลี่ยนจุดเริ่มต้นของสาขาของคุณ แต่คุณไม่ควรกลัว:ใช้แรงอย่างชาญฉลาด ในที่สุดรีโมทก็เป็นสาขาของคุณดังนั้นคุณจะไม่ส่งผลกระทบmasterถึงแม้ว่าคุณจะทำอะไรผิด

  2. สร้าง PR / MR และรอจนกว่าจะได้รับอนุมัติ masterจะมีส่วนร่วมของคุณ ยินดีด้วย! ดังนั้นตอนนี้คุณสามารถชำระเงินmasterดึงการเปลี่ยนแปลงและลบสาขาท้องถิ่นของคุณเพื่อล้างไดอะแกรม ควรลบสาขาระยะไกลด้วยหากไม่ดำเนินการเมื่อคุณรวมเข้ากับต้นแบบ

แผนภาพสุดท้ายนั้นสะอาดและชัดเจนอีกครั้ง:

ป้อนคำอธิบายรูปภาพที่นี่

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.