git-rebase - ออนไลน์ใน Cloud

โครงการ:

ชื่อ

git-rebase - ฟอร์เวิร์ดพอร์ตโลคัลคอมมิตกับอัปสตรีม head . ที่อัปเดต

เรื่องย่อ

คอมไพล์ รีเบส [-ฉัน | --โต้ตอบ] [ตัวเลือก] [--exec ] [--ไปยัง ]
[ [ ]]
คอมไพล์ รีเบส [-ฉัน | --โต้ตอบ] [ตัวเลือก] [--exec ] [--ไปยัง ]
--ราก[ ]
คอมไพล์ รีเบส --ต่อ | --ข้าม | --ยกเลิก | --edit-todo

DESCRIPTION

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

ถ้า ไม่ได้ระบุ ต้นน้ำที่กำหนดค่าในสาขา .remote และ
สาขา. จะใช้ตัวเลือก .merge (ดู git-config.php(1) เพื่อดูรายละเอียด) และ
ถือว่าตัวเลือก --fork-point หากคุณไม่ได้อยู่ในสาขาใดหรือหากปัจจุบัน
แบรนช์ไม่มีอัปสตรีมที่กำหนดค่าไว้ รีเบสจะยกเลิก

การเปลี่ยนแปลงทั้งหมดที่ทำโดยคอมมิตในสาขาปัจจุบันแต่ไม่อยู่ใน รอดแล้ว
สู่พื้นที่ชั่วคราว นี่คือชุดของคอมมิตเดียวกันกับที่จะแสดงโดย git log
..ศีรษะ; หรือโดย git log 'fork_point'..HEAD ถ้า --fork-point ทำงานอยู่ (ดู
คำอธิบายเกี่ยวกับ --fork-point ด้านล่าง); หรือโดย git log HEAD หากระบุตัวเลือก --root

สาขาปัจจุบันถูกรีเซ็ตเป็น , หรือ หากมีการระบุตัวเลือก --onto
สิ่งนี้มีผลเหมือนกับการรีเซ็ต git --hard (หรือ ). ORIG_HEAD คือ
กำหนดให้ชี้ไปที่ปลายกิ่งก่อนทำการรีเซ็ต

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

เป็นไปได้ว่าความล้มเหลวในการผสานจะทำให้กระบวนการนี้ไม่สมบูรณ์
อัตโนมัติ. คุณจะต้องแก้ไขความล้มเหลวในการผสานดังกล่าวและเรียกใช้ git rebase --continue
อีกทางเลือกหนึ่งคือการข้ามการคอมมิตที่ทำให้การผสานล้มเหลวด้วย git rebase
--ข้าม. เพื่อตรวจสอบต้นฉบับ และลบไฟล์ทำงาน .git/rebase-apply
ใช้คำสั่ง git rebase --abort แทน

สมมติว่ามีประวัติต่อไปนี้และสาขาปัจจุบันคือ "หัวข้อ":

A---B---C หัวข้อ
/
D---E---F---G มาสเตอร์

จากจุดนี้ ผลลัพธ์ของคำสั่งใดคำสั่งหนึ่งต่อไปนี้:

คอมไพล์รีเบสมาสเตอร์
git rebase หัวข้อหลัก

อยากจะเป็น:

หัวข้อ A'-B'--C'
/
D---E---F---G มาสเตอร์

หมายเหตุ: แบบฟอร์มหลังเป็นเพียงหัวข้อย่อยของ git checkout ตามด้วย git rebase
ผู้เชี่ยวชาญ. เมื่อ rebase ออกจากหัวข้อจะยังคงเป็นสาขาที่เช็คเอาท์

หากสาขาต้นน้ำมีการเปลี่ยนแปลงที่คุณได้ทำไว้อยู่แล้ว (เช่น เนื่องจากคุณส่ง a
แพตช์ที่ใช้อัพสตรีม) จากนั้นคอมมิตนั้นจะถูกข้ามไป เช่น วิ่ง
git rebase master ในประวัติต่อไปนี้ (ซึ่ง A' และ A แนะนำชุดเดียวกันของ
เปลี่ยนแปลงแต่มีข้อมูลผู้มอบที่แตกต่างกัน):

A---B---C หัวข้อ
/
D---E---A'---F มาสเตอร์

จะส่งผลให้:

B'---C' หัวข้อ
/
D---E---A'---F มาสเตอร์

นี่คือวิธีที่คุณจะย้ายสาขาหัวข้อโดยอิงจากสาขาหนึ่งไปอีกสาขาหนึ่งเพื่อแกล้ง
ที่คุณแยกสาขาหัวข้อจากสาขาหลังโดยใช้ rebase --onto

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

o---o---o---o---o อาจารย์
\
o---o---o---o---o ต่อไป
\
o---o---o หัวข้อ

เราต้องการที่จะทำให้ หัวข้อ แยกจากสาขา เจ้านาย; ตัวอย่างเช่นเนื่องจากฟังก์ชั่นบน
ที่ หัวข้อ ขึ้นอยู่ถูกรวมเข้าเป็นมีเสถียรภาพมากขึ้น เจ้านาย สาขา. เราต้องการให้ต้นไม้ของเราเป็น
มีลักษณะดังนี้:

o---o---o---o---o อาจารย์
- -
| o'-o'--o' หัวข้อ
\
o---o---o---o---o ต่อไป

เราสามารถรับได้โดยใช้คำสั่งต่อไปนี้:

git rebase --onto master หัวข้อถัดไป

อีกตัวอย่างหนึ่งของตัวเลือก --onto คือการรีเบสส่วนหนึ่งของสาขา ถ้าเรามีดังต่อไปนี้
สถานการณ์:

H---I---J หัวข้อB
/
E---F---G หัวข้อA
/
A---B---C---D มาสเตอร์

แล้วคำสั่ง

git rebase --onto master topicA หัวข้อB

จะส่งผลให้:

H'--ฉัน'--J' topicB
/
| E---F---G หัวข้อA
|/
A---B---C---D มาสเตอร์

สิ่งนี้มีประโยชน์เมื่อ topicB ไม่ได้ขึ้นอยู่กับ topicA

คอมมิทช่วงหนึ่งสามารถลบออกได้ด้วยการรีเบส หากเรามีสถานการณ์ดังต่อไปนี้:

E---F---G---H---I---J หัวข้อA

แล้วคำสั่ง

git rebase --onto topicA~5 หัวข้อA~3 หัวข้อA

จะส่งผลให้มีการยกเลิกการกระทำ F และ G:

E---H'---ฉัน'---J' หัวข้อA

สิ่งนี้มีประโยชน์หาก F และ G มีข้อบกพร่องในทางใดทางหนึ่ง หรือไม่ควรเป็นส่วนหนึ่งของหัวข้อ A บันทึก
ที่อาร์กิวเมนต์เพื่อ --onto และ พารามิเตอร์สามารถเป็น commit-ish ใดๆ ที่ถูกต้องได้

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

git add

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

git rebase -- ดำเนินการต่อ

หรือคุณสามารถเลิกทำการ คอมไพล์ รีเบส กับ

git rebase --ยกเลิก

การกำหนดค่า

รีเบส.สเตท
จะแสดง diffstat ของสิ่งที่เปลี่ยนแปลงอัปสตรีมตั้งแต่การรีเบสครั้งล่าสุดหรือไม่ เท็จโดย
ค่าเริ่มต้น.

rebase.autoSquash
หากตั้งค่าเป็น true enable --ออโต้สควอช ตัวเลือกโดยค่าเริ่มต้น

rebase.autoStash
หากตั้งค่าเป็น true enable --เก็บอัตโนมัติ ตัวเลือกโดยค่าเริ่มต้น

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

rebase.instructionFormat
รูปแบบรายการคอมมิตที่กำหนดเองเพื่อใช้ระหว่าง an --เชิงโต้ตอบ รีเบส

OPTIONS

--ไปยัง
จุดเริ่มต้นที่จะสร้างคอมมิตใหม่ หากตัวเลือก --onto ไม่ใช่
ระบุจุดเริ่มต้นคือ . อาจเป็นการคอมมิตที่ถูกต้อง ไม่ใช่แค่ an
ชื่อสาขาที่มีอยู่

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


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


สาขางาน; ค่าเริ่มต้นเป็น HEAD

--ดำเนินต่อ
เริ่มกระบวนการปรับฐานใหม่หลังจากแก้ไขข้อขัดแย้งในการผสาน

--ยกเลิก
ยกเลิกการดำเนินการรีเบสและรีเซ็ต HEAD เป็นสาขาเดิม ถ้า เคยเป็น
ระบุเมื่อเริ่มต้นการดำเนินการ rebase จากนั้น HEAD จะถูกรีเซ็ตเป็น .
มิฉะนั้น HEAD จะถูกรีเซ็ตไปยังตำแหน่งเดิมเมื่อการดำเนินการรีเบสเริ่มต้นขึ้น

--ให้ว่าง
รักษาความมุ่งมั่นที่ไม่เปลี่ยนแปลงอะไรจากผู้ปกครองในผลลัพธ์

--ข้าม
เริ่มต้นกระบวนการปรับฐานใหม่โดยข้ามแพตช์ปัจจุบัน

--แก้ไขสิ่งที่ต้องทำ
แก้ไขรายการสิ่งที่ต้องทำระหว่างการรีเบสเชิงโต้ตอบ

-m, --ผสาน
ใช้กลยุทธ์การรวมเพื่อรีเบส เมื่อใช้กลยุทธ์การรวมแบบเรียกซ้ำ (ค่าเริ่มต้น)
สิ่งนี้ทำให้ rebase รับรู้ถึงการเปลี่ยนชื่อที่ฝั่งต้นน้ำ

โปรดทราบว่าการรวมรีเบสทำงานโดยการเล่นซ้ำแต่ละรายการจากสาขาการทำงานที่อยู่ด้านบน
ของ สาขา. ด้วยเหตุนี้ เมื่อเกิดการแย่งชิงกันขึ้น ฝ่าย
รายงานเป็น แบก เป็นซีรีส์ที่สร้างใหม่มาจนถึงตอนนี้ เริ่มด้วย , และ ของพวกเขา is
สาขาการทำงาน กล่าวอีกนัยหนึ่งคือสลับข้าง

-NS , --กลยุทธ์=
ใช้กลยุทธ์การรวมที่กำหนด หากไม่มี -s ตัวเลือก คอมไพล์ ผสาน-เรียกซ้ำ ถูกนำมาใช้
แทนที่. นี่หมายความว่า --ผสาน

เพราะ คอมไพล์ รีเบส เล่นซ้ำแต่ละคอมมิชชันจากสาขาการทำงานที่ด้านบนของ
สาขาโดยใช้กลยุทธ์ที่กำหนดโดยใช้ แบก กลยุทธ์เพียงแค่ทิ้ง
แพทช์ทั้งหมดจาก ซึ่งไม่ค่อยสมเหตุสมผล

-NS , --กลยุทธ์-ตัวเลือก=
ผ่าน ไปจนถึงกลยุทธ์การรวม นี่หมายความว่า --merge และ if
ไม่ได้ระบุกลยุทธ์ - แบบเรียกซ้ำ สังเกตการกลับรายการของ แบก และ ของพวกเขา as
ระบุไว้ข้างต้นสำหรับตัวเลือก -m

-NS[ ], --gpg-สัญญาณ[= ]
สัญญา GPG ตกลง อาร์กิวเมนต์ keyid เป็นทางเลือกและเป็นค่าเริ่มต้นของคอมมิทเตอร์
ตัวตน; หากระบุไว้จะต้องติดอยู่กับตัวเลือกโดยไม่มีช่องว่าง

-q, --เงียบ
เงียบไว้ หมายถึง --no-stat

-v, --เวอร์โบส
ละเอียด. หมายถึง --stat

--สถิติ
แสดงความแตกต่างของสิ่งที่เปลี่ยนแปลงต้นน้ำตั้งแต่การรีเบสครั้งล่าสุด ดิฟสแตทก็เช่นกัน
ควบคุมโดยตัวเลือกการกำหนดค่า rebase.stat

-n, --ไม่มีสถานะ
อย่าแสดง diffstat เป็นส่วนหนึ่งของกระบวนการรีเบส

--ไม่-ยืนยัน
อ็อพชันนี้ข้าม hook pre-rebase ดูสิ่งนี้ด้วย gitooks(5)

--ตรวจสอบ
อนุญาตให้เรียกใช้ pre-rebase hook ซึ่งเป็นค่าดีฟอลต์ สามารถใช้ตัวเลือกนี้เพื่อ
แทนที่ --ไม่-ตรวจสอบ ดูสิ่งนี้ด้วย gitooks(5)

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

-f, --force-rebase
บังคับให้ทำการรีเบสแม้ว่าสาขาปัจจุบันจะเป็นปัจจุบันและคำสั่งที่ไม่มี
--force จะกลับมาโดยไม่ทำอะไรเลย

คุณอาจพบว่าสิ่งนี้ (หรือ --no-ff กับ rebase แบบโต้ตอบ) มีประโยชน์หลังจากคืนค่า a
การรวมสาขาของหัวข้อ เนื่องจากตัวเลือกนี้จะสร้างสาขาของหัวข้อใหม่ด้วยการคอมมิตใหม่ ดังนั้น
สามารถ remerged ได้สำเร็จโดยไม่ต้อง "ย้อนกลับการพลิกกลับ" (ดู
ย้อนกลับ-a-ผิดพลาดผสาน How-To[1] สำหรับรายละเอียด)

--fork-point --no-fork-point
ใช้ reflog เพื่อค้นหาบรรพบุรุษร่วมกันที่ดีกว่าระหว่าง และ เมื่อไร
กำลังคำนวณว่าคอมมิตใดได้รับการแนะนำโดย .

เมื่อ --fork-point ทำงานอยู่ ทางแยก จะใช้แทน ถึง
คำนวณชุดของคอมมิตที่จะรีเบส โดยที่ ทางแยก เป็นผลจาก git
รวมฐาน --fork-point คำสั่ง (ดู git-ผสานฐาน(1)). ถ้า
ทางแยก จบลงด้วยความว่างเปล่า จะใช้เป็นทางเลือก

ถ้าอย่างใดอย่างหนึ่ง หรือ --root ถูกกำหนดในบรรทัดคำสั่ง จากนั้นค่าดีฟอลต์คือ
--no-fork-point มิฉะนั้น ค่าเริ่มต้นคือ --fork-point

--ignore-ช่องว่าง, --ช่องว่าง=
ธงเหล่านี้จะถูกส่งต่อไปยัง คอมไพล์ ใช้ โปรแกรม (ดู git-สมัคร(1)) ที่ใช้
ปะ. เข้ากันไม่ได้กับตัวเลือก --อินเทอร์แอกทีฟ

--committer-date-is-author-date, --ignore-date
แฟล็กเหล่านี้จะถูกส่งต่อไปยัง คอมไพล์ am เพื่อเปลี่ยนวันที่ของการคอมมิตใหม่ได้อย่างง่ายดาย
(ดู git-am(1)). เข้ากันไม่ได้กับตัวเลือก --อินเทอร์แอกทีฟ

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

รูปแบบรายการกระทำสามารถเปลี่ยนแปลงได้โดยการตั้งค่าตัวเลือกการกำหนดค่า
rebase.instructionFormat รูปแบบคำสั่งที่กำหนดเองจะมี
แฮชคอมมิชชันแบบยาวที่ต่อท้ายรูปแบบ

-p, --อนุรักษ์-ผสาน
สร้างการผสานใหม่แทนที่จะทำให้ประวัติแบนราบโดยการเล่นซ้ำเป็นการคอมมิตการผสาน
แนะนำตัว ผสานการแก้ไขข้อขัดแย้งหรือการแก้ไขด้วยตนเองเพื่อรวมคอมมิต
ไม่ได้รับการเก็บรักษาไว้

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

-NS , --exec
ต่อท้าย "exec " หลังจากแต่ละบรรทัดสร้างคอมมิตในประวัติสุดท้าย จะ
ถูกตีความว่าเป็นคำสั่งเชลล์ตั้งแต่หนึ่งคำสั่งขึ้นไป

ตัวเลือกนี้สามารถใช้ได้เฉพาะกับตัวเลือก --อินเทอร์แอกทีฟ (โปรดดู โหมดโต้ตอบ
ด้านล่าง)

คุณสามารถรันคำสั่งได้หลายคำสั่งโดยใช้หนึ่งอินสแตนซ์ของ --exec กับ many
คำสั่ง:

git rebase -i --exec "cmd1 && cmd2 && ..."

หรือโดยให้มากกว่าหนึ่ง --exec:

git rebase -i --exec "cmd1" --exec "cmd2" --exec ...

หากใช้ --autosquash บรรทัด "exec" จะไม่ถูกต่อท้ายสำหรับตัวกลาง
คอมมิต และจะปรากฏต่อท้ายชุดสควอช/ฟิกซ์อัพแต่ละชุดเท่านั้น

--ราก
รีเบสคอมมิตทั้งหมดสามารถเข้าถึงได้จาก แทนที่จะจำกัดพวกเขาด้วย an
. สิ่งนี้ทำให้คุณสามารถรีเบสการคอมมิตของรูทบนแบรนช์ได้ เมื่อใช้กับ
--onto มันจะข้ามการเปลี่ยนแปลงที่มีอยู่แล้วใน (แทน )
ในขณะที่ไม่มี --onto มันจะทำงานในทุกการเปลี่ยนแปลง เมื่อใช้ร่วมกับทั้งสองอย่าง
--onto และ --preserve-merges, ทั้งหมด การคอมมิตรูตจะถูกเขียนใหม่ให้มี เช่น
ผู้ปกครองแทน

--autosquash --no-autosquash
เมื่อข้อความบันทึกการคอมมิตขึ้นต้นด้วย "squash! ..." (หรือ "fixup! ...") และมี
คอมมิตที่ชื่อขึ้นต้นด้วย ... แก้ไขรายการสิ่งที่ต้องทำของ .โดยอัตโนมัติ
rebase -i เพื่อให้การคอมมิตที่ทำเครื่องหมายสำหรับการสควอชมาทันทีหลังจากคอมมิตที่จะเป็น
แก้ไขและเปลี่ยนการกระทำของการกระทำที่ย้ายจากการเลือกเป็นสควอช (หรือการแก้ไข)
ละเว้น "fixup! " หรือ "squash! " ที่ตามมาหลังจากครั้งแรก ในกรณีที่คุณอ้างถึง an
การแก้ไข/สควอชก่อนหน้าด้วย git commit --fixup/--squash

ตัวเลือกนี้ใช้ได้เฉพาะเมื่อ --เชิงโต้ตอบ ใช้ตัวเลือก

ถ้า --ออโต้สควอช เปิดใช้งานตัวเลือกโดยค่าเริ่มต้นโดยใช้ตัวแปรการกำหนดค่า
rebase.autoSquash ตัวเลือกนี้สามารถใช้เพื่อแทนที่และปิดใช้งานการตั้งค่านี้

--autostash, --no-autostash
สร้างที่เก็บชั่วคราวโดยอัตโนมัติก่อนที่การดำเนินการจะเริ่ม และนำไปใช้หลังจาก
การดำเนินการสิ้นสุดลง ซึ่งหมายความว่าคุณสามารถเรียกใช้การรีเบสบนเวิร์กทรีที่สกปรกได้ อย่างไรก็ตาม,
ใช้ด้วยความระมัดระวัง: แอปพลิเคชั่นซ่อนสุดท้ายหลังจากการรีเบสสำเร็จอาจส่งผลให้
ความขัดแย้งที่ไม่สำคัญ

--no-ff
ด้วย --interactive, cherry-pick คอมมิทที่อิงตามใหม่ทั้งหมดแทนที่จะส่งต่ออย่างรวดเร็ว
ที่ไม่เปลี่ยนแปลง สิ่งนี้ทำให้มั่นใจได้ว่าประวัติทั้งหมดของสาขาที่ถูกรีเบสคือ
ประกอบด้วยคอมมิชชันใหม่

หากไม่มี --interactive นี่เป็นคำพ้องความหมายสำหรับ --force-rebase

คุณอาจพบว่าสิ่งนี้มีประโยชน์หลังจากคืนค่าการรวมสาขาของหัวข้อ ตามตัวเลือกนี้
สร้างสาขาของหัวข้อใหม่ด้วยการคอมมิตใหม่เพื่อให้สามารถรวมใหม่ได้สำเร็จ
โดยไม่ต้อง "ย้อนกลับ" (ดู ย้อนกลับ-a-ผิดพลาดผสาน How-To[1] สำหรับ
รายละเอียด).

ผสาน กลยุทธ์

กลไกการผสาน (คำสั่ง git merge และ git pull) ช่วยให้แบ็กเอนด์ ผสาน กลยุทธ์
ให้เลือกด้วยตัวเลือก -s กลยุทธ์บางอย่างสามารถใช้ตัวเลือกของตนเองได้ ซึ่งสามารถ
ผ่านการให้ -X อาร์กิวเมนต์เพื่อ git merge และ/หรือ git pull

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

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

พื้นที่ ซ้ำ กลยุทธ์สามารถใช้ตัวเลือกต่อไปนี้:

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

สิ่งนี้ไม่ควรสับสนกับ แบก กลยุทธ์การผสานซึ่งไม่ได้ดู
ในสิ่งที่ต้นไม้อื่นมีอยู่เลย มันละทิ้งทุกอย่างที่ต้นไม้ต้นอื่นทำ
ภาษณ์ ของเรา ประวัติศาสตร์มีทุกสิ่งที่เกิดขึ้นในนั้น

ของพวกเขา
นี่คือสิ่งที่ตรงกันข้ามกับ แบก.

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

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

ละเว้นช่องว่างการเปลี่ยนแปลง, ละเว้นช่องว่างทั้งหมด, ละเว้น-อวกาศ-at-eol
ถือว่าเส้นที่มีการเปลี่ยนช่องว่างประเภทที่ระบุไม่เปลี่ยนแปลงสำหรับ
เห็นแก่การรวมสามทาง การเปลี่ยนแปลงช่องว่างผสมกับการเปลี่ยนแปลงอื่นๆ ในบรรทัด
ไม่ถูกละเลย ดูสิ่งนี้ด้วย git-diff(1) -b, -w และ --ignore-space-at-eol

· ถ้า ของพวกเขา เวอร์ชันแนะนำการเปลี่ยนแปลงช่องว่างในบรรทัดเท่านั้น ของเรา รุ่นคือ
ใช้แล้ว;

· ถ้า ของเรา รุ่นแนะนำการเปลี่ยนแปลงช่องว่างแต่ ของพวกเขา รุ่นรวมถึงa
การเปลี่ยนแปลงที่สำคัญ, ของพวกเขา ใช้เวอร์ชัน

· มิฉะนั้น การผสานจะดำเนินการตามปกติ

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

ไม่สร้างมาตรฐานใหม่
ปิดใช้งานตัวเลือกการปรับค่าปกติ สิ่งนี้จะแทนที่ merge.renormalize
ตัวแปรการกำหนดค่า

เปลี่ยนชื่อ-threshold=
ควบคุมเกณฑ์ความคล้ายคลึงกันที่ใช้สำหรับการตรวจหาการเปลี่ยนชื่อ ดูสิ่งนี้ด้วย git-diff(1)
-NS.

ทรีย่อย[= ]
ตัวเลือกนี้เป็นรูปแบบขั้นสูงของ ทรีย่อย กลยุทธ์ที่กลยุทธ์ทำให้
เดาว่าต้องย้ายต้นไม้สองต้นมารวมกันอย่างไรเมื่อรวมกัน
แต่เส้นทางที่ระบุจะถูกนำหน้า (หรือถอดออกจากจุดเริ่มต้น) เพื่อสร้าง
รูปร่างของต้นไม้สองต้นให้เข้าคู่กัน

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

แบก
สิ่งนี้จะแก้ไขหัวจำนวนเท่าใดก็ได้ แต่ต้นไม้ผลลัพธ์ของการผสานจะเป็นเช่นนั้นเสมอ
ของหัวหน้าสาขาปัจจุบัน โดยไม่สนใจการเปลี่ยนแปลงทั้งหมดจากสาขาอื่นทั้งหมดอย่างมีประสิทธิภาพ
มีไว้เพื่อใช้แทนที่ประวัติศาสตร์การพัฒนาเก่าของสาขาย่อย บันทึก
ว่าสิ่งนี้แตกต่างจากตัวเลือก -Xours ถึง ซ้ำ กลยุทธ์การรวม

ทรีย่อย
นี่คือกลยุทธ์แบบเรียกซ้ำที่แก้ไขแล้ว เมื่อรวมต้นไม้ A และ B ถ้า B สอดคล้องกับ
ทรีย่อยของ A, B จะถูกปรับให้เข้ากับโครงสร้างต้นไม้ของ A ก่อน แทนที่จะเป็น
การอ่านต้นไม้ในระดับเดียวกัน การปรับนี้ทำกับคนทั่วไปเช่นกัน
ต้นไม้บรรพบุรุษ

ด้วยกลยุทธ์ที่ใช้การผสาน 3 ทาง (รวมถึงค่าเริ่มต้น ซ้ำ) หากมีการเปลี่ยนแปลง
จะทำทั้งสองสาขา แต่ภายหลังกลับคืนมาที่กิ่งใดกิ่งหนึ่ง การเปลี่ยนแปลงนั้นจะเป็น
นำเสนอในผลรวม; บางคนพบว่าพฤติกรรมนี้ทำให้เกิดความสับสน เกิดขึ้นเพราะ
เฉพาะส่วนหัวและฐานที่ผสานเท่านั้นที่จะถูกพิจารณาเมื่อทำการผสาน ไม่ใช่
ความมุ่งมั่นของแต่ละบุคคล อัลกอริทึมการผสานจึงถือว่าการเปลี่ยนแปลงที่ย้อนกลับเป็น no
เปลี่ยนเลยและแทนที่เวอร์ชันที่เปลี่ยนแปลงแทน

หมายเหตุ

คุณควรเข้าใจความหมายของการใช้ คอมไพล์ รีเบส บนที่เก็บที่คุณแชร์
ดูการกู้คืนจาก UPSTREAM REBASE ด้านล่างด้วย

เมื่อรันคำสั่ง git-rebase จะรันคำสั่ง "pre-rebase" ก่อน ถ้า one
มีอยู่ คุณสามารถใช้เบ็ดนี้เพื่อตรวจสอบสุขภาพจิตและปฏิเสธการรีเบสหากไม่ใช่
เหมาะสม. โปรดดูตัวอย่างสคริปต์เบ็ดการรีเบสล่วงหน้าของเทมเพลต

เมื่อเสร็จสิ้น, จะเป็นสาขาปัจจุบัน

เชิงโต้ตอบ โหมด

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

โหมดโต้ตอบมีไว้สำหรับเวิร์กโฟลว์ประเภทนี้:

1. มีความคิดที่ยอดเยี่ยม

2. แฮ็ครหัส

3.เตรียมซีรี่ย์ส่ง

4. ส่ง

โดยจุดที่ 2 ประกอบด้วยหลายกรณีของ

ก) ใช้งานปกติ

1. ทำสิ่งที่คู่ควรกับการกระทำให้เสร็จสิ้น

2. มุ่งมั่น

b) การแก้ไขอิสระ

1. ตระหนักว่าบางสิ่งบางอย่างไม่ได้ผล

2. ซ่อมมัน

3. ลงมือทำ

บางครั้งสิ่งที่แก้ไขใน b.2 ไม่สามารถแก้ไขให้กระทำการที่ไม่สมบูรณ์ได้
การแก้ไข เนื่องจากการกระทำนั้นถูกฝังลึกในชุดโปรแกรมแก้ไข นั่นคือสิ่งที่
rebase แบบโต้ตอบมีไว้สำหรับ: ใช้หลังจาก "a" และ "b" จำนวนมากโดยจัดเรียงใหม่และ
การแก้ไขการคอมมิต และการบีบหลายคอมมิตให้เป็นหนึ่งเดียว

เริ่มต้นด้วยการคอมมิตล่าสุดที่คุณต้องการเก็บไว้ตามที่เป็น:

git rebase -i

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

เลือก deadbee เส้นเดียวของการกระทำนี้
เลือก fa1afe1 oneline ของคอมมิชชันถัดไป
...

คำอธิบาย oneline เป็นเพียงเพื่อความสุขของคุณ คอมไพล์ รีเบส จะไม่มองดูพวกเขา
แต่ที่ชื่อคอมมิต ("deadbee" และ "fa1afe1" ในตัวอย่างนี้) ดังนั้นอย่าลบหรือ
แก้ไขชื่อ

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

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

หากต้องการยกเลิกการคอมมิต ให้แทนที่คำสั่ง "pick" ด้วย "drop" หรือเพียงแค่ลบการจับคู่
เส้น

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

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

ตัวอย่างเช่น หากคุณต้องการเรียงลำดับการคอมมิต 5 รายการล่าสุดใหม่ ดังนั้นสิ่งที่เป็น HEAD~4 กลายเป็น
หัวใหม่ เพื่อให้บรรลุสิ่งนั้นคุณจะเรียก คอมไพล์ รีเบส อย่างนี้:

$ git rebase -i HEAD~5

และย้ายแพตช์แรกไปยังจุดสิ้นสุดของรายการ

คุณอาจต้องการคงการผสานไว้ หากคุณมีประวัติดังนี้:

X
\
เอ---เอ็ม---บี
/
---o---O---P---คิว

สมมติว่าคุณต้องการรีเบสแบรนช์ด้านข้างโดยเริ่มจาก "A" ถึง "Q" ตรวจสอบให้แน่ใจว่า
HEAD ปัจจุบันคือ "B" และเรียก

$ git rebase -i -p --onto QO

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

เลือก deadbee ใช้คุณสมบัติ XXX
fixup f1a5c00 แก้ไขเพื่อให้มี XXX
ผู้บริหารทำ
เลือก c0ffeee oneline ของคอมมิชชันถัดไป
แก้ไข deadbab เส้นเดียวของการคอมมิทหลังจาก
exec cd ย่อย; ทำแบบทดสอบ
...

rebase แบบโต้ตอบจะหยุดเมื่อคำสั่งล้มเหลว (เช่น ออกด้วยสถานะที่ไม่ใช่ -0) ถึง
ให้โอกาสในการแก้ไขปัญหา คุณสามารถดำเนินการต่อด้วย git rebase --continue

คำสั่ง "exec" เรียกใช้คำสั่งในเชลล์ (คำสั่งที่ระบุใน $SHELL หรือ the
เชลล์เริ่มต้นหากไม่ได้ตั้งค่า $SHELL) ดังนั้นคุณสามารถใช้คุณสมบัติเชลล์ได้ (เช่น "cd", ">", ";"
...) คำสั่งรันจากรูทของแผนผังการทำงาน

$ git rebase -i --exec "ทำการทดสอบ"

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

เลือก 5928aea หนึ่ง
exec ทำการทดสอบ
เลือก 04d0fda สอง
exec ทำการทดสอบ
เลือก ba46169 สาม
exec ทำการทดสอบ
เลือก f4593f9 สี่
exec ทำการทดสอบ

การแบ่งแยก ภาระผูกพัน

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

· เริ่มการรีเบสแบบโต้ตอบด้วย git rebase -i ^ ที่ไหน คือความมุ่งมั่น
คุณต้องการแยก อันที่จริง ช่วงการคอมมิตใดๆ ก็ตาม ตราบใดที่มีช่วงนั้นอยู่
กระทำ

· ทำเครื่องหมายการคอมมิตที่คุณต้องการแยกด้วยการกระทำ "แก้ไข"

· เมื่อต้องแก้ไขคอมมิตนั้น ให้รัน git reset HEAD^ ผลก็คือว่า
HEAD ถูกกรอกลับหนึ่งอัน และดัชนีจะตามหลังความเหมาะสม อย่างไรก็ตาม ต้นไม้ทำงานยังคงอยู่
เหมือน.

· ตอนนี้ ให้เพิ่มการเปลี่ยนแปลงไปยังดัชนีที่คุณต้องการให้มีในการคอมมิตครั้งแรก คุณสามารถ
ใช้ git add (อาจโต้ตอบได้) หรือ คอมไพล์ กุย (หรือทั้งสองอย่าง) ที่จะทำอย่างนั้น

· คอมมิตดัชนีปัจจุบันด้วยข้อความการคอมมิตใดๆ ก็ตามที่เหมาะสมในตอนนี้

· ทำซ้ำสองขั้นตอนสุดท้ายจนกว่าแผนผังการทำงานของคุณจะสะอาด

· ทำการรีเบสต่อด้วย git rebase --continue

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

การกู้คืน จาก อัพสตรีม รีเบส

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

เพื่อเป็นตัวอย่าง สมมติว่าคุณอยู่ในสถานการณ์ที่ใครบางคนพัฒนา a ระบบย่อย สาขา,
และคุณกำลังทำงานกับ a หัวข้อ ที่ขึ้นอยู่กับสิ่งนี้ ระบบย่อย. คุณอาจลงเอยด้วย
ประวัติศาสตร์ดังต่อไปนี้:

o---o---o---o---o---o---o---o---o อาจารย์
\
o---o---o---o---o ระบบย่อย
\
*---*---* หัวข้อ

If ระบบย่อย เป็นพื้นฐานต่อต้าน เจ้านาย, สิ่งต่อไปนี้เกิดขึ้น:

o---o---o---o---o---o---o---o อาจารย์
-
o---o---o---o---o o'--o'--o'--o'--o' ระบบย่อย
\
*---*---* หัวข้อ

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

o---o---o---o---o---o---o---o อาจารย์
-
o---o---o---o---o o'--o'--o'--o'--o'--M ระบบย่อย
-
*---*---*-..........-*--* หัวข้อ

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

การแก้ไขมีสองประเภท ที่กล่าวถึงในหัวข้อย่อยต่อไปนี้:

กรณีง่าย: การเปลี่ยนแปลงนั้นเหมือนกันอย่างแท้จริง
สิ่งนี้จะเกิดขึ้นหาก ระบบย่อย rebase เป็น rebase ธรรมดาและไม่มีข้อขัดแย้ง

กรณียาก: การเปลี่ยนแปลงไม่เหมือนกัน
สิ่งนี้จะเกิดขึ้นหาก ระบบย่อย rebase มีข้อขัดแย้งหรือใช้ --interactive เพื่อละเว้น
แก้ไข สควอช หรือแก้ไขคอมมิต; หรือถ้าต้นน้ำใช้อย่างใดอย่างหนึ่งของการคอมมิต -- แก้ไข, รีเซ็ต,
หรือกรองสาขา

พื้นที่ ง่าย กรณี
ใช้ได้เฉพาะเมื่อการเปลี่ยนแปลง (รหัสแพทช์ตามเนื้อหาต่าง) บน ระบบย่อย เป็น
เหมือนกันทั้งก่อนและหลังการรีเบส ระบบย่อย ไม่

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

$ git rebase ระบบย่อย

คุณจะจบลงด้วยประวัติคงที่

o---o---o---o---o---o---o---o อาจารย์
\
o'-o'--o'--o'--o' ระบบย่อย
\
*---*---* หัวข้อ

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

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

ความคิดคือการบอกด้วยตนเอง คอมไพล์ รีเบส "เก่าที่ไหน ระบบย่อย สิ้นสุดและของคุณ หัวข้อ
ได้เริ่มต้นขึ้น" นั่นคือ การรวมฐานแบบเก่าระหว่างพวกเขาคืออะไร คุณจะต้องหาวิธีที่จะ
ตั้งชื่อการกระทำครั้งสุดท้ายของเก่า ระบบย่อย, ตัวอย่างเช่น:

· กับ ระบบย่อย reflog: หลัง คอมไพล์ นำมา, เคล็ดลับเก่าของ ระบบย่อย อยู่ที่
ระบบย่อย@{1}. การดึงข้อมูลในภายหลังจะเพิ่มจำนวนขึ้น (ดู git-reflog(1).)

· เทียบกับปลายของ หัวข้อ: รู้ว่าคุณ หัวข้อ มีสามคอมมิต, ทิปเก่า
of ระบบย่อย ต้องเป็นหัวข้อ~3

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

$ git rebase --เข้าสู่ระบบย่อยระบบย่อย@{1}

ผลกระทบของการฟื้นตัวของ "เคสแข็ง" นั้นแย่เป็นพิเศษ: ทุกคน ปลายน้ำจาก
หัวข้อ ตอนนี้ก็จะต้องทำการกู้คืน "เคสแข็ง" ด้วย!

ใช้ git-rebase ออนไลน์โดยใช้บริการ onworks.net