ฉันจะเพิ่มไดเรกทอรีว่างในที่เก็บ Git ได้อย่างไร

ฉันจะเพิ่มไดเรกทอรีว่างเปล่า (ที่ไม่มีไฟล์) ไปยังที่เก็บ Git ได้อย่างไร?

อีกวิธีในการทำให้ไดเรกทอรีอยู่ (เกือบ) ว่าง (ในที่เก็บ) คือการสร้าง.gitignoreไฟล์ภายในไดเรกทอรีนั้นที่มีสี่บรรทัดเหล่านี้:

# Ignore everything in this directory
*
# Except this file
!.gitignore

แล้วคุณไม่จำเป็นต้องได้รับการสั่งซื้อที่เหมาะสมวิธีการที่คุณต้องทำใน M104 ของการแก้ปัญหา

สิ่งนี้ยังให้ประโยชน์ที่ไฟล์ในไดเรกทอรีนั้นจะไม่ปรากฏเป็น "untracked" เมื่อคุณทำสถานะ git

การทำให้ความคิดเห็นของ@GreenAsJadeยังคงอยู่:

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

คุณทำไม่ได้ ดูGit คำถามที่พบบ่อย

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

ไดเรกทอรีจะถูกเพิ่มโดยอัตโนมัติเมื่อเพิ่มไฟล์ภายใน กล่าวคือไม่ต้องเพิ่มไดเรกทอรีในที่เก็บและไม่ได้ติดตามด้วยตนเอง

คุณสามารถพูดว่า " git add <dir>" แล้วมันจะเพิ่มไฟล์เข้าไป

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

สร้างไฟล์ว่างที่เรียกว่า.gitkeepในไดเรกทอรีและเพิ่มไฟล์นั้น

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

touch .keep

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

อีกวิธีหนึ่งดังที่ระบุไว้ในคำตอบอื่นไดเร็กทอรีสามารถมีคำอธิบายREADMEหรือREADME.mdไฟล์แทน

แน่นอนว่าการมีไฟล์จะไม่ทำให้แอปพลิเคชันของคุณหยุดทำงาน

ทำไมเราต้องมีโฟลเดอร์ที่ว่างเปล่า

สิ่งแรกแรก:

directory ว่างไม่สามารถเป็นส่วนหนึ่งของต้นไม้ภายใต้ระบบเวอร์ชันคอมไพล์

มันจะไม่ถูกติดตาม แต่มีบางสถานการณ์ที่ไดเรกทอรีว่าง "รุ่น" อาจมีความหมายตัวอย่างเช่น:

• นั่งร้านโครงสร้างโฟลเดอร์ที่กำหนดไว้ล่วงหน้าทำให้ผู้ใช้ทุกคน / ผู้มีส่วนร่วมของที่เก็บ; หรือเป็นกรณีพิเศษของด้านบนสร้างโฟลเดอร์สำหรับไฟล์ชั่วคราวเช่น a cache/หรือlogs/ไดเรกทอรีที่เราต้องการให้โฟลเดอร์ แต่.gitignoreเนื้อหา
• เกี่ยวข้องกับด้านบนบางโครงการจะไม่ทำงานหากไม่มีโฟลเดอร์ (ซึ่งมักจะเป็นคำใบ้ของโครงการที่ออกแบบมาไม่ดี แต่เป็นสถานการณ์ที่เกิดขึ้นบ่อยครั้งในโลกแห่งความเป็นจริง

บางวิธีแก้ไขปัญหาที่แนะนำ

ผู้ใช้หลายคนแนะนำ:

1. วางREADMEไฟล์หรือไฟล์อื่นที่มีเนื้อหาบางส่วนเพื่อทำให้ไดเรกทอรีไม่ว่างเปล่าหรือ
2. การสร้าง.gitignoreไฟล์ด้วย "reverse logic" (เช่นเพื่อรวมไฟล์ทั้งหมด) ซึ่งในตอนท้ายจะให้บริการด้วยจุดประสงค์เดียวกันของวิธีการ # 1

ในขณะที่โซลูชันทั้งสองทำงานได้อย่างแน่นอนฉันพบว่าพวกเขาไม่สอดคล้องกับแนวทางที่มีความหมายต่อการกำหนดเวอร์ชันของ Git

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

. gitkeep approach

ใช้ไฟล์ว่างที่เรียกว่า.gitkeepเพื่อบังคับให้มีโฟลเดอร์ในระบบการกำหนดเวอร์ชัน

แม้ว่ามันอาจจะดูไม่แตกต่างกันมากนัก:

• คุณใช้ไฟล์ที่มีจุดประสงค์เดียวในการเก็บรักษาโฟลเดอร์ คุณไม่ได้ใส่ข้อมูลใด ๆ ที่คุณไม่ต้องการใส่

  ตัวอย่างเช่นคุณควรใช้ README เช่นกันกับ README ที่มีข้อมูลที่เป็นประโยชน์ไม่ใช่ข้ออ้างในการเก็บโฟลเดอร์

  การแยกข้อกังวลออกมาเป็นสิ่งที่ดีเสมอและคุณยังสามารถเพิ่ม a .gitignoreเพื่อละเว้นไฟล์ที่ไม่ต้องการได้

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

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

การรับเป็นบุตรบุญธรรม

ผมเคยเห็น.gitkeepวิธีการที่นำมาใช้โดยกรอบความสำคัญมากเช่นLaravel , เชิงมุม-CLI

ดังที่อธิบายไว้ในคำตอบอื่น ๆ Git ไม่สามารถแสดงไดเรกทอรีว่างในพื้นที่จัดเตรียม (ดูคำถามที่พบบ่อยเกี่ยวกับGit ) อย่างไรก็ตามหากไดเรกทอรีของคุณว่างเปล่าถ้ามันมี.gitignoreไฟล์เท่านั้นคุณสามารถสร้าง.gitignoreไฟล์ในไดเรกทอรีที่ว่างเปล่าผ่าน:

find . -type d -empty -exec touch {}/.gitignore \;

Andy Lester ถูกต้อง แต่ถ้าไดเรกทอรีของคุณต้องว่างเปล่าและไม่ว่างเปล่าคุณสามารถใส่ค่าว่างได้.gitignoreไฟล์ไว้ในนั้นเป็นวิธีแก้ปัญหา

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

Ruby on Railsเข้าสู่ระบบโฟลเดอร์วิธีการสร้าง:

mkdir log && touch log/.gitkeep && git add log/.gitkeep

ตอนนี้ไดเรกทอรีบันทึกจะรวมอยู่ในต้นไม้ มันมีประโยชน์มากเมื่อใช้งานดังนั้นคุณไม่ต้องเขียนรูทีนเพื่อสร้างไดเรกทอรีบันทึก

ล็อกไฟล์สามารถถูกเก็บไว้โดยการออก

echo log/dev.log >> .gitignore

แต่คุณอาจรู้ว่า

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

ฉันแนะนำให้ใส่ไฟล์ README ในไดเรกทอรีว่างที่อธิบายว่าทำไมไดเรกทอรีว่างเปล่าและทำไมต้องมีการติดตามใน Git เมื่อมีไฟล์ README อยู่แล้วเท่าที่ Git เกี่ยวข้องไดเรกทอรีจะไม่ว่างเปล่าอีกต่อไป

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

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

ในการแสดงรายการไดเร็กทอรีว่างทั้งหมดให้ใช้คำสั่งต่อไปนี้:

find -name .git -prune -o -type d -empty -print

ในการสร้างตัวยึด READMEs ในทุกไดเรกทอรีว่าง:

find -name .git -prune -o -type d -empty -exec sh -c \
  "echo this directory needs to be empty because reasons > {}/README.emptydir" \;

หากต้องการละเว้นทุกสิ่งในไดเรกทอรียกเว้นไฟล์ README ให้วางบรรทัดต่อไปนี้ใน.gitignore:

path/to/emptydir/*
!path/to/emptydir/README.emptydir
path/to/otheremptydir/*
!path/to/otheremptydir/README.emptydir

หรือมิฉะนั้นคุณสามารถยกเว้นไฟล์ README ทุกไฟล์จากการถูกละเว้น:

path/to/emptydir/*
path/to/otheremptydir/*
!README.emptydir

ในการแสดง README ทุกรายการหลังจากสร้างเสร็จแล้ว:

find -name README.emptydir

คำเตือน: การปรับแต่งนี้ไม่ทำงานอย่างแท้จริงตามที่ปรากฎ ขออภัยในความไม่สะดวก.

โพสต์ต้นฉบับด้านล่าง:

ฉันพบวิธีแก้ปัญหาขณะเล่นกับ internals Git!

1. สมมติว่าคุณอยู่ในพื้นที่เก็บข้อมูลของคุณ

2. สร้างไดเรกทอรีว่างเปล่าของคุณ:

   $ mkdir path/to/empty-folder
   

3. เพิ่มไปยังดัชนีโดยใช้คำสั่ง plumbing และแผนผังว่างSHA-1 :

   $ git update-index --index-info
   040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904    path/to/empty-folder
   

   พิมพ์คำสั่งแล้วป้อนบรรทัดที่สอง กดEnterและจากนั้นCtrl+ Dเพื่อยุติอินพุตของคุณ หมายเหตุ: รูปแบบคือโหมด [SPACE] ประเภท [SPACE] SHA-1hash [TAB]พา ธ (แท็บมีความสำคัญการจัดรูปแบบคำตอบไม่ได้เก็บไว้)

4. แค่นั้นแหละ! โฟลเดอร์ว่างของคุณอยู่ในดัชนีของคุณ สิ่งที่คุณต้องทำคือกระทำ

วิธีแก้ปัญหานี้สั้นและเห็นได้ชัดว่าทำงานได้ดี ( ดูการแก้ไข! ) แต่มันไม่ง่ายที่จะจำ ...

แผนผังว่างเปล่า SHA-1 สามารถพบได้โดยการสร้างที่เก็บ Git ว่างใหม่cdลงในและออกgit write-treeซึ่งจะส่งออกต้นไม้ว่าง SHA-1

แก้ไข:

ฉันใช้โซลูชันนี้ตั้งแต่ฉันพบมัน ดูเหมือนว่าจะทำงานในลักษณะเดียวกับการสร้าง submodule ยกเว้นว่าจะไม่มีการกำหนดโมดูลใด ๆ git submodule init|updateนี้นำไปสู่ข้อผิดพลาดเมื่อออก ปัญหาคือการgit update-indexเขียน040000 treeส่วนเข้าไป160000 commitใหม่

ยิ่งกว่านั้นไฟล์ใด ๆ ที่วางภายใต้เส้นทางนั้นจะไม่ถูกสังเกตเห็นโดย Git เนื่องจากมันคิดว่าเป็นของที่เก็บอื่น ๆ นี่เป็นสิ่งที่น่ารังเกียจเพราะมองข้ามไปได้ง่าย!

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

สมมติว่าคุณต้องการไดเร็กทอรีว่างชื่อtmp :

$ mkdir tmp
$ touch tmp/.gitignore
$ git add tmp
$ echo '*' > tmp/.gitignore
$ git commit -m 'Empty directory' tmp

กล่าวอีกนัยหนึ่งคุณต้องเพิ่มไฟล์. gitignore ไปยังดัชนีก่อนที่คุณจะสามารถบอกให้ Git เพิกเฉยได้ (และทุกอย่างในไดเรกทอรีว่าง)

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

mkdir --parents .generated/bin ## create a folder for storing generated binaries
mv myprogram1 myprogram2 .generated/bin ## populate the directory as needed

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

ln -sf .generated/bin bin
git add bin

เมื่อคุณต้องการล้างทรีซอร์สของคุณคุณสามารถทำได้เพียง:

rm -rf .generated ## this should be in a "clean" script or in a makefile

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

คุณสามารถละเว้นไฟล์ทั้งหมดที่สร้างขึ้นได้โดยเพิ่มสิ่งต่อไปนี้ในรูต. gitignore ของคุณ:

.generated

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

นี่คือเหตุผลที่ฉันตัดสินใจที่จะเขียนเครื่องมือโอเพนซอร์สซึ่งสามารถจัดการการสร้าง / ลบไฟล์ตัวยึดดังกล่าวโดยอัตโนมัติ มันถูกเขียนขึ้นสำหรับแพลตฟอร์ม. NET และทำงานภายใต้ Mono (.NET สำหรับ Linux) และ Windows

เพียงดูได้ที่: http://code.google.com/p/markemptydirs

ฉันชอบคำตอบของ @ Artur79 และ @mjs ดังนั้นฉันจึงใช้ทั้งสองอย่างร่วมกันและทำให้เป็นมาตรฐานสำหรับโครงการของเรา

find . -type d -empty -exec touch {}/.gitkeep \;

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

แก้ไขเพื่อทางออกที่ดีกว่า

ดังนั้นเนื่องจากนักพัฒนาซอฟต์แวร์ส่วนใหญ่ของเราติดตั้งAntอยู่แล้วสิ่งแรกที่ฉันคิดคือการรวมไฟล์ Ant build เข้าด้วยกันเพื่อทำสิ่งนี้โดยไม่ขึ้นกับแพลตฟอร์ม ยังสามารถพบได้ที่นี่

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

pip3 install gitkeep2

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

$ gitkeep --help
Usage: gitkeep [OPTIONS] PATH

  Add a .gitkeep file to a directory in order to push them into a Git repo
  even if they're empty.

  Read more about why this is necessary at: https://git.wiki.kernel.org/inde
  x.php/Git_FAQ#Can_I_add_empty_directories.3F

Options:
  -r, --recursive     Add or remove the .gitkeep files recursively for all
                      sub-directories in the specified path.
  -l, --let-go        Remove the .gitkeep files from the specified path.
  -e, --empty         Create empty .gitkeep files. This will ignore any
                      message provided
  -m, --message TEXT  A message to be included in the .gitkeep file, ideally
                      used to explain why it's important to push the specified
                      directory to source control even if it's empty.
  -v, --verbose       Print out everything.
  --help              Show this message and exit.

ฉันหวังว่าคุณพบว่ามีประโยชน์.

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

มีคำพูดออกไปที่ไหนสักแห่งที่ฉันอ่านครั้งเดียว

ฉันพบRe: ล้างไดเรกทอรี ..แต่อาจมีอีกอันหนึ่ง

คุณต้องอยู่กับวิธีแก้ปัญหา ... โชคไม่ดี

เมื่อคุณเพิ่ม.gitignoreไฟล์หากคุณต้องการใส่เนื้อหาจำนวนหนึ่ง (คุณต้องการให้ Git เพิกเฉย) คุณอาจต้องการเพิ่มบรรทัดเดียวด้วยเครื่องหมายดอกจัน*เพื่อให้แน่ใจว่าคุณจะไม่เพิ่มเนื้อหาที่ถูกละเว้นโดยไม่ตั้งใจ .

ไม่มีวิธีที่จะทำให้ Git ติดตามไดเรกทอรีดังนั้นทางออกเดียวคือเพิ่มไฟล์ตัวแทนในไดเรกทอรีที่คุณต้องการให้ Git ติดตาม

ไฟล์สามารถตั้งชื่อและมีทุกอย่างที่คุณต้องการ แต่คนส่วนใหญ่ใช้ไฟล์เปล่าที่ชื่อ.gitkeep(แม้ว่าบางคนชอบ VCS-agnostic.keep )

คำนำหน้า .ทำเครื่องหมายว่าเป็นไฟล์ที่ซ่อนอยู่

อีกแนวคิดหนึ่งคือการเพิ่มREADMEไฟล์เพื่ออธิบายว่าจะใช้ไดเรกทอรีใด

ตามที่กล่าวถึงเป็นไปไม่ได้ที่จะเพิ่มไดเรกทอรีว่างเปล่า แต่นี่คือหนึ่งซับที่เพิ่มไฟล์. gitignore ที่ว่างเปล่าไปยังไดเรกทอรีทั้งหมด

ruby -e 'require "fileutils" ; Dir.glob(["target_directory","target_directory/**"]).each { |f| FileUtils.touch(File.join(f, ".gitignore")) if File.directory?(f) }'

ฉันติดสิ่งนี้ใน Rakefile เพื่อให้เข้าถึงได้ง่าย

วิธีการแก้ปัญหาของ Jamie Flournoy ใช้งานได้ดี นี่คือรุ่นปรับปรุงเล็กน้อยเพื่อให้.htaccess:

# Ignore everything in this directory
*
# Except this file
!.gitignore
!.htaccess

ด้วยวิธีนี้คุณสามารถที่จะกระทำโฟลเดอร์ที่ว่างเปล่าเช่น/log, /tmpหรือ/cacheและโฟลเดอร์จะอยู่ที่ว่างเปล่า

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

function check_page_custom_folder_structure () {
    if (!is_dir(TEMPLATEPATH."/page-customs"))
        mkdir(TEMPLATEPATH."/page-customs");    
    if (!is_dir(TEMPLATEPATH."/page-customs/css"))
        mkdir(TEMPLATEPATH."/page-customs/css");
    if (!is_dir(TEMPLATEPATH."/page-customs/js"))
        mkdir(TEMPLATEPATH."/page-customs/js");
}

นี่คือ PHP แต่ฉันแน่ใจว่าภาษาส่วนใหญ่รองรับฟังก์ชั่นเดียวกันและเนื่องจากการสร้างโฟลเดอร์ได้รับการดูแลโดยแอปพลิเคชันโฟลเดอร์จะอยู่ที่นั่นเสมอ

นี่คือแฮ็ค แต่มันตลกที่มันใช้งานได้ (Git 2.2.1) คล้ายกับสิ่งที่ @Teka แนะนำ แต่ง่ายต่อการจดจำ:

• เพิ่ม submodule ไปยังที่เก็บใด ๆ (git submodule add path_to_repo )
• จะเป็นการเพิ่มโฟลเดอร์และไฟล์ .submodulesนี้จะเพิ่มโฟลเดอร์และไฟล์กระทำการเปลี่ยนแปลง
• ลบ.submodulesไฟล์และส่งมอบการเปลี่ยนแปลง

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

ร้ายแรง: ไม่ใช่ชื่อวัตถุที่ถูกต้อง b64338b90b4209263b50244d18278c0999867193

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

หลายคนตอบคำถามนี้ไปแล้ว เพียงเพิ่มรุ่น PowerShell ที่นี่

ค้นหาโฟลเดอร์ว่างทั้งหมดในไดเรกทอรี

เพิ่มไฟล์. gitkeep ที่ว่างเปล่าในนั้น

Get-ChildItem 'Path to your Folder' -Recurse -Directory | Where-Object {[System.IO.Directory]::GetFileSystemEntries($_.FullName).Count -eq 0} | ForEach-Object { New-Item ($_.FullName + "\.gitkeep") -ItemType file}

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

/app/data/**/*.* !/app/data/**/*.md

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

คุณสามารถเติมไดเรกทอรีเหล่านี้ทั้งหมดด้วยไฟล์ xml / images หรืออะไรก็ได้และเพิ่มไดเรกทอรีเพิ่มเติมภายใต้ /app/data/เมื่อเวลาผ่านไปตามความต้องการที่เก็บข้อมูลสำหรับแอปของคุณพัฒนา (ด้วยไฟล์ README.md ที่ให้บริการเพื่อเขียนในรายละเอียดว่า ตรง)

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

วิธีง่ายๆในการทำเช่นนี้คือการเพิ่ม.gitkeepไฟล์ไปยังไดเรกทอรีที่คุณต้องการ (ในปัจจุบัน) ทำให้ว่างเปล่า

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

เพิ่มอีกหนึ่งตัวเลือกในการต่อสู้

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

รูปแบบดังกล่าวคือ:

*
!.gitignore

ทีนี้ถ้าคุณต้องการวิธีที่จะทำสิ่งนี้ที่ command line, ในคราวเดียว, ในขณะที่อยู่ในไดเร็กตอรี่ที่คุณต้องการเพิ่ม, คุณสามารถรัน:

$ echo "*" > .gitignore && echo '!.gitignore' >> .gitignore && git add .gitignore

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

#!/bin/bash

dir=''

if [ "$1" != "" ]; then
    dir="$1/"
fi

echo "*" > $dir.gitignore && \
echo '!.gitignore' >> $dir.gitignore && \
git add $dir.gitignore

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

$ ignore_dir ./some/directory

ตัวเลือกอื่น (เพื่อตอบกลับความคิดเห็นโดย @GreenAsJade) หากคุณต้องการติดตามโฟลเดอร์ว่างที่MAYมีไฟล์ที่ถูกติดตามในอนาคต แต่จะว่างเปล่าในตอนนี้คุณสามารถ*ออกจาก.gitignoreไฟล์และตรวจสอบสิ่งต่อไปนี้ โดยพื้นฐานแล้วไฟล์ทั้งหมดที่พูดคือ "อย่าเพิกเฉยฉัน " แต่อย่างอื่นไดเรกทอรีนั้นว่างเปล่าและถูกติดตาม

.gitignoreไฟล์ของคุณจะมีลักษณะดังนี้:

!.gitignore

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

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

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

สร้างไดเรกทอรีที่ต้องการก่อน:

mkdir empty

จากนั้นคุณเพิ่มลิงก์สัญลักษณ์ที่เสียหายไปยังไดเรกทอรีนี้ (แต่ในกรณีอื่นนอกเหนือจากกรณีการใช้งานที่อธิบายไว้ด้านบนโปรดใช้ a READMEพร้อมคำอธิบาย):

ln -s .this.directory empty/.keep

ในการเพิกเฉยไฟล์ในไดเรกทอรีนี้คุณสามารถเพิ่มเข้าไปในรูทของคุณได้.gitignore:

echo "/empty" >> .gitignore

ในการเพิ่มไฟล์ที่ถูกละเว้นให้ใช้พารามิเตอร์เพื่อบังคับ:

git add -f empty/.keep

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

find empty -type f

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

$ php -r "var_export(glob('empty/.*'));"
array (
  0 => 'empty/.',
  1 => 'empty/..',
)

แต่ฉันขอแนะนำอย่างยิ่งให้ใช้โซลูชันนี้เฉพาะในกรณีพิเศษการเขียนที่ดีREADMEในไดเรกทอรีว่างมักเป็นวิธีที่ดีกว่า (และฉันไม่รู้ว่ามันใช้งานได้กับระบบไฟล์ windows ... )

การอ่านคำตอบของ@ofavreและ@ stanislav-bashkyrtsevโดยใช้การอ้างอิง submodule GIT ที่เสียเพื่อสร้างไดเรกทอรี GIT ฉันแปลกใจที่ไม่มีใครแนะนำเลยว่าการแก้ไขความคิดนี้ง่ายและปลอดภัยทั้งหมด:

แทนที่จะเจาะ submodule ปลอมเข้า GITเพียงเพิ่มจริงที่ว่างเปล่า

ป้อน: https://gitlab.com/empty-repo/empty.git

ที่เก็บ GIT ที่มีหนึ่งคอมมิชชัน:

commit e84d7b81f0033399e325b8037ed2b801a5c994e0
Author: Nobody <none>
Date: Thu Jan 1 00:00:00 1970 +0000

ไม่มีข้อความไม่มีไฟล์ที่คอมมิท

การใช้

ในการเพิ่มไดเรกทอรีว่างให้คุณ repo GIT:

git submodule add https://gitlab.com/empty-repo/empty.git path/to/dir

ในการแปลงไดเรกทอรีว่างที่มีอยู่ทั้งหมดเป็น submodules:

find . -type d -empty -delete -exec git submodule add -f https://gitlab.com/empty-repo/empty.git \{\} \;

Git จะเก็บแฮชคอมมิทล่าสุดเมื่อสร้างการอ้างอิง submodule ดังนั้นคุณไม่ต้องกังวลเกี่ยวกับตัวฉัน (หรือ GitLab) โดยใช้สิ่งนี้เพื่อฉีดไฟล์ที่เป็นอันตราย น่าเสียดายที่ฉันไม่พบวิธีบังคับให้ใช้รหัสยืนยันใด ๆ ในระหว่างการชำระเงินดังนั้นคุณจะต้องตรวจสอบด้วยตนเองว่าใช้รหัสยืนยันการe84d7b81f0033399e325b8037ed2b801a5c994e0ใช้งานด้วยตนเองgit submodule statusหลังจากเพิ่มธุรกรรมซื้อคืนแล้ว

ยังคงไม่ได้เป็นทางออกพื้นเมือง แต่ที่ดีที่สุดที่เราอาจจะมีใครสักคนโดยไม่ต้องได้รับในมือของพวกเขาจริงๆ , จริงๆสกปรกใน codebase GIT

ภาคผนวก: การสร้างความมุ่งมั่นนี้อีกครั้ง

คุณควรจะสามารถสร้างการกระทำที่แน่นอนนี้โดยใช้ (ในไดเรกทอรีว่าง):

# Initialize new GIT repository
git init

# Set author data (don't set it as part of the `git commit` command or your default data will be stored as “commit author”)
git config --local user.name "Nobody"
git config --local user.email "none"

# Set both the commit and the author date to the start of the Unix epoch (this cannot be done using `git commit` directly)
export GIT_AUTHOR_DATE="Thu Jan 1 00:00:00 1970 +0000"
export GIT_COMMITTER_DATE="Thu Jan 1 00:00:00 1970 +0000"

# Add root commit
git commit --allow-empty --allow-empty-message --no-edit

การสร้าง GIT ที่ทำซ้ำได้ยากมาก ...

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

คุณสามารถบันทึกรหัสนี้เป็น create_readme.php และเรียกใช้รหัสPHPจากไดเรกทอรีรากของโครงการ Git ของคุณ

> php create_readme.php

มันจะเพิ่มไฟล์ README ไปยังไดเรกทอรีทั้งหมดที่ว่างเปล่าดังนั้นไดเรกทอรีเหล่านั้นจะถูกเพิ่มไปยังดัชนี

<?php
    $path = realpath('.');
    $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path),       RecursiveIteratorIterator::SELF_FIRST);
    foreach($objects as $name => $object){
        if ( is_dir($name) && ! is_empty_folder($name) ){
            echo "$name\n" ;
            exec("touch ".$name."/"."README");
        }
    }

    function is_empty_folder($folder) {
        $files = opendir($folder);
        while ($file = readdir($files)) {
            if ($file != '.' && $file != '..')
                return true; // Not empty
            }
        }
?>

จากนั้นทำ

git commit -m "message"
git push