ฉันมีข้อสงสัยเกี่ยวกับ CamelCase นึกว่าคุณมีตัวย่อนี้:Unesco = United Nations Educational, Scientific and Cultural Organization.

คุณควรเขียน: unitedNationsEducationalScientificAndCulturalOrganization

แต่ถ้าคุณต้องการเขียนคำย่อ สิ่งที่ต้องการ:

getUnescoProperties();

การเขียนด้วยวิธีนี้ถูกต้องหรือไม่ getUnescoProperties() OR getUNESCOProperties();

แนวทางบางประการที่Microsoft ได้เขียนเกี่ยวกับcamelCaseคือ:

เมื่อใช้ตัวย่อให้ใช้ตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่สำหรับตัวย่อมากกว่าสองตัว ตัวอย่างเช่นใช้หรือHtmlButton htmlButtonอย่างไรก็ตามคุณควรใช้ประโยชน์จากตัวย่อที่ประกอบด้วยเพียงสองตัวละครเช่นแทนSystem.IOSystem.Io

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

สรุป:

• เมื่อคุณใช้ตัวย่อหรือตัวย่อที่มีความยาวสองตัวอักษรให้ใส่ทั้งหมดในตัวพิมพ์ใหญ่

• เมื่อตัวย่อยาวเกินสองตัวอักษรให้ใช้ตัวพิมพ์ใหญ่สำหรับอักขระตัวแรก

ดังนั้นในกรณีเฉพาะของคุณgetUnescoProperties()ถูกต้อง

มีการวิพากษ์วิจารณ์อย่างถูกกฎหมายเกี่ยวกับคำแนะนำของ Microsoftจากคำตอบที่ยอมรับได้

• การรักษาคำย่อ / คำย่อที่ไม่สอดคล้องกันขึ้นอยู่กับจำนวนตัวอักษร:
  • playerIDVS VSplayerIdplayerIdentifier
• คำถามว่าตัวย่อสองตัวอักษรควรยังคงเป็นตัวพิมพ์ใหญ่หรือไม่ถ้ามันปรากฏที่จุดเริ่มต้นของตัวระบุ:
  • USTaxes VS usTaxes
• ความยากลำบากในการจำแนกคำย่อหลายคำ:
  • ie USIDvs usId(หรือparseDBMXMLในตัวอย่างของ Wikipedia)

ดังนั้นฉันจะโพสต์คำตอบนี้เป็นทางเลือกแทนคำตอบที่ยอมรับ คำย่อทั้งหมดควรได้รับการปฏิบัติอย่างสม่ำเสมอ คำย่อควรได้รับการปฏิบัติเหมือนคำอื่น ๆ การอ้างถึง Wikipedia :

... โปรแกรมเมอร์บางคนชอบที่จะใช้คำย่อราวกับว่ามันเป็นคำเล็ก ๆ ...

ดังนั้นคำถามของ OP ฉันเห็นด้วยกับคำตอบที่ยอมรับ สิ่งนี้ถูกต้อง:getUnescoProperties()

แต่ฉันคิดว่าฉันจะได้ข้อสรุปที่แตกต่างในตัวอย่างเหล่านี้:

• US Taxes → usTaxes
• Player ID → playerId

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

Camel Case เป็นแบบแผนไม่ใช่ข้อกำหนด ดังนั้นฉันเดากฎความเห็นยอดนิยม

( แก้ไข:ลบข้อเสนอแนะนี้เพื่อให้คะแนนควรตัดสินใจเรื่องนี้ตามที่ @Brian David พูดว่า Stack Overflow ไม่ใช่ "การประกวดความนิยม" และคำถามนี้ถูกปิดเป็น "อิงตามความคิดเห็น")

แม้ว่าคนจำนวนมากชอบที่จะรักษาคำย่อเหมือนคำอื่น ๆ แต่การฝึกฝนโดยทั่วไปอาจจะใช้คำย่อในตัวพิมพ์ใหญ่ทั้งหมด (แม้ว่ามันจะนำไปสู่ ​​"สิ่งที่น่ารังเกียจ")

• ดู "EDXML" ในXML schema นี้
• ดู "SFAS158" ในXBRL schema นี้

แหล่งข้อมูลอื่น ๆ :

• หมายเหตุบางคนแยกความแตกต่างระหว่างตัวย่อและตัวย่อ
• หมายเหตุแนวทางของ Microsoft แยกแยะระหว่างตัวย่อสองตัวอักษรและ "ตัวย่อยาวเกินสองอักขระ"
• หมายเหตุบางคนแนะนำให้หลีกเลี่ยงตัวย่อ / ตัวย่อทั้งหมด
• หมายเหตุบางคนแนะนำให้หลีกเลี่ยง CamelCase / PascalCase ทั้งหมด
• หมายเหตุบางคนแยกความแตกต่างระหว่าง "ความสอดคล้อง" เป็น "กฎที่ดูเหมือนไม่สอดคล้องกันภายใน" (เช่นการรักษาคำย่อสองตัวอักษรที่แตกต่างจากตัวย่อสามตัวอักษร); บางคนกำหนด "ความมั่นคง" เป็น "ใช้กฎเดียวกันอย่างสม่ำเสมอ" (แม้ว่ากฎจะไม่สอดคล้องกันภายใน)
• แนวทางการออกแบบกรอบ
• แนวทางของ Microsoft

ก่อนอื่นฉันต้องชี้แจงว่าฉันไม่ได้เป็นเจ้าของภาษาอังกฤษดังนั้นการกล่าวอ้างเกี่ยวกับไวยากรณ์ภาษาอังกฤษอาจผิด หากคุณพบข้อผิดพลาดดังกล่าวโปรดแจ้งให้เราทราบและฉันจะขอบคุณมาก

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

จากนั้นฉันคิดว่าUNESCOเหมาะสมกว่าUnescoเพราะเพียงใกล้กับรูปแบบชีวิตจริงที่คุ้นเคยมากขึ้น ฉันมีปัญหาบางอย่างที่จะเข้าใจความหมายของคำUnescoว่า

Arcในฐานะที่เป็นอีกตัวอย่างหนึ่งที่คิดเกี่ยวกับ มันฟังดูเหมือนโค้งรอบ ๆ วงกลม แต่ใน Rust หมายถึงAtomically Reference Countedอะไร หากมีการเขียนเช่นARCนั้นอย่างน้อยผู้อ่านจะจำได้ว่าคำศัพท์นั้นเป็นคำย่อของอย่างอื่นแทนที่จะเป็นเส้นโค้ง

โปรแกรมสมัยใหม่เขียนขึ้นเพื่อคนอ่านเป็นหลัก จากนั้นต้องตั้งกฎการตั้งชื่อเหล่านั้นเพื่อให้มนุษย์สามารถอ่านได้มากกว่าการประมวลผลหรือการวิเคราะห์ด้วยเครื่องจักร

ในมุมมองนี้เราสูญเสียความสามารถในการอ่านโดยใช้UnescoไปโดยUNESCOไม่ได้อะไรเลย

และสำหรับกรณีอื่น ๆ ผมคิดว่าต่อไปนี้เป็นเพียงธรรมดากฎตัวย่อภาษาอังกฤษ (หรือการประชุม)ก็เพียงพอสำหรับกรณีส่วนใหญ่สำหรับการอ่านที่ดีที่สุด

ในการแปลงเป็น CamelCase ยังมีอัลกอริทึมกรณี Camel กรณีที่ Google กำหนดไว้ (เกือบ) :

เริ่มต้นด้วยรูปแบบร้อยแก้วของชื่อ:

1. แปลงวลีเป็น ASCII ธรรมดาและลบอะพอสโทรฟีใด ๆ ตัวอย่างเช่น "อัลกอริทึมของMüller" อาจกลายเป็น "อัลกอริทึม Muellers"
2. แบ่งผลลัพธ์นี้ออกเป็นคำโดยแยกช่องว่างและเครื่องหมายวรรคตอนที่เหลือ (โดยปกติคือเครื่องหมายขีดกลาง)
   1. แนะนำ: หากคำใด ๆ ที่มีลักษณะตัวเรือนอูฐธรรมดาอยู่แล้วในการใช้งานทั่วไปให้แบ่งคำนี้ออกเป็นส่วนต่าง ๆ ของมัน (เช่น "AdWords" กลายเป็น "คำโฆษณา") โปรดทราบว่าคำเช่น "iOS" ไม่ใช่ในกรณีของอูฐ มันเป็นการฝ่าฝืนอนุสัญญาใด ๆ ดังนั้นคำแนะนำนี้จึงไม่มีผลบังคับใช้
3. ตอนนี้ทุกอย่างเป็นตัวพิมพ์เล็ก (รวมถึงตัวย่อ) แล้วพิมพ์ใหญ่เป็นตัวอักษรตัวแรกของ:
   1. ... แต่ละคำเพื่อให้ได้ตัวอูฐตัวสูงหรือ
   2. ... แต่ละคำยกเว้นคำแรกเพื่อให้ได้ตัวพิมพ์เล็ก
4. สุดท้ายเข้าร่วมคำทั้งหมดเป็นตัวระบุเดียว

โปรดทราบว่าปลอกของคำเดิมนั้นแทบจะไม่สนใจเลย

ในตัวอย่างต่อไปนี้ "คำขอ XML HTTP" ถูกแปลงเป็น XmlHttpRequest อย่างถูกต้อง XMLHTTPRequest ไม่ถูกต้อง

getUnescoProperties() ควรเป็นทางออกที่ดีที่สุด ...

เมื่อเป็นไปได้เพียงทำตามความบริสุทธิ์camelCaseเมื่อคุณมีคำย่อให้ปล่อยให้ตัวพิมพ์ใหญ่เป็นไปcamelCaseได้

โดยทั่วไปในตัวแปรการเขียนโปรแกรม OO ควรเริ่มต้นด้วยตัวอักษรพิมพ์เล็ก ( lowerCamelCase) และคลาสควรเริ่มต้นด้วยอักษรตัวพิมพ์ใหญ่ (UpperCamelCase )

เมื่อมีข้อสงสัยก็ไปบริสุทธิ์camelCase;)

parseXMLเป็นเรื่องปกติparseXmlนอกจากนี้ยังมีcamelCase

XMLHTTPRequestควรเป็นXmlHttpRequestหรือxmlHttpRequestไม่มีวิธีที่จะไปกับคำย่อตัวพิมพ์ใหญ่ที่ตามมามันไม่ชัดเจนสำหรับกรณีทดสอบทั้งหมด

เช่นวิธีการทำคุณอ่านคำนี้HTTPSSLRequest, HTTP + SSLหรือHTTPS + SL(ที่ไม่ได้หมายความว่าอะไร แต่ ... ) ในกรณีที่กรณีดังต่อไปนี้อูฐประชุมและไปhttpSslRequestหรือhttpsSlRequestบางทีมันอาจจะไม่มีความสุขอีกต่อไป แต่เป็นที่แน่นอนชัดเจนมากขึ้น

มีairbnb JavaScript Style Guideที่ github พร้อมดวงดาวมากมาย (ประมาณ 57.5k ในขณะนี้) และคำแนะนำเกี่ยวกับคำย่อที่พูดว่า:

คำย่อและการเริ่มต้นควรจะเป็นตัวพิมพ์ใหญ่ทั้งหมดหรือตัวพิมพ์เล็กทั้งหมด

ทำไม? ชื่อมีไว้สำหรับความสามารถในการอ่านไม่ใช่เพื่อเอาใจคอมพิวเตอร์

// bad
import SmsContainer from './containers/SmsContainer';

// bad
const HttpRequests = [
  // ...
];

// good
import SMSContainer from './containers/SMSContainer';

// good
const HTTPRequests = [
  // ...
];

// also good
const httpRequests = [
  // ...
];

// best
import TextMessageContainer from './containers/TextMessageContainer';

// best
const requests = [
  // ...
];

ขณะนี้ฉันกำลังใช้กฎต่อไปนี้:

1. XMLHTTPRequestกรณีเงินกองทุนเพื่อรองรับคำย่อ: xmlHTTPRequest, requestIPAddress,

2. ID[entifier]กรณีอูฐสำหรับตัวย่อ: Exe[cutable], App[lication],

ID เป็นข้อยกเว้นขออภัย แต่เป็นความจริง

เมื่อฉันเห็นอักษรตัวใหญ่ฉันจะใช้คำย่อเช่นตัวอักษรแยกต่างหากสำหรับแต่ละตัวอักษร ตัวย่อไม่มีคำแยกสำหรับตัวอักษรแต่ละตัวดังนั้นฉันจึงใช้ตัวอูฐ

XMLHTTPRequest มันคลุมเครือ แต่มันเป็นกรณีที่หายากและมันก็ไม่คลุมเครือมากนักดังนั้นก็โอเคกฎและตรรกะมีความสำคัญมากกว่าความงาม

คู่มือสไตล์ JavaScript Airbnb พูดถึงสิ่งนี้เล็กน้อย โดยทั่วไป:

// bad
const HttpRequests = [ req ];

// good
const httpRequests = [ req ];

// also good
const HTTPRequests = [ req ];

เพราะโดยปกติฉันจะอ่านตัวพิมพ์ใหญ่ที่เป็นตัวชี้นำในชั้นเรียน ในตอนท้ายของวันมันคือการตั้งค่าทั้งหมด

นอกจากสิ่งที่ @valex พูดแล้วฉันต้องการสรุปสองสิ่งด้วยคำตอบที่ให้สำหรับคำถามนี้

ฉันคิดว่าคำตอบทั่วไปคือมันขึ้นอยู่กับภาษาการเขียนโปรแกรมที่คุณใช้

C ชาร์ป

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

จาวาสคริ

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

encodeURIComponent XMLHttpRequest toJSON toISOString

คำปฏิเสธ: ภาษาอังกฤษไม่ใช่เสียงแม่ของฉัน แต่ฉันคิดเกี่ยวกับปัญหานี้มาเป็นเวลานานโดยเฉพาะเมื่อใช้โหนด (สไตล์ camelcase) เพื่อจัดการฐานข้อมูลเนื่องจากชื่อของเขตข้อมูลตารางควรจะเป็นงูนี่คือความคิดของฉัน:

โปรแกรมเมอร์มีคำย่อสองชนิดสำหรับโปรแกรมเมอร์:

• ในภาษาธรรมชาติยูเนสโก
• ในภาษาโปรแกรมคอมพิวเตอร์ตัวอย่างเช่นtmc and textMessageContainerซึ่งมักจะปรากฏเป็นตัวแปรท้องถิ่น

ในโลกแห่งการเขียนโปรแกรมคำย่อทั้งหมดในภาษาธรรมชาติควรได้รับการปฏิบัติเสมือนคำว่า :

1. เมื่อเราเขียนโปรแกรมเราควรตั้งชื่อตัวแปรทั้งในรูปแบบตัวย่อหรือไม่ใช่ตัวย่อ ดังนั้นถ้าเราตั้งชื่อฟังก์ชั่น getUNESCOProperties ก็หมายความว่ายูเนสโกเป็นตัวย่อ (ไม่อย่างนั้นมันไม่ควรเป็นตัวอักษรตัวพิมพ์ใหญ่ทั้งหมด) แต่เห็นได้ชัดgetและpropertiesไม่ใช่ตัวย่อ ดังนั้นเราควรตั้งชื่อฟังก์ชั่นนี้ไม่ว่าจะเป็นgunescopหรือgetUnitedNationsNationalEducationalSocialificAndCulturalOrganizationPropertiesซึ่งทั้งคู่ยอมรับไม่ได้

2. ภาษาธรรมชาติมีการพัฒนาอย่างต่อเนื่องและ ตัวย่อของวันนี้จะกลายเป็นคำศัพท์พรุ่งนี้แต่โปรแกรมควรเป็นอิสระจากแนวโน้มนี้และยืนอยู่ตลอดไป

โดยวิธีการในคำตอบที่ได้รับการโหวตมากที่สุด IO เป็นตัวย่อในความหมายภาษาคอมพิวเตอร์ (ย่อมาจาก InputOutput) แต่ฉันไม่ชอบชื่อเนื่องจากฉันคิดว่าตัวย่อ (ในภาษาคอมพิวเตอร์) ควรใช้เพื่อตั้งชื่อเท่านั้น ตัวแปรโลคัล แต่คลาส / ฟังก์ชันระดับบนสุดดังนั้น InputOutput ควรใช้แทน IO

ยูเนสโกเป็นกรณีพิเศษเนื่องจากมักจะอ่านเป็นคำศัพท์ไม่ใช่ตัวย่อเช่นยูฟ่า RADA บาฟต้าและไม่เหมือนกับ BBC, HTML, SSL

นอกจากนี้ยังมีรูปแบบการประชุม camelcase อื่นที่พยายามสนับสนุนการอ่านคำย่อโดยใช้ตัวพิมพ์ใหญ่ ( HTML) หรือตัวพิมพ์เล็ก ( html) แต่หลีกเลี่ยงทั้งสอง (Html )

getUNESCOPropertiesดังนั้นในกรณีของคุณคุณสามารถเขียน คุณสามารถเขียนunescoPropertiesตัวแปรหรือUNESCOPropertiesคลาสได้ (แบบแผนสำหรับคลาสคือเริ่มต้นด้วยตัวพิมพ์ใหญ่)

กฎนี้จะยุ่งยากหากคุณต้องการรวมคำย่อสองตัวเข้าด้วยกันตัวอย่างเช่นคลาสที่ชื่อ XML HTTP Request มันจะเริ่มต้นด้วยตัวพิมพ์ใหญ่ แต่เนื่องจากXMLHTTPRequestจะไม่ง่ายในการอ่าน (เป็น XMLH TTP Request หรือไม่) และXMLhttpRequestจะทำลายการประชุม camelcase (มันคือ XM Lhttp Request?) ตัวเลือกที่ดีที่สุดคือการผสมเคส: XMLHttpRequestซึ่งเป็น จริงว่าW3C ใช้ อย่างไรก็ตามการใช้ namings ประเภทนี้ไม่สนับสนุน สำหรับตัวอย่างนี้HTTPRequestจะเป็นชื่อที่ดีกว่า

เนื่องจากคำภาษาอังกฤษอย่างเป็นทางการสำหรับการระบุตัวตน / ตัวตนดูเหมือนจะเป็น ID แม้ว่าจะไม่ใช่ตัวย่อคุณสามารถใช้กฎเดียวกันกับที่นั่น

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