การสะกดผิดโดยเจตนาเพื่อหลีกเลี่ยงคำที่สงวนไว้

ฉันมักจะเห็นรหัสที่มีการสะกดผิดโดยเจตนาของคำทั่วไปที่ดีขึ้นหรือแย่ลงกลายเป็นคำสงวน:

• klassหรือclazzสำหรับชั้นเรียน :Class clazz = ThisClass.class
• kountสำหรับการนับใน SQL:count(*) AS kount

โดยส่วนตัวแล้วฉันพบว่าการอ่านนี้ลดลง ในทางปฏิบัติของฉันเองฉันไม่ได้พบมากเกินไปกรณีที่ชื่อที่ดีกว่าอาจจะไม่ได้ถูกนำมาใช้ - หรือitemClassrecordTotal

ตัวอย่างจาก JavaDocs สำหรับClassแสดงสิ่งนี้ในพารามิเตอร์:

 public <U> Class<? extends U> asSubclass(Class<U> clazz)

นี่แสดงให้เห็นถึงกรณีการใช้งานที่สมเหตุสมผลหรือไม่?

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

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

Guide Styleของ Python นำเสนอปัญหานี้โดยเฉพาะและแนะนำ:

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

ดูเหมือนว่ากฎทั่วไปที่ค่อนข้างดีโดยถือว่ามันไม่ขัดแย้งกับความหมายของภาษาใดภาษาหนึ่ง

รหัสกลิ่น

string stringVariable = "";

โค้ดด้านบนไม่ได้บอกอะไรเกี่ยวกับตัวแปรที่ตั้งใจใช้

class Klass

ปัญหาเดียวกัน

string UserNameString = "bmackey"

โค้ดด้านบนไม่ควรต้องการสตริงคำหลักต่อท้ายชื่อตัวแปร หากคุณพบว่าคุณต้องการระบุประเภทด้วยชื่อตัวแปรรหัสของคุณยาวเกินไป ย่อ-refactor

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

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

จากแหล่งที่มาพร้อมกับ JDK 1.6 R21 ฉันพบ "clazz" 917 ครั้ง เห็นได้ชัดว่าพวกเขาคิดว่ามันเป็นสไตล์ที่ยอมรับได้

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

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

การสะกดผิดโดยเจตนาเพื่อหลีกเลี่ยงคำสงวนเป็นความคิดที่ไม่ดี

• การสะกดผิดยากที่จะแยกความแตกต่างจากการสะกดที่ถูกต้องดังนั้นจึงทำให้การอ่านรหัสยากขึ้น

• การสะกดคำยากที่จะจำได้ดังนั้นการสะกดผิดที่ไม่สอดคล้องกันหลายครั้งมีแนวโน้มที่จะแข่งขันในโค้ดซึ่งทำให้โค้ดยากต่อการเขียนและอ่านยากขึ้น

• คำที่สงวนไว้หมายถึงภาษาที่ใช้ในการแก้ปัญหาไม่ใช่เพื่อปัญหา ชื่อตัวแปรควรชี้ไปที่แนวคิดที่เกี่ยวข้องกับปัญหา

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

public static Method findBenchmarkMethod(BenchmarkRecord benchmark) {
    Class<?> benchmarkedClass = ClassUtils.loadClass(benchmark.generatedClass());
    return findBenchmarkMethod(benchmarkedClass, benchmark.generatedMethod());
}

Class clazzมีกลิ่นเหมือน "ฉันไม่ได้รำคาญที่จะพยายามหาชื่อที่ดี" ตัวแปรแสดงถึงบางสิ่งอยู่เสมอและชื่อที่ดีจะอธิบายสิ่งนั้น ฉันปฏิเสธที่จะจินตนาการว่าclazzตัวอย่างเช่นภายใต้สถานการณ์ใด ๆ เป็นชื่อที่ดีที่สุดที่เป็นไปได้ มันคือการอ้างอิงไปยังคลาส -> class_reference เป็นสำเนาของวัตถุคลาส -> class_copy ฯลฯ อาจเป็นไปได้ที่จะลดลง "คลาส" และเพียงแค่ใช้คำอธิบายเช่น

java.lang.SecurityManager.checkMemberAccess(Class<?> clazz, int which)
Parameters
    clazz -- the class that reflection is to be performed on.

ที่นี่ clazz เป็นคลาสเป้าหมายที่จะทำการตรวจสอบ

checkMemberAccess(Class<?> target, int which)

จะดีกว่าที่จะอธิบายสิ่งที่พารามิเตอร์ที่ใช้มานานกว่าจะเคย clazz

หากพวกเขาใช้ชื่อที่สงวนไว้สำหรับตัวแปรมันเป็นตัวแปรที่มีชื่อไม่ดี แม้ว่าจะเป็นชื่อที่ถูกต้องเช่น Class สำหรับซอฟต์แวร์ห้องเรียน

ตัวแปรที่มีชื่อไม่ดีนั้นเป็นสัญญาณของความคิดที่ไม่ดีหรือรหัสชั่วคราว - ระวังของ gotchas อื่น ๆ ในส่วนของซอฟต์แวร์ที่คุณกำลังบำรุงรักษา

ผมคิดว่าคำที่สะกดผิดโดยเจตนาหรือตัวย่อที่มีความคิดที่ดีถ้าใช้อย่างระมัดระวังและสม่ำเสมอ

พิจารณาใน Java:

class X { public X() { } }
X x = new X();
x.getClass;  // Wha?  How does "get" help anything?
x.class;     // Best, but requires more lexer/parser work
x.klass;     // At least as good as getClass
x.clazz;     // Same

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

1. คุณไม่รู้สึกอยากคิดชื่อที่ดี
2. คุณเพียงแค่ต้องการตัวแปรจำลองและไม่ต้องการชื่ออธิบาย

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

boolean isMyName(String testName) { return myName.equals(testName); }
boolean isMyName(String s) { return myName.equals(s); }

Date nextMeeting(Klass klass) { return /* something */ }
Date nextMeeting(Klass k) { return /* something */ }

คุณจะไม่สูญเสียอะไรกับชื่อตัวแปรแบบสั้นเมื่อเมธอดหรือโครงสร้างของโค้ดบอกคุณว่าต้องมีอะไร

ฉันเห็นการใช้งานที่ถูกต้องตามกฎหมายของClass klassการทำภาพสะท้อนที่คุณทำงานกับตัวอย่างของClassชั้นเรียนจริง

ฉันมักจะเห็นรหัสที่มีการสะกดผิดโดยเจตนาของคำทั่วไปที่ดีขึ้นหรือแย่ลงกลายเป็นคำสงวน:

คลาสหรือคลาสสำหรับคลาส: Class clazz = ThisClass.class

kount สำหรับการนับใน SQL: count (*) AS kount

โดยส่วนตัวแล้วฉันพบว่าการอ่านนี้ลดลง ในทางปฏิบัติของฉันเองฉันไม่พบหลายกรณีเกินไปที่ไม่สามารถใช้ชื่อที่ดีกว่าได้ - itemClass หรือ recordTotal

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

สำหรับตัวแปรท้องถิ่นและการโต้แย้งอย่างเป็นทางการมันไม่สำคัญ

ชื่อใด ๆ ก็ดีตราบใดที่มันไม่ได้ทำให้เข้าใจผิดหรือทำให้เสียสมาธิโดยเจตนา ในตัวอย่างของคุณ:

public static Method findBenchmarkMethod(BenchmarkRecord benchmark) {
    Class<?> clazz = ClassUtils.loadClass(benchmark.generatedClass());
    return findBenchmarkMethod(clazz, benchmark.generatedMethod());
}

ไม่สำคัญว่าตัวแปรโลคัลเดียวคือ "clazz" หรือ "klass" หรือ "cls" หรือเพียงแค่ "c" ฉันอาจจะแค่แสดงออกแบบอินไลน์:

return findBenchmarkMethod(ClassUtils.loadClass(benchmark.generatedClass()),
                           benchmark.generatedMethod());

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

ฉันคิดว่าการสะกดผิดเป็นความคิดที่ไม่ดีเสมอ มันไม่ดีสำหรับผู้อ่านของคุณ ฉัน, klassหนึ่งจะถูกสงสัยว่าฉันพลาดอะไรบางอย่างเมื่อผมเห็นคำว่า (พวกเขาหมายถึงclassหรือพวกเขาหมายถึงโจรสลัด?) อย่างน้อยสำหรับฉันการสะกดผิดทั้งหมดที่ฉันจำได้ว่าน่ารำคาญ

ในบางกรณีที่คำสงวนเป็นสิ่งสำคัญเพียงอย่างเดียวที่รู้เกี่ยวกับตัวแปรฉันจะใช้ทางเลือกต่อไปนี้:

• ถ้ามันอาร์กิวเมนต์ฟังก์ชั่นใช้แทนaClassclass

• ถ้ามันเป็นตัวแปรท้องถิ่นหรือสมาชิกใช้แทนmyClassclass

• ถ้าเป็นตัวเข้าถึงใช้แทนgetClass()class()

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

ข้อดีอย่างหนึ่งของการสะกดคำที่สร้างสรรค์คือความสามารถในการค้นหาที่ดีขึ้น ฉันคิดว่ามันง่ายกว่าที่จะทำการค้นหาโค้ดโดยเฉพาะสำหรับสิ่งที่แปลกใหม่กว่าสำหรับคำทั่วไปซึ่งบ่อยครั้งที่คุณจะพบสิ่งผิดทั้งหมดและอีก 1,000 รายการ ตัวอย่างเช่นฉันเคยเป็นเจ้าของ kzpg.com Google ที่ตอนนี้และคุณจะเห็นเพียงไม่กี่ครั้ง มันเป็นเอกลักษณ์และหาได้ง่ายมาก

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