ฉันจะเลิกทำการ 'เพิ่มคอมไพล์' ก่อนที่จะส่งได้อย่างไร?

ฉันเพิ่มไฟล์ไปยัง Git โดยไม่ตั้งใจโดยใช้คำสั่ง:

git add myfile.txt

git commitฉันยังไม่ได้ทำงานเลย มีวิธีการยกเลิกการทำเช่นนี้ดังนั้นไฟล์เหล่านี้จะไม่รวมอยู่ในการกระทำ?

คุณสามารถเลิกทำgit addก่อนกระทำการ

git reset <file>

ซึ่งจะลบออกจากดัชนีปัจจุบัน (รายการ "กำลังจะเกิดขึ้น") โดยไม่เปลี่ยนแปลงสิ่งใด

คุณสามารถใช้ได้

git reset

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

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

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

คุณต้องการ:

git rm --cached <added_file_to_undo>

เหตุผล:

เมื่อฉันยังใหม่กับสิ่งนี้ฉันพยายามครั้งแรก

git reset .

(เพื่อยกเลิกการเพิ่มเริ่มต้นของฉันทั้งหมด) เพียงเพื่อรับข้อความนี้ (ไม่ได้) ข้อความที่เป็นประโยชน์:

fatal: Failed to resolve 'HEAD' as a valid ref.

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

1. cd ไปยังไดเร็กตอรี่โปรเจคใหม่ที่ยอดเยี่ยมของฉันเพื่อทดลองใช้ Git ความนิยมใหม่
2. git init
3. git add .

4. git status

   ... จำนวนมากอึเลื่อน ...

   => ประณามฉันไม่ต้องการที่จะเพิ่มทั้งหมด

5. google "เลิกทำการเพิ่ม git"

   => ค้นหา Stack Overflow - yay

6. git reset .

   => ร้ายแรง: ไม่สามารถแก้ไข 'HEAD' เป็นข้อมูลอ้างอิงที่ถูกต้อง

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

