ลักษณะตัวเลือกบรรทัดคำสั่ง - POSIX หรืออะไร

อยู่ที่ไหนสักแห่งที่ฉันเห็นว่าพูดจาโผงผางกับ java / javac ที่ถูกกล่าวหาว่าใช้การผสมผสานระหว่าง Windows และ Unix style

java -classpath ... -ea ... Something

IMHO มันไม่มีการผสมผสานมันก็เหมือนfindงานเหมือนกันใช่ไหม AFAIK ตาม POSIX ไวยากรณ์ควรเป็นเช่นนั้น

java --classpath ... --ea ... Something

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

ฉันกำลังเขียนโปรแกรมอรรถประโยชน์ขนาดเล็กใน Java และไม่ว่าในกรณีใดฉันจะใช้รูปแบบ Windows /a /bเนื่องจากฉันสนใจ Unix เป็นหลัก ฉันควรเลือกรูปแบบใด

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

มีข้อยกเว้นสำหรับกฎ - findตัวอย่างเช่น - แต่สิ่งเหล่านี้เป็นเพราะสิ่งที่มีมาก่อนในระบบปฏิบัติการยูนิกซ์

X Windows (X11) ใช้findตัวเลือกเส้นประยาวเหมือนตัวเดียว

ตัวเลือกชื่อแบบยาวสองเท่าถูกบุกเบิกโดย GNU (หลังจากทางอ้อมใช้+เป็นส่วนนำหน้า)

ดูคำถามStackOverflowนี้สำหรับการอภิปรายเกี่ยวกับระบบจัดการอาร์กิวเมนต์บรรทัดคำสั่งที่เป็นที่รู้จัก - มีจำนวนมาก ( ตั้งแต่นี้ถูกเขียนในอำนาจที่จะตัดสินใจคำถาม SO 367309 ไม่ได้เป็นแบบที่ดีสำหรับ SO. ฉันได้โอนคำตอบของคำถามอื่นคืออะไรไวยากรณ์ทั่วไปของคำสั่ง Unix เปลือก? . )

คุณสามารถขยายรายการของเทคนิคต่าง ๆ เพื่อให้ครอบคลุมgit(และระบบอื่น ๆ ) ซึ่งคุณได้รับโครงสร้างเช่น:

• basecommand[ ตัวเลือกสากล ] subcommand[ ตัวเลือกคำสั่งย่อย ] [ชื่อ ... ]

อาจมีคำสั่งย่อยจำนวนมากแต่ละคำสั่งมีตัวเลือกย่อย

แน่นอน Windows ใช้เครื่องหมายทับ (ใช้แล้ว) ' /' เพื่อระบุตัวเลือกแทนเครื่องหมายขีดกลาง ' -'

JCL (สำหรับ z / OS และ OS / 360 และระบบระดับกลาง) มีแนวโน้มที่จะใช้พารามิเตอร์ตำแหน่งคั่นด้วยเครื่องหมายจุลภาคและโดยทั่วไปถือว่าไม่เป็นมิตรกับผู้ใช้หรืออินเทอร์เฟซที่ดี

แก้ไข:มันได้รับการชี้ให้เห็นว่าสไตล์นี้เป็น GNU-ism และ Unixes ที่ไม่ใช้ GNU นั้นมีแนวโน้มที่จะใช้ไวยากรณ์แบบเส้นประเดียว (โดยเฉพาะอย่างยิ่งตัวแปร OS X และ BSD)

แม้จะเป็นสถานะ GNU-ism แต่โปรแกรม Unix สไตล์ใหม่ที่เขียนขึ้นใช้สไตล์นี้:

• --long-option สำหรับชื่อตัวเลือกแบบยาว
• -s สำหรับตัวเลือกสั้น ๆ (หนึ่งอักขระ)
• -abc สำหรับตัวเลือกสั้น ๆ หลายรายการโดยไม่มีอาร์กิวเมนต์ (หนึ่งตัวอักษรต่อตัวเลือก)
• ตัวเลือกที่มีข้อโต้แย้ง:
  • --long argหรือ--long=argสำหรับตัวเลือกยาว
  • -s arg, -sargหรือ (ขยะ) -s=argสำหรับตัวเลือกที่สั้น สิ่งนี้สามารถรวมกับตัวเลือกสั้น ๆ อื่น ๆ ตราบใดที่มีเพียงข้อสุดท้ายเท่านั้นที่มีข้อโต้แย้ง
• ตัวเลือก "semantic" เดียวกันนั้นสามารถมีนามแฝงได้หลายตัวโดยส่วนใหญ่จะเป็นชื่อสั้น ๆ

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

¹ตัวอย่างเช่นบางส่วนของโปรแกรมที่ใช้รูปแบบนี้ (บนเครื่อง Linux ของฉัน): ls, grep, man, sed, bashฯลฯ ( แก้ไข:เหล่านี้จะเห็นได้ชัดว่า GNU-ISMS แม้ว่า BSD และ OS X เครื่องไม่ได้ใช้รูปแบบนี้)

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

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

• อาร์กิวเมนต์ที่มีเส้นประ ( --long-arg) เป็นแบบแผน GNU (ดูการใช้งานของgetopt )
• คำสั่ง POSIX จะไม่ใช้อาร์กิวเมนต์เส้นประสองครั้ง สิ่งนี้ใช้กับตัวแปรส่วนใหญ่ของ Unix (Mac OS X, BSD) ยกเว้น Linux ซึ่งใช้ GNU โดยค่าเริ่มต้น

สำหรับโครงการ Java ของคุณคุณอาจต้องการตรวจสอบGNU getopt สำหรับ JavaหรือApache CLI พวกเขาสนับสนุนการประชุมทั้งสอง

ตัวเลือกที่สามคือการใช้อาร์กิวเมนต์ Java VM และให้รันไทม์แจงให้คุณ:

 $ java -Dcolor=blue

จากนั้นในรหัส:

 System.getProperty("color");

โดยส่วนตัวแล้วฉันจะใช้-Dสำนวนและห่อคาถา Java ไว้ใน shell-script ซึ่งจัดการการแยกบรรทัดคำสั่งรวมถึงการตรวจสอบ classpath เป็นต้นซึ่งทำให้ผู้ใช้ทั่วไปสามารถรันโปรแกรม Java ของคุณได้ง่ายขึ้น

มันขึ้นอยู่กับ. ฉันชอบสไตล์ POSIX เป็นการส่วนตัว แต่ในกรณีของคุณฉันอาจตั้งเป้าหมายให้สอดคล้องกับสภาพแวดล้อมที่เครื่องมือของคุณจะถูกใช้ นี่หมายถึงการใช้ระเบียบ Java สำหรับ JARs (เว้นแต่ว่าคุณวางแผนที่จะมีสคริปต์ตัวคลุมที่จะทำให้มันดูเหมือนคำสั่ง Unix ทั่วไป)