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

โครงการ:

ชื่อ

git-reset - รีเซ็ต HEAD ปัจจุบันเป็นสถานะที่ระบุ

เรื่องย่อ

คอมไพล์ ตั้งใหม่ [-NS] [ ] [--] ...
คอมไพล์ ตั้งใหม่ (--แพทช์ | -p) [ ] [--] [ ...]
คอมไพล์ ตั้งใหม่ [--นุ่ม | --mixed [-N] | --ยาก | --ผสาน | --เก็บ] [-q] [ ]

DESCRIPTION

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

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

ซึ่งหมายความว่า git reset ตรงข้ามกับ git add .

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

คอมไพล์ ตั้งใหม่ (--แพทช์ | -p) [ ] [--] [ ...]
เลือก hunks ในความแตกต่างระหว่างดัชนีและ
(ค่าเริ่มต้นคือ HEAD) ก้อนที่เลือกจะถูกนำไปใช้กับดัชนี

ซึ่งหมายความว่า git reset -p ตรงกันข้ามกับ git add -p นั่นคือคุณสามารถใช้ to
เลือกรีเซ็ต hunks ดูส่วน "โหมดโต้ตอบ" ของ คอมไพล์เพิ่ม(1) เรียนรู้วิธี
เพื่อใช้งานโหมด --patch

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

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

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

หากระบุ -N เส้นทางที่ลบออกจะถูกทำเครื่องหมายเป็นความตั้งใจที่จะเพิ่ม (ดู คอมไพล์เพิ่ม(พ.ศ. 1)).

--แข็ง
รีเซ็ตดัชนีและแผนผังการทำงาน การเปลี่ยนแปลงใด ๆ กับไฟล์ที่ติดตามในการทำงาน
ต้นไม้ตั้งแต่ ถูกทิ้ง

--ผสาน
รีเซ็ตดัชนีและอัปเดตไฟล์ในแผนผังการทำงานที่แตกต่างกัน
ระหว่าง และ HEAD แต่คงไว้ซึ่งความแตกต่างระหว่าง index
และผังการทำงาน (เช่น ที่มีการเปลี่ยนแปลงซึ่งยังไม่ได้เพิ่ม) ถ้าเป็นไฟล์
ที่แตกต่างกันระหว่าง และดัชนีมีการเปลี่ยนแปลงที่ไม่ได้จัดฉาก รีเซ็ตเป็น
ยกเลิก

กล่าวอีกนัยหนึ่ง --merge ทำบางอย่างเช่น คอมไพล์ อ่านต้นไม้ -u -m แต่
ดำเนินการรายการดัชนีที่ยังไม่ได้รวม

--เก็บไว้
รีเซ็ตรายการดัชนีและอัปเดตไฟล์ในแผนผังการทำงานที่แตกต่างกัน
ระหว่าง และหัวหน้า หากเป็นไฟล์ที่แตกต่างกันระหว่าง และ HEAD
มีการเปลี่ยนแปลงในเครื่อง การรีเซ็ตถูกยกเลิก

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

OPTIONS

-q, --เงียบ
เงียบ แจ้งข้อผิดพลาดเท่านั้น

ตัวอย่าง

เลิกทำการเพิ่ม

$ แก้ไข (1)
$ git เพิ่ม frotz.c filfre.c
$ จดหมาย (2)
$ git รีเซ็ต (3)
$ git ดึง git://info.example.com/ nitfol (4)

1. คุณมีความสุขกับการทำงานบางอย่าง และพบว่าการเปลี่ยนแปลงในไฟล์เหล่านี้อยู่ใน
คำสั่งที่ดี คุณไม่ต้องการเห็นพวกเขาเมื่อคุณเรียกใช้ "git diff" เพราะคุณวางแผนที่จะ
การทำงานกับไฟล์อื่นๆ และการเปลี่ยนแปลงกับไฟล์เหล่านี้ทำให้เสียสมาธิ
2. มีคนขอให้คุณดึง และการเปลี่ยนแปลงฟังดูคุ้มค่าที่จะรวมเข้าด้วยกัน
3. อย่างไรก็ตาม คุณทำให้ดัชนีสกปรกแล้ว (เช่น ดัชนีของคุณไม่ตรงกับ HEAD
ให้สัญญา). แต่คุณรู้ว่าแรงดึงที่คุณจะทำนั้นไม่มีผลกับ frotz.c หรือ
filfre.c ดังนั้นคุณจึงยกเลิกการเปลี่ยนแปลงดัชนีสำหรับสองไฟล์นี้ การเปลี่ยนแปลงในการทำงานของคุณ
ต้นไม้ยังคงอยู่ที่นั่น
4. จากนั้นคุณสามารถดึงและผสาน โดยปล่อยให้การเปลี่ยนแปลง frotz.c และ filfre.c ยังคงอยู่ใน
ต้นไม้ทำงาน

เลิกทำการคอมมิตและทำซ้ำ

$ git กระทำ ...
$ รีเซ็ต git --soft HEAD^ (1)
$ แก้ไข (2)
$ git คอมมิท -a -c ORIG_HEAD (3)

1. สิ่งนี้เกิดขึ้นบ่อยที่สุดเมื่อคุณจำได้ว่าสิ่งที่คุณเพิ่งทำนั้นไม่สมบูรณ์
หรือคุณสะกดข้อความยืนยันผิด หรือทั้งสองอย่าง ปล่อยให้ต้นไม้ทำงานเหมือนเมื่อก่อน
"รีเซ็ต".
2. ทำการแก้ไขไฟล์แผนผังการทำงาน
3. "รีเซ็ต" คัดลอกส่วนหัวเก่าไปที่ .git/ORIG_HEAD; ทำซ้ำการกระทำโดยเริ่มต้นด้วย
ข้อความบันทึก หากคุณไม่ต้องการแก้ไขข้อความเพิ่มเติม คุณสามารถให้ -C ตัวเลือก
แทน.

ดูเพิ่มเติมที่ -- แก้ไขตัวเลือกเพื่อ git-กระทำ(1)

เลิกทำการคอมมิต ทำให้เป็นสาขาของหัวข้อ

$ git สาขาหัวข้อ/wip (1)
$ รีเซ็ต git --hard HEAD~3 (2)
$ git หัวข้อการชำระเงิน/wip (3)

1. คุณได้ทำภาระกิจบางอย่างแล้ว แต่ตระหนักดีว่ายังเร็วเกินไปที่จะเป็น "อาจารย์"
สาขา. คุณต้องการขัดเกลามันต่อไปในหัวข้อหัวข้อ ดังนั้นให้สร้าง "topic/wip"
แยกสาขาออกจาก HEAD ปัจจุบัน
2. ย้อนกลับมาสเตอร์แบรนช์เพื่อกำจัดการคอมมิตทั้งสามนั้น
3. เปลี่ยนเป็นสาขา "topic/wip" และทำงานต่อไป

เลิกทำคอมมิทอย่างถาวร

$ git กระทำ ...
$ รีเซ็ต git --hard HEAD~3 (1)

1. คอมมิทสามตัวสุดท้าย (HEAD, HEAD^ และ HEAD~2) ไม่ดีและคุณไม่ต้องการ
เคยเห็นพวกเขาอีกครั้ง ทำ ไม่ ทำเช่นนี้หากคุณได้ให้คำมั่นสัญญาเหล่านี้กับ
คนอื่น. (ดูส่วน "การกู้คืนจากแหล่งรีเบสของ UPSTREAM" ใน คอมไพล์รีเบส(1) สำหรับ
ผลของการกระทำดังกล่าว)

เลิกทำการผสานหรือดึง

$ git ดึง (1)
การรวมอัตโนมัติ nitfol
CONFLICT (เนื้อหา): รวมข้อขัดแย้งใน nitfol
การรวมอัตโนมัติล้มเหลว แก้ไขข้อขัดแย้งแล้วส่งผลลัพธ์
$ รีเซ็ต git --hard (2)
$ git ดึง หัวข้อ/สาขา (3)
กำลังอัปเดตจาก 41223... เป็น 13134...
กรอไปข้างหน้า
$ รีเซ็ต git --hard ORIG_HEAD (4)

1. พยายามอัพเดทจากอัพสตรีมทำให้เกิดข้อขัดแย้งมากมาย คุณยังไม่พร้อม
ที่จะใช้เวลาส่วนใหญ่ในการรวมกันในตอนนี้ ดังนั้นคุณจึงตัดสินใจทำในภายหลัง
2. "pull" ไม่ได้ทำการผสาน ดังนั้น "git reset --hard" ซึ่งเป็นคำพ้องความหมายสำหรับ "git
reset --hard HEAD" ล้างความยุ่งเหยิงจากไฟล์ดัชนีและแผนผังการทำงาน
3. รวมสาขาหัวข้อเข้ากับสาขาปัจจุบัน ซึ่งส่งผลให้กรอไปข้างหน้า
4. แต่คุณตัดสินใจว่าสาขาหัวข้อยังไม่พร้อมสำหรับการบริโภคของประชาชน
"ดึง" หรือ "ผสาน" จะออกจากส่วนปลายเดิมของสาขาปัจจุบันใน ORIG_HEAD เสมอ
ดังนั้นการรีเซ็ตอย่างหนักจะทำให้ไฟล์ดัชนีของคุณและโครงสร้างการทำงานกลับมาที่
state และรีเซ็ตส่วนปลายของแบรนช์เป็นคอมมิตนั้น

เลิกทำการผสานหรือดึงเข้าไปในแผนผังการทำงานที่สกปรก

$ git ดึง (1)
การรวมอัตโนมัติ nitfol
ผสานโดยเรียกซ้ำ
นิตโฟล์ | 20 ++++++----
...
$ รีเซ็ต git --ผสาน ORIG_HEAD (2)

1. แม้ว่าคุณจะมีการปรับเปลี่ยนโครงสร้างในแผนผังการทำงานของคุณ คุณสามารถพูดได้อย่างปลอดภัยว่า
"git pull" เมื่อรู้ว่าการเปลี่ยนแปลงสาขาอื่นไม่ทับซ้อนกับ
พวกเขา
2. หลังจากตรวจสอบผลการรวมแล้ว คุณอาจพบว่าการเปลี่ยนแปลงในส่วนอื่นๆ
สาขาไม่น่าพอใจ การรัน "git reset --hard ORIG_HEAD" จะทำให้คุณกลับไปที่
คุณอยู่ที่ไหน แต่จะยกเลิกการเปลี่ยนแปลงในเครื่องของคุณ ซึ่งคุณไม่ต้องการ "กิต
reset --merge" จะรักษาการเปลี่ยนแปลงในเครื่องของคุณ

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

$ git checkout feature ;# คุณกำลังทำงานในสาขา "feature" และ
$ ทำงาน ทำงาน ;# ถูกขัดจังหวะ
$ git commit -a -m "snapshot WIP" (1)
$ git ต้นแบบการชำระเงิน
$ ฟิกซ์ ฟิกซ์ ฟิกซ์
$ git commit ;# commit ด้วย log จริง
คุณลักษณะการชำระเงิน $ git
$ git reset --soft HEAD^ ;# กลับไปที่สถานะ WIP (2)
$ git รีเซ็ต (3)

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

ดูสิ่งนี้ด้วย git ซ่อน(1)

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

$ รีเซ็ต git -- frotz.c (1)
$ git commit -m "ส่งไฟล์ในดัชนี" (2)
$ git เพิ่ม frotz.c (3)

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

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

$ git แท็กเริ่มต้น
$ git ชำระเงิน -b branch1
$ แก้ไข
$ git กระทำ ... (1)
$ แก้ไข
$ git ชำระเงิน -b branch2 (2)
$ รีเซ็ต git --ให้เริ่มต้น (3)

1. นี่เป็นการคอมมิตการแก้ไขครั้งแรกของคุณใน branch1
2. ในโลกอุดมคติ คุณอาจจะรู้ว่าการกระทำก่อนหน้านี้ไม่เข้าพวก
ไปที่หัวข้อใหม่เมื่อคุณสร้างและเปลี่ยนเป็น branch2 (เช่น "git checkout -b
branch2 start") แต่ไม่มีใครสมบูรณ์แบบ
3. แต่คุณสามารถใช้ "reset --keep" เพื่อลบคอมมิตที่ไม่ต้องการออกหลังจากที่คุณเปลี่ยนเป็น
"สาขา2".

อภิปราย

ตารางด้านล่างแสดงให้เห็นว่าเกิดอะไรขึ้นเมื่อทำงาน:

รีเซ็ต git --option เป้าหมาย

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

ในตารางเหล่านี้ A, B, C และ D เป็นสถานะที่แตกต่างกันของไฟล์ ตัวอย่างเช่น ครั้งแรก
บรรทัดของตารางแรกหมายความว่าหากไฟล์อยู่ในสถานะ A ในแผนผังการทำงาน ในสถานะ B
ในดัชนี ในสถานะ C ใน HEAD และในสถานะ D ในเป้าหมาย จากนั้น "git reset --soft
เป้าหมาย" จะปล่อยให้ไฟล์อยู่ในโครงสร้างการทำงานในสถานะ A และในดัชนีในสถานะ B. It
รีเซ็ต (เช่นย้าย) HEAD (เช่นส่วนปลายของสาขาปัจจุบันหากคุณอยู่บนหนึ่ง) ถึง
"target" (ซึ่งมีไฟล์อยู่ในสถานะ D)

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
ABCD --soft ABD
--ผสมADD
--ฮาร์ด DDD
--ผสาน (ไม่อนุญาต)
--เก็บ (ไม่อนุญาต)

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
ABCC --soft ABC
--ผสมACC
--ฮาร์ด CCC
--ผสาน (ไม่อนุญาต)
--ให้ACC

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
BBCD --soft BBD
--ผสมBDD
--ฮาร์ด DDD
--ผสาน DDD
--เก็บ (ไม่อนุญาต)

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
BBCC --soft BBC
--ผสม BCC
--ฮาร์ด CCC
--ผสาน CCC
--เก็บ BCC

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
BCCD --soft BCD
--ผสมBDD
--ฮาร์ด DDD
--ผสาน (ไม่อนุญาต)
--เก็บ (ไม่อนุญาต)

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
BCCC --soft BCC
--ผสม BCC
--ฮาร์ด CCC
--ผสาน BCC
--เก็บ BCC

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

"reset --keep" มีไว้เพื่อใช้เมื่อลบการคอมมิตล่าสุดบางส่วนในปัจจุบัน
สาขาในขณะที่รักษาการเปลี่ยนแปลงในแผนผังการทำงาน หากอาจมีความขัดแย้งระหว่าง
การเปลี่ยนแปลงในการคอมมิตที่เราต้องการลบและการเปลี่ยนแปลงในแผนผังการทำงานที่เราต้องการ
ให้รีเซ็ตไม่ได้รับอนุญาต จึงไม่อนุญาตหากมีการเปลี่ยนแปลงทั้งสองอย่าง
ระหว่างแผนผังการทำงานกับ HEAD และระหว่าง HEAD กับเป้าหมาย เพื่อความปลอดภัยก็ยัง
ไม่อนุญาตเมื่อมีรายการที่ยังไม่ได้รวม

ตารางต่อไปนี้แสดงให้เห็นว่าเกิดอะไรขึ้นเมื่อมีรายการที่ยังไม่ได้ผสาน:

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
XUAB --soft (ไม่ได้รับอนุญาต)
--ผสมXBB
--ฮาร์ด BBB
--ผสาน BBB
--เก็บ (ไม่อนุญาต)

ดัชนีการทำงาน HEAD เป้าหมาย ดัชนีการทำงาน HEAD
-------------------------------------------------- -
XUAA --soft (ไม่อนุญาต)
--ผสมXAA
--ฮาร์ด AAA
--ผสาน AAA
--เก็บ (ไม่อนุญาต)

X หมายถึงสถานะใดๆ และ U หมายถึงดัชนีที่ยังไม่ได้รวม

GIT

เป็นส่วนหนึ่งของ คอมไพล์(1) ห้องชุด

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