และนั่นเป็นทางออกที่ถูกต้องในสถานะ Git (ซึ่ง, ใช่, ฉันคัดสรรเป็น 'อึ)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

git rm --cached FILEและการแก้ปัญหาจริงคือการใช้งาน

หมายเหตุ: คำเตือนที่อื่น ๆ ที่นี่ - git rmลบสำเนาการทำงานภายในประเทศของคุณไฟล์ แต่ไม่ได้ถ้าคุณใช้--cached นี่คือผลลัพธ์ของgit help rm :

--cached ใช้ตัวเลือกนี้เพื่อ unstage และลบเส้นทางจากดัชนีเท่านั้น ไฟล์แผนผังการทำงานไม่ว่าจะถูกแก้ไขหรือไม่ก็ตามจะถูกทิ้งไว้

ฉันใช้ต่อไป

git rm --cached .

เพื่อลบทุกอย่างและเริ่มใหม่อีกครั้ง ใช้งานไม่ได้เพราะในขณะที่add .เรียกซ้ำจะเปิดใช้งานrmจำเป็นต้องเรียก-rเก็บเงิน ถอนหายใจ

git rm -r --cached .

โอเคตอนนี้ฉันกลับไปที่ที่ฉันเริ่มแล้ว ครั้งต่อไปฉันจะใช้-nในการทำแห้งและดูว่าจะเพิ่มอะไร:

git add -n .

ฉันซิปขึ้นทุกอย่างไปยังที่ปลอดภัยก่อนที่จะไว้วางใจgit help rmในสิ่งที่--cachedไม่ทำลาย (และถ้าฉันสะกดผิด)

หากคุณพิมพ์:

git status

Git จะบอกคุณว่าฉากใดบ้าง ฯลฯ รวมถึงคำแนะนำเกี่ยวกับขั้นตอนการทำเวที:

use "git reset HEAD <file>..." to unstage

ฉันพบว่า Git ทำหน้าที่ได้ดีมากในการผลักดันให้ฉันทำสิ่งที่ถูกต้องในสถานการณ์เช่นนี้

หมายเหตุ: เวอร์ชัน Git ล่าสุด (1.8.4.x) มีการเปลี่ยนแปลงข้อความนี้:

(use "git rm --cached <file>..." to unstage)

หากต้องการชี้แจง: git addย้ายการเปลี่ยนแปลงจากไดเร็กทอรีการทำงานปัจจุบันไปยังพื้นที่การจัดเตรียม (ดัชนี)

กระบวนการนี้เรียกว่าการแสดงละคร ดังนั้นคำสั่งเป็นธรรมชาติมากที่สุดที่จะเป็นเวทีการเปลี่ยนแปลง (แฟ้มการเปลี่ยนแปลง) เป็นที่เห็นได้ชัดที่หนึ่ง:

git stage

git add เป็นเพียงนามแฝงที่ง่ายต่อการพิมพ์ git stage

สงสารไม่มีgit unstageมิได้git unaddคำสั่ง สิ่งที่เกี่ยวข้องนั้นยากที่จะคาดเดาหรือจำได้ แต่ก็ค่อนข้างชัดเจน:

git reset HEAD --

เราสามารถสร้างนามแฝงสำหรับสิ่งนี้ได้อย่างง่ายดาย:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

และในที่สุดเรามีคำสั่งใหม่:

git add file1
git stage file2
git unadd file2
git unstage file1

ส่วนตัวฉันใช้นามแฝงที่สั้นกว่า:

git a # For staging
git u # For unstaging

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

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

git gc --prune=now

อัปเดต (สิ่งต่อไปนี้คือความพยายามของฉันในการกำจัดความสับสนบางอย่างที่อาจเกิดขึ้นจากคำตอบที่ upvoted ที่สุด):

ดังนั้นซึ่งเป็นจริงเลิกทำของgit add?

git reset HEAD <file> ?

หรือ

git rm --cached <file>?

พูดอย่างเคร่งครัดและถ้าฉันไม่ผิด: ไม่มี

git add ไม่สามารถยกเลิกได้ได้อย่างปลอดภัยโดยทั่วไป

ลองนึกถึงสิ่งแรกที่ควรgit add <file>ทำ:

1. หาก<file>ได้รับไม่ได้ติดตามก่อนหน้านี้ , git add จะเพิ่มไปยังแคชที่มีเนื้อหาปัจจุบัน

2. หาก<file>ได้รับการติดตามแล้ว , git add บันทึกเนื้อหาปัจจุบัน (ภาพรวมรุ่น) ไปยังแคช ใน Git การกระทำนี้ยังคงเรียกว่าเพิ่ม (ไม่ใช่แค่อัปเดต ) เนื่องจากสองเวอร์ชันที่แตกต่างกัน (สแนปชอต) ของไฟล์ถือเป็นสองรายการที่แตกต่างกัน: ดังนั้นเราจึงเพิ่มรายการใหม่ลงในแคช มุ่งมั่นในภายหลัง

เมื่อพิจารณาถึงสิ่งนี้คำถามจะคลุมเครือเล็กน้อย:

ฉันเพิ่มไฟล์ผิดโดยใช้คำสั่ง ...

สถานการณ์ของ OP น่าจะเป็นไฟล์แรก (ไฟล์ที่ไม่ได้ติดตาม) เราต้องการให้ "เลิกทำ" เพื่อลบไฟล์ (ไม่ใช่แค่เนื้อหาปัจจุบัน) ออกจากรายการที่ถูกติดตาม หากเป็นกรณีนี้แสดงว่าไม่สามารถทำงาน git rm --cached <file>ได้

และเราก็สามารถวิ่งgit reset HEAD <file>ได้ สิ่งนี้เป็นสิ่งที่ดีกว่าเพราะมันใช้งานได้ในทั้งสองสถานการณ์: มันจะทำการเลิกทำเมื่อเราเพิ่มเวอร์ชันของรายการที่ถูกติดตามไปอย่างผิด ๆ

แต่มีสองประการ

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

ข้อสอง: โปรดทราบว่าgit reset HEAD ไม่สามารถกู้คืนเนื้อหาไฟล์ที่แคชไว้ก่อนหน้าได้อย่างน่าอัศจรรย์เพียงแค่ซิงโครไนซ์ไฟล์จาก HEAD อีกครั้ง หากเราเข้าใจผิดgit addเขียนทับเวอร์ชันที่ไม่มีข้อผูกมัดฉากก่อนหน้าเราจะไม่สามารถกู้คืนได้ นั่นเป็นเหตุผลที่พูดอย่างเคร่งครัดเราไม่สามารถยกเลิก [*]

ตัวอย่าง:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # First add of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # Stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # Oops we didn't mean this
$ git reset HEAD file.txt  # Undo?
$ git diff --cached file.txt  # No dif, of course. stage == HEAD
$ git diff file.txt   # We have irrevocably lost "version 2"
-version 1
+version 3

แน่นอนว่ามันไม่สำคัญมากหากเราเพียงแค่ทำตามขั้นตอนการทำงานแบบสันหลังยาวของการทำ 'git add' เท่านั้นสำหรับการเพิ่มไฟล์ใหม่ (กรณีที่ 1) และเราอัพเดทเนื้อหาใหม่ผ่านgit commit -aคำสั่งcommit,

^{* (แก้ไข: ด้านบนถูกต้องจริง แต่ก็ยังสามารถมีวิธีแฮ็ค / convoluted เล็กน้อยสำหรับการกู้คืนการเปลี่ยนแปลงที่ staged แต่ไม่ได้มุ่งมั่นแล้วเขียนทับ - ดูความคิดเห็นโดย Johannes Matokic และ iolsmit)}

การเลิกทำไฟล์ที่เพิ่มไปแล้วนั้นค่อนข้างง่ายด้วย Git สำหรับการรีเซ็ตmyfile.txtซึ่งเพิ่มไปแล้วให้ใช้:

git reset HEAD myfile.txt

คำอธิบาย:

หลังจากที่คุณฉากไฟล์ที่ไม่พึงประสงค์ (s), git resetเพื่อยกเลิกการที่คุณสามารถทำได้ Headเป็นส่วนหัวของไฟล์ของคุณในโลคัลและพารามิเตอร์สุดท้ายคือชื่อไฟล์ของคุณ

ฉันได้สร้างขั้นตอนในภาพด้านล่างโดยละเอียดเพื่อคุณมากขึ้นรวมถึงขั้นตอนทั้งหมดที่อาจเกิดขึ้นในกรณีเหล่านี้:

git rm --cached . -r

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

วิ่ง

git gui

และลบไฟล์ทั้งหมดด้วยตนเองหรือโดยการเลือกทั้งหมดของพวกเขาและคลิกที่unstage จากกระทำปุ่ม

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

สิ่งที่คุณทำมาก่อน:

• เปลี่ยนไฟล์และใช้หรือgit add .git add <file>

คุณต้องการอะไร:

• ลบไฟล์ออกจากดัชนี แต่เก็บไว้เป็นเวอร์ชันและทิ้งไว้พร้อมกับการเปลี่ยนแปลงแบบไม่มีข้อผูกมัดในสำเนาการทำงาน:

  git reset head <file>
  

• รีเซ็ตไฟล์เป็นสถานะสุดท้ายจาก HEAD, เลิกทำการเปลี่ยนแปลงและลบออกจากดัชนี:

  # Think `svn revert <file>` IIRC.
  git reset HEAD <file>
  git checkout <file>
  
  # If you have a `<branch>` named like `<file>`, use:
  git checkout -- <file>

  สิ่งนี้จำเป็นเนื่องจากgit reset --hard HEADจะไม่ทำงานกับไฟล์เดียว

• ลบออก<file>จากดัชนีและการกำหนดเวอร์ชันโดยให้ไฟล์ที่ไม่มีเวอร์ชันพร้อมการเปลี่ยนแปลงในสำเนาการทำงาน:

  git rm --cached <file>
  

• ลบ<file>จากสำเนาการทำงานและการกำหนดเวอร์ชันอย่างสมบูรณ์:

  git rm <file>
  

คำถามไม่ได้ถูกวางอย่างชัดเจน เหตุผลก็คือgit addมีสองความหมาย:

1. การเพิ่มไฟล์ใหม่ไปยังพื้นที่จัดเตรียมจากนั้นยกเลิกด้วยgit rm --cached fileไปยังพื้นที่การแสดงละครแล้วเลิกกับ
2. เพิ่มการแก้ไขgit reset HEAD fileไฟล์ไปยังพื้นที่การแสดงละครแล้วเลิกกับ

หากมีข้อสงสัยให้ใช้

git reset HEAD file

เพราะมันทำสิ่งที่คาดหวังในทั้งสองกรณี

คำเตือน:หากคุณทำgit rm --cached fileไฟล์ที่ถูกแก้ไข (ไฟล์ที่มีอยู่ก่อนในที่เก็บ) ไฟล์นั้นจะถูกลบออกgit commit! มันจะยังคงอยู่ในระบบไฟล์ของคุณ แต่ถ้าใครดึงการกระทำของคุณไฟล์จะถูกลบออกจากแผนผังการทำงานของพวกเขา

git statusจะบอกคุณว่าไฟล์ดังกล่าวเป็นไฟล์ใหม่หรือถูกแก้ไข :

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

หากคุณใช้ความรับผิดชอบเริ่มต้นและไม่สามารถใช้งานได้git resetให้ประกาศ "Git bankruptcy" และลบ.gitโฟลเดอร์แล้วเริ่มใหม่

ตามคำตอบอื่น ๆ มากมายคุณสามารถใช้ git reset

แต่:

ฉันพบโพสต์เล็ก ๆ น้อย ๆ ที่ยิ่งใหญ่นี้ซึ่งจริง ๆ แล้วเพิ่มคำสั่ง Git (ดี, นามแฝง) สำหรับgit unadd: ดูgit unaddสำหรับรายละเอียดหรือ ..

เพียงแค่

git config --global alias.unadd "reset HEAD"

ตอนนี้คุณสามารถ

git unadd foo.txt bar.txt

ใช้ git add -iเพื่อลบไฟล์ที่เพิ่งเพิ่มเข้ามาจากการคอมมิชชันที่กำลังจะมาถึง ตัวอย่าง:

การเพิ่มไฟล์ที่คุณไม่ต้องการ:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

ไปที่การเพิ่มแบบโต้ตอบเพื่อยกเลิกการเพิ่มของคุณ (คำสั่งที่พิมพ์ที่ git ที่นี่คือ "r" (เปลี่ยนกลับ), "1" (รายการแรกในรายการย้อนกลับรายการ), 'กลับ' เพื่อเลื่อนออกจากโหมดเปลี่ยนกลับและ "q" (เลิก):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

แค่นั้นแหละ! นี่คือหลักฐานของคุณซึ่งแสดงว่า "foo" กลับมาอยู่ในรายการที่ไม่ได้ติดตาม:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

git removeหรือgit rmสามารถใช้สำหรับสิ่งนี้ด้วยการ--cachedตั้งค่าสถานะ ลอง:

git help rm

ต่อไปนี้เป็นวิธีหลีกเลี่ยงปัญหาที่รบกวนเมื่อคุณเริ่มโครงการใหม่:

• สร้างไดเรกทอรีหลักสำหรับโครงการใหม่ของคุณ
• git initวิ่ง
• ตอนนี้สร้างไฟล์. gitignore (แม้ว่าจะว่างเปล่า)
• ยอมรับไฟล์. gitignore ของคุณ

Git ทำให้มันยากจริงๆgit resetถ้าคุณไม่มีภาระผูกพันใด ๆ หากคุณสร้างการเริ่มต้นเล็ก ๆ เพียงเพื่อเห็นแก่หลังจากนั้นคุณสามารถgit add -Aและgit resetหลาย ๆ ครั้งตามที่คุณต้องการเพื่อให้ทุกอย่างถูกต้อง

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

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

บางที Git มีวิวัฒนาการมาตั้งแต่คุณโพสต์คำถามของคุณ

$> git --version
git version 1.6.2.1

ตอนนี้คุณสามารถลอง:

git reset HEAD .

นี่ควรเป็นสิ่งที่คุณกำลังมองหา

โปรดทราบว่าหากคุณไม่ได้ระบุการแก้ไขคุณจะต้องมีตัวคั่น ตัวอย่างจากคอนโซลของฉัน:

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M    <path_to_file>

(Git เวอร์ชั่น 1.7.5.4)

หากต้องการลบไฟล์ใหม่ออกจากพื้นที่จัดเตรียม (และเฉพาะในกรณีของไฟล์ใหม่) ตามที่แนะนำข้างต้น:

git rm --cached FILE

ใช้ rm - แคชเฉพาะสำหรับไฟล์ใหม่ที่เพิ่มโดยไม่ตั้งใจ

หากต้องการรีเซ็ตทุกไฟล์ในโฟลเดอร์เฉพาะ (และโฟลเดอร์ย่อย) คุณสามารถใช้คำสั่งต่อไปนี้:

git reset *

ใช้*คำสั่งเพื่อจัดการไฟล์หลายไฟล์พร้อมกัน:

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

เป็นต้น

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

สมมติว่าฉันสร้างไฟล์ใหม่newFile.txt:

สมมติว่าฉันเพิ่มไฟล์โดยไม่ตั้งใจgit add newFile.txt:

ตอนนี้ฉันต้องการยกเลิกการเพิ่มนี้ก่อนที่จะกระทำgit reset newFile.txt:

สำหรับไฟล์เฉพาะ:

• git รีเซ็ต my_file.txt
• git checkout my_file.txt

สำหรับไฟล์ที่เพิ่มทั้งหมด:

• รีเซ็ตคอมไพล์
• ชำระเงินคอมไพล์

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

คำสั่งนี้จะปลดการเปลี่ยนแปลงของคุณ:

git reset HEAD filename.txt

คุณยังสามารถใช้

git add -p 

เพื่อเพิ่มบางส่วนของไฟล์

นอกจากนี้ยังมีโหมดโต้ตอบ:

git add -i

เลือกตัวเลือก 3 เพื่อยกเลิกการเพิ่มไฟล์ ในกรณีของฉันฉันมักจะต้องการเพิ่มมากกว่าหนึ่งไฟล์และด้วยโหมดการโต้ตอบคุณสามารถใช้ตัวเลขเช่นนี้เพื่อเพิ่มไฟล์ สิ่งนี้จะใช้เวลาทั้งหมดยกเว้น 4: 1, 2, 3 และ 5

ในการเลือกลำดับเพียงพิมพ์ 1-5 เพื่อเลือกจาก 1 ถึง 5

Git ไฟล์จัดเตรียม

หากต้องการยกเลิกgit addให้ใช้:

git reset filename

git reset filename.txt

จะลบไฟล์ชื่อ filename.txt ออกจากดัชนีปัจจุบันพื้นที่ "กำลังจะถูกส่ง" โดยไม่ต้องเปลี่ยนแปลงสิ่งใด

git add myfile.txt # สิ่งนี้จะเพิ่มไฟล์ของคุณลงในรายการที่ต้องการ

ตรงกันข้ามกับคำสั่งนี้คือ

git reset HEAD myfile.txt  # This will undo it.

ดังนั้นคุณจะอยู่ในสถานะก่อนหน้า จะมีการระบุอีกครั้งในรายการที่ไม่ได้ติดตาม (สถานะก่อนหน้า)

มันจะรีเซ็ตหัวของคุณด้วยไฟล์ที่ระบุ ดังนั้นหากหัวของคุณไม่มีความหมายหัวก็จะรีเซ็ต

ใน Sourcetree คุณสามารถทำได้อย่างง่ายดายผ่าน GUI คุณสามารถตรวจสอบคำสั่งที่ Sourcetree ใช้เพื่อเลิกไฟล์

ฉันสร้างไฟล์ใหม่และเพิ่มลงใน Git จากนั้นฉันก็ไม่ทำมันโดยใช้ Sourcetree GUI นี่คือผลลัพธ์ที่ได้:

ไฟล์ที่ไม่เก็บข้อมูล [08/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = การรีเซ็ตต้นทาง -q - พา ธ / ถึง / ไฟล์ / filename.java

Sourcetree ใช้resetเพื่อ unstage ไฟล์ใหม่

git reset filename.txt  

จะลบไฟล์ชื่อ filename.txt ออกจากดัชนีปัจจุบันพื้นที่ "กำลังจะถูกส่ง" โดยไม่ต้องเปลี่ยนแปลงสิ่งใด