คำนำหน้าประเภทและขอบเขตมีประโยชน์หรือไม่

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

int nTickCount  
bool bConnected  
object[] m_aItems  
fSum += fWeight * fValue  
class cManager  
enum etSystemStates  
etSystemStates eState   
cManager.cs

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

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

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

Joel Spolsky เขียนบทความเกี่ยวกับสาเหตุที่มีสัญกรณ์ฮังการีอยู่และสิ่งที่ตั้งใจไว้เพื่อช่วยตอบคำถามของคุณ

คำนำหน้าเช่น tbl สำหรับตารางฐานข้อมูล, int สำหรับจำนวนเต็ม ฯลฯ โดยทั่วไปจะไม่มีประโยชน์ - มันเป็นเรื่องเล็กน้อยที่จะคิดออกว่าอะไรคือสิ่งที่มาจากบริบทหรือจากเครื่องมือในการพัฒนาของคุณในกรณีเหล่านั้น สิ่งที่ต้องการการวัดแบบอิมพีเรียลและการวัดผลนั้นมีเหตุผลมากกว่านี้เพราะมิฉะนั้นคุณจะเห็นได้ว่ามันเป็นจำนวนจุดลอยตัว

area = width * height

ดูดีอย่างสมบูรณ์แบบในขณะที่

impArea = metWidth * impHeight

แสดงให้คุณเห็นทันทีว่ามีบางอย่างผิดปกติ

ส่วนตัวฉันใช้ชื่อตัวแปรอธิบาย $ number_of_items เห็นได้ชัดว่าเป็นการนับจำนวนเต็ม $ input_file_handle, $ is_active และ $rypt_password มีประเภทที่ชัดเจนทั้งในแง่ของประเภทข้อมูลภาษาและประเภทความหมาย

สิ่งที่คุณอธิบายเรียกว่าสัญกรณ์ฮังการี มันเคยถูกพิจารณาว่าเป็นการปฏิบัติที่ดีที่สุด แต่ตอนนี้กำลังขมวดคิ้วอยู่

บทความ Wikipedia มีส่วนหนึ่งเกี่ยวกับข้อดีข้อเสีย

ใช่คำนำหน้าอาจมีประโยชน์ แต่ฉันมีข้อเสนอแนะสองสามข้อ:

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

ในภาษาที่มีการพิมพ์แบบสแตติกไม่เพียง แต่คัดลอกชนิดของตัวแปร เช่น "bSubscribeed" เป็นชื่อที่ไม่ดีสำหรับตัวแปรบูลีนใน C # หรือ Java เพราะ IDE ของคุณรู้อยู่แล้วว่ามันคืออะไร ใน C ในทางกลับกันซึ่งขาดประเภทบูลีนนี่จะเป็นข้อมูลที่มีประโยชน์

ใน C # และ Java คุณอาจพิจารณาคำนำหน้าเพื่อแสดงว่าวัตถุอาจเป็นโมฆะ หรือว่าสตริงได้รับการหลบหนี html หรือว่ามันหมายถึงการแสดงออกปกติหรือคำสั่ง SQL หรือว่าเรียงลำดับแล้ว ใช้จินตนาการของคุณ.

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

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

สิ่งที่สำคัญกว่าคือไกล: ใช้ชื่อที่สื่อความหมายสำหรับตัวแปรและฟังก์ชั่น ในตัวอย่างของคุณด้วย "ผลรวม", "น้ำหนัก" และ "ค่า" คุณอาจต้องการให้ชื่อที่มีความหมายมากขึ้น: "totalCost", "lumberWeight", "lumberValuePerOunce" (ฉันกำลังตั้งสมมติฐานบางอย่างที่นี่)

ฉันพบว่าการประชุมเช่นการเพิ่มชื่อตัวแปรด้วยอักขระที่บ่งบอกถึงประเภทที่จะทำให้เสียสมาธิในภาษาที่ทันสมัยมากที่สุด

นักพัฒนา. NET ส่วนใหญ่ปฏิบัติตามแนวทางการออกแบบของ Microsoft ( http://msdn.microsoft.com/en-us/library/ms229042.aspx ) ซึ่งค่อนข้างคล้ายกับ Java (ความแตกต่างที่สำคัญคือ Microsoft โปรดปราน Pascal Case สำหรับชื่อสมาชิกในขณะที่ Java โปรดปรานกรณีอูฐ)

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

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

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

ประเด็นแรกคือ "intStudentCount" มีความชัดเจนมากกว่าเช่น "numberOfStudents" หรือไม่ จะไม่ "invoiceLineItems" เป็นอย่างน้อยเป็นข้อมูลที่เป็น "aobjItems" (ชนิดข้อมูลควรเกี่ยวกับความหมายของข้อมูลในโดเมนปัญหาไม่ใช่การแสดงระดับต่ำ)

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

มันอาจขึ้นอยู่กับสาเหตุที่คุณเติมคำนำหน้าชื่อ

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

การมีคำนำหน้าbtสำหรับปุ่มช่วยให้ค้นหาปุ่มขวาได้ง่ายในภายหลังแทนที่จะมีชื่อมากมายปะปนกัน

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

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

ในภาษาที่พิมพ์แบบคงที่เช่นเดียวกับที่คุณกำลังใช้ความรู้สึกสะดวกสบายยิ่งขึ้นกับระบบการพิมพ์สัญลักษณ์ฮังการีที่มีความสำคัญน้อยกว่าจะกลายเป็น ดังนั้นใน Java หรือ C # และโดยเฉพาะอย่างยิ่งใน Haskell ฉันจะไม่คิดถึงการเพิ่มคำนำหน้าเหล่านั้นเพราะเครื่องมือของคุณสามารถบอกประเภทของการแสดงออกใด ๆ และจะจับข้อผิดพลาดส่วนใหญ่ที่เกิดจากการเข้าใจผิดประเภท

คำนำหน้ามักจะทำให้รู้สึกถึงวัตถุเช่นในรูปแบบที่คุณอาจมี 20 กล่องข้อความเรียกพวกเขาทั้งหมดtbSomethingทำให้รู้สึก

อย่างไรก็ตามส่วนใหญ่ฉันไม่คิดว่ามันคุ้มค่าโดยเฉพาะอย่างยิ่งสำหรับประเภทค่า

ตัวอย่างเช่นสมมติว่าคุณมี:

short shortValue = 0;
//stuff happens

เดือนต่อมาคุณพบว่าคุณต้องเปลี่ยนมัน - สั้นไม่ใหญ่พอ ตอนนี้คุณมี:

int shortValue = 0;
//stuff happens

หากคุณไม่เปลี่ยนชื่อของตัวแปร (ความเสี่ยงของการแตกรหัสมากกว่าการเปลี่ยนประเภทในกรณีนี้) ตอนนี้คุณมีรหัสที่สับสน

คุณจะมีชื่อที่อธิบายชื่อของมันได้ดีกว่า:

int loopCounter = 0;
//stuff happens

หากภายหลังนั้นต้องเปลี่ยนเป็นความยาว: ไม่มีปัญหา

อาจมีข้อโต้แย้งเพิ่มเติมสำหรับอนุสัญญาเหล่านี้ในภาษาที่พิมพ์แบบไดนามิกหรือแบบที่ไม่มี IDE

ฉันมักจะมีแนวโน้มที่จะใช้ตัวย่อ 2 ถึง 4 ตัวอักษรสำหรับประเภทที่ด้านหน้าของตัวแปรเอง บางครั้งดูเหมือนน่าเบื่อ แต่เมื่อคุณทำงานกับชนิดข้อมูลหรือสถานการณ์ที่ซับซ้อนมันจะมีประโยชน์ ฉันคิดว่ามันอยู่ในหมวดหมู่เคสอูฐล่าง

ดูตัวอย่างของคุณด้านบนมันจะได้รับการดัดแปลงเล็กน้อยเพื่อ:

int intTickCount;
bool boolConnected;
object[] aobjItems;

อาร์เรย์มีชนิดด้านหน้าอยู่เสมอเพื่อกำหนดอาร์เรย์ นอกจากนี้ยังช่วยให้ฉันจัดกลุ่มอินสแตนซ์ตัวแปรที่คล้ายกันเข้าด้วยกัน ตัวอย่างเช่นฉันสามารถใช้ ...

taStore.Fill(dtStore);

... ซึ่งระบุว่า Store TableAdapter ของฉันเติมลงใน Store DataTable

ฉันพยายามที่จะยึดมั่นในหลักการพื้นฐานที่ควรใส่คำนำหน้าและ / หรือคำต่อท้ายเฉพาะเมื่อมันทำให้โค้ดอ่านได้มากขึ้น (เช่นในภาษาอังกฤษธรรมดา)

ความลับน้อยกว่าดีกว่า ...

ทำไมมีวิธีเช่นนี้:

public boolean connect( String h, int p );

เมื่อคุณสามารถมีสิ่งนี้:

public boolean connect( String hostName, int port );

ยิ่งไปกว่านั้น IDEs ในปัจจุบันมีเครื่องมือที่ทรงพลังสำหรับการรีแฟคเตอร์ตัวแปร (โดยเฉพาะ Java), ชื่อเมธอด, คลาส, ฯลฯ ... ความคิดที่จะบอกว่าข้อมูลสูงสุดที่มีจำนวนตัวอักษรน้อยที่สุดนั้นค่อนข้างเก่า