อะไรคือวิธีที่ดีที่สุด (และปลอดภัยที่สุด) ในการผสานสาขา Git เข้ากับเจ้านาย

สาขาใหม่จากถูกสร้างขึ้นที่เราเรียกว่าmastertest

มีผู้พัฒนาหลายคนที่มุ่งมั่นmasterหรือสร้างสาขาอื่น ๆ และรวมเข้าด้วยกันในmasterภายหลัง

สมมติว่าการทำงานในtestคือการหลายวันและคุณต้องการอย่างต่อเนื่องเพื่อให้การปรับปรุงด้วยการกระทำภายในtestmaster

ฉันจะทำจากgit pull origin mastertest

คำถามที่ 1:นี่เป็นแนวทางที่ถูกต้องหรือไม่? นักพัฒนาคนอื่นสามารถทำงานกับไฟล์เดียวกันได้อย่างง่ายดายขณะที่ฉันทำงาน btw

งานของฉันในการจะทำและผมพร้อมที่จะผสานมันกลับไปtest masterนี่คือสองวิธีที่ฉันนึกได้:

A:

git checkout test
git pull origin master
git push origin test
git checkout master
git pull origin test 

B:

git checkout test
git pull origin master
git checkout master
git merge test

ฉันไม่ได้ใช้--rebaseเพราะจากความเข้าใจของฉันการรีบูตจะได้รับการเปลี่ยนแปลงจากmasterและสแต็คของฉันที่ด้านบนของมันดังนั้นมันสามารถเขียนทับการเปลี่ยนแปลงที่คนอื่นทำ

คำถามที่ 2:หนึ่งในสองวิธีนี้ถูกต้องหรือไม่ ความแตกต่างที่นั่นคืออะไร?

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

ฉันจะทำสิ่งนี้อย่างไร

git checkout master
git pull origin master
git merge test
git push origin master

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

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

นี่เป็นคำถามที่ใช้งานได้จริง แต่คำตอบทั้งหมดข้างต้นไม่สามารถนำไปใช้ได้จริง

ชอบ

git checkout master
git pull origin master
git merge test
git push origin master

วิธีนี้มีสองประเด็น :

1. มันไม่ปลอดภัยเพราะเราไม่รู้ว่ามีข้อขัดแย้งระหว่างสาขาทดสอบและสาขาหลักหรือไม่

2. มันจะ "บีบ" การทดสอบทั้งหมดที่ทำไว้ในการรวมหนึ่งคอมมิทบนมาสเตอร์ กล่าวคือในสาขาหลักเราไม่สามารถดูบันทึกการเปลี่ยนแปลงทั้งหมดของสาขาทดสอบ

ดังนั้นเมื่อเราสงสัยว่าจะมีความขัดแย้งเกิดขึ้นเราสามารถดำเนินการคอมไพล์ได้ดังนี้

git checkout test
git pull 
git checkout master
git pull
git merge --no-ff --no-commit test

การทดสอบmergeก่อนที่จะcommitหลีกเลี่ยงได้อย่างรวดเร็วไปข้างหน้ากระทำโดย--no-ff,

หากพบความขัดแย้งเราสามารถเรียกใช้git statusเพื่อตรวจสอบรายละเอียดเกี่ยวกับความขัดแย้งและพยายามแก้ไข

git status

เมื่อเราแก้ไขข้อขัดแย้งหรือถ้าไม่มีความขัดแย้งเราcommitและpushพวกเขา

git commit -m 'merge test branch'
git push

แต่วิธีนี้จะสูญเสียประวัติการเปลี่ยนแปลงที่บันทึกไว้ในสาขาการทดสอบและจะทำให้สาขาหลักยากสำหรับนักพัฒนาอื่น ๆ ที่จะเข้าใจประวัติของโครงการ

ดังนั้นวิธีที่ดีที่สุดคือเราต้องใช้rebaseแทนmerge(สมมติว่าในเวลานี้เราได้แก้ไขข้อขัดแย้งของสาขา)

ต่อไปนี้เป็นตัวอย่างง่ายๆสำหรับการดำเนินงานขั้นสูงโปรดดูที่http://git-scm.com/book/en/v2/Git-Branching-Rebasing

git checkout master
git pull
git checkout test
git pull
git rebase -i master
git checkout master
git merge test

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

สิ่งเดียวที่คุณต้องหลีกเลี่ยงคือห้ามใช้rebaseในสาขาสาธารณะเช่นเดียวกับสาขาหลัก

ไม่ต้องดำเนินการใดๆ ดังต่อไปนี้:

git checkout master
git rebase -i test

รายละเอียดสำหรับhttps://www.atlassian.com/git/tutorials/merging-vs-rebasing/the-golden-rule-of-rebasing

ภาคผนวก:

• หากคุณไม่แน่ใจเกี่ยวกับการดำเนินการรีบูตโปรดดูที่: https://git-scm.com/book/en/v2/Git-Branching-Rebasing

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

วิธีการปกติในขณะที่การพัฒนาคือ

git checkout master
git pull
git checkout test
git log master.. # if you're curious
git merge origin/test # to update your local test from the fetch in the pull earlier

เมื่อคุณพร้อมที่จะรวมกลับเข้าสู่โหมดมาสเตอร์

git checkout master
git log ..test # if you're curious
git merge test
git push

หากคุณกังวลว่าจะมีบางสิ่งบางอย่างเกิดขึ้นระหว่างการรวมgit merge --abortตัว

ใช้การผลักแล้วดึงเป็นวิธีการรวมเป็นโง่ ฉันก็ไม่แน่ใจเหมือนกันว่าเพราะอะไร

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

นอกจากคำตอบของ KingCrunchesฉันขอแนะนำให้ใช้

git checkout master
git pull origin master
git merge --squash test
git commit
git push origin master

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

แก้ไข: คุณอาจสนใจ

• ในคอมไพล์อะไรคือความแตกต่างระหว่างการผสาน - สควอชและการรีบูต
• การรวมกับการรีบูต
• วิธีการ Rebase คำขอดึง

ดังนั้นใน GitHub ฉันเลยทำสิ่งต่อไปนี้สำหรับสาขาฟีเจอร์mybranch:

รับล่าสุดจากแหล่งกำเนิด

$ git checkout master
$ git pull origin master

ค้นหาแฮชฐานการผสาน:

$ git merge-base mybranch master
c193ea5e11f5699ae1f58b5b7029d1097395196f

$ git checkout mybranch
$ git rebase -i c193ea5e11f5699ae1f58b5b7029d1097395196f

ตอนนี้ตรวจสอบให้แน่ใจเท่านั้นแรกคือpickส่วนที่เหลือคือs:

pick 00f1e76 Add first draft of the Pflichtenheft
s d1c84b6 Update to two class problem
s 7486cd8 Explain steps better

ถัดไปเลือกข้อความยืนยันที่ดีมากและกดไปที่ GitHub ทำการร้องขอการดึงแล้ว

หลังจากการรวมคำขอดึงคุณสามารถลบภายใน:

$ git branch -d mybranch

และบน GitHub

$ git push origin :mybranch

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

รับปริญญาโทและสาขาล่าสุด:

git checkout master
git pull --rebase origin master
git checkout <branch_name>
git pull --rebase origin <branch_name>

ผสานสาขาบนสุดของปรมาจารย์:

git checkout <branch_name>
git rebase master

ทางเลือก: หากคุณพบข้อขัดแย้งระหว่างการ Rebase:

ก่อนอื่นให้แก้ไขข้อขัดแย้งในไฟล์ แล้ว:

git add .
git rebase --continue

ผลักดันสาขาที่ถูกปฏิเสธของคุณ:

git push origin <branch_name>

ตอนนี้คุณมีสองตัวเลือก:

• A) สร้าง PR (เช่นใน GitHub) และรวมมันเข้ากับ UI
• B) ย้อนกลับไปที่บรรทัดคำสั่งและผสานสาขาเป็นหลัก

git checkout master
git merge --no-ff <branch_name>
git push origin master

เสร็จสิ้น

นี่คือเวิร์กโฟลว์ที่ฉันใช้ในงานของฉันกับทีม สถานการณ์เป็นไปตามที่คุณอธิบาย อย่างแรก, เมื่อฉันทำงานเสร็จแล้ว, ฉันทำการtestrebase กับ master เพื่อดึงสิ่งที่ถูกเพิ่มไปยัง master ในช่วงเวลาที่ฉันทำงานในtestสาขา

git pull -r upstream master

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

git checkout master
git pull origin master
# Merge branch test into master
git merge test

หลังจากผสานถ้าไฟล์มีการเปลี่ยนแปลงแล้วเมื่อคุณผสานมันจะผ่านข้อผิดพลาดของ "แก้ไขความขัดแย้ง"

ดังนั้นก่อนอื่นคุณต้องแก้ไขข้อขัดแย้งทั้งหมดของคุณก่อนจากนั้นคุณต้องยอมรับการเปลี่ยนแปลงทั้งหมดอีกครั้งแล้วกด

git push origin master

นี่เป็นสิ่งที่ดีกว่าถ้าใครได้ทำการเปลี่ยนแปลงในสาขาการทดสอบเพราะเขารู้ว่าเขาได้ทำการเปลี่ยนแปลงอะไร

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

ดังนั้นโดยไม่ต้องตรวจสอบmasterฉันจะ:

git fetch origin
git rebase -i origin/master
# ...solve possible conflicts here

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

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

git checkout test
git pull
git checkout master
git pull origin master
git merge test
git push origin master

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

git checkout master
git pull

ไม่จำเป็นต้องเช็คเอาท์ก่อน rebase ทำในสิ่งที่ถูกต้องโดยมีสองอาร์กิวเมนต์

git rebase master test  

git checkout master
git merge test

git push โดยค่าเริ่มต้นจะผลักสาขาทั้งหมดที่มีอยู่ที่นี่และในระยะไกล

git push
git checkout test

ตามที่ชื่อกล่าวว่า "วิธีที่ดีที่สุด" ฉันคิดว่าเป็นความคิดที่ดีที่จะพิจารณา กลยุทธ์การรวมความอดทน

จาก: https://git-scm.com/docs/merge-strategies

ด้วยตัวเลือกนี้ 'ผสานรวมซ้ำ' ใช้เวลาเพิ่มเล็กน้อยเพื่อหลีกเลี่ยงความเสียหายที่เกิดขึ้นเนื่องจากเส้นที่ไม่สำคัญ (เช่นวงเล็บปีกกาจากฟังก์ชั่นที่แตกต่าง) ใช้สิ่งนี้เมื่อกิ่งที่จะรวมถูกแยกออกจากกันอย่างดุเดือด ดูเพิ่มเติม git-diff [1] - ความอดทน

การใช้งาน:

git fetch
git merge -s recursive -X patience origin/master

Git Alias

ฉันใช้นามแฝงนี้เสมอเช่นเรียกใช้ครั้งเดียว:

 git config --global alias.pmerge 'merge -s recursive -X patience'

ตอนนี้คุณสามารถทำได้:

git fetch
git pmerge origin/master

นี่คือจาก GitLab: เพียงทำตามคำแนะนำ:

ฉันจะตอบตามการพัฒนาและคุณลักษณะสาขา

หากคุณอยู่ในสาขาฟีเจอร์และจำเป็นต้องอัปเดตด้วยคำสั่งพัฒนาด้านล่าง: git checkout พัฒนา git pull git checkout คุณสมบัติ / xyz git merge พัฒนา

ตอนนี้คุณสมบัติของคุณได้รับการอัพเดตด้วยการพัฒนาคุณสามารถผลักดันการเปลี่ยนแปลงของคุณได้