ชื่อเมธอด Java ยาวเกินไปเมื่อใด [ปิด]

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

ตัวอย่างคือ:

getNumberOfSkinCareEligibleItemsWithinTransaction

ชื่อใน Java หรือภาษาอื่น ๆ ยาวเกินไปเมื่อมีชื่อที่สั้นกว่าที่มีความหมายพอ ๆ กันกับพฤติกรรมของวิธีการ

เทคนิคบางอย่างสำหรับการลดความยาวของชื่อเมธอด:

1. หากโปรแกรมหรือคลาสหรือโมดูลของคุณเกี่ยวกับ 'รายการดูแลผิว' คุณสามารถทิ้งการดูแลผิว ตัวอย่างเช่นถ้าชั้นของคุณถูกเรียกSkinCareUtilsนั่นจะนำคุณมาgetNumberOfEligibleItemsWithinTransaction

2. คุณสามารถเปลี่ยนภายในไปใน ,getNumberOfEligibleItemsInTransaction

3. คุณสามารถเปลี่ยนการทำธุรกรรมที่จะ Tx getNumberOfEligibleItemsInTxซึ่งทำให้คุณได้รับ

4. หรือถ้าวิธีการยอมรับ param ประเภทTransactionคุณสามารถวาง InTx ทั้งหมด:getNumberOfEligibleItems

5. คุณเปลี่ยน numberOf โดยนับ: getEligibleItemsCount

ตอนนี้มันสมเหตุสมผลมาก และสั้นกว่า 60%

เพียงเพื่อการเปลี่ยนแปลงคำตอบที่ไม่ใช่อัตนัย: 65536 ตัวอักษร

A.java:1: การแทน UTF8 สำหรับสตริง "xxxxxxxxxxxxxxxxxxxxxx ... " ยาวเกินไปสำหรับพูลคงที่

;-)

ฉันเห็นด้วยกับทุกคน: ชื่อวิธีการไม่ควรยาวเกินไป ฉันต้องการเพิ่มข้อยกเว้นหนึ่งข้อแม้ว่า:

อย่างไรก็ตามชื่อของวิธีทดสอบ JUnit อาจมีความยาวและควรมีลักษณะคล้ายประโยค

ทำไม?

• เพราะพวกเขาไม่ได้เรียกในรหัสอื่น ๆ
• เพราะพวกมันถูกใช้เป็นชื่อทดสอบ
• เพราะพวกเขาสามารถเขียนเป็นประโยคอธิบายข้อกำหนด (ตัวอย่างเช่นการใช้AgileDox )

ตัวอย่าง:

    @Test
    public void testDialogClosesDownWhenTheRedButtonIsPressedTwice() {
        ...
    }

ดู " การออกแบบพฤติกรรมขับเคลื่อน " สำหรับข้อมูลเพิ่มเติมเกี่ยวกับแนวคิดนี้

บริบท "... InsideTransaction" ควรชัดเจน นั่นคือสิ่งที่เกี่ยวกับการวางแนววัตถุ

วิธีการเป็นส่วนหนึ่งของชั้นเรียน ถ้าคลาสไม่ได้แปลว่า "ธุรกรรม" - และถ้ามันไม่ช่วยให้คุณไม่ต้องพูดว่า "InsideTransaction" ตลอดเวลาแสดงว่าคุณมีปัญหา

ฉันมักจะใช้กฎไฮกุสำหรับชื่อ:

 Seven syllable class names 
 five for variables
 seven for method and other names

เหล่านี้เป็นกฎของหัวแม่มือสำหรับชื่อสูงสุด ฉันละเมิดสิ่งนี้เฉพาะเมื่อปรับปรุงความสามารถในการอ่าน recalculateMortgInterest (currentRate, quoteSet ... ) ดีกว่าการคำนวณ recalculateMortgInterestRate หรือ recalculateMortgInterestRateFromSet เนื่องจากความจริงที่ว่ามันเกี่ยวข้องกับอัตราและชุดของราคาที่ควรจะค่อนข้างชัดเจนจาก docs ฝังตัวเช่น javadoc หรือเทียบเท่า. NET

หมายเหตุ: ไม่ใช่ไฮกุจริง ๆ เพราะมันเป็น 7-5-7 มากกว่า 5-7-5 แต่ฉันก็ยังชอบเรียกมันว่าไฮกุ

Java มีวัฒนธรรมของการส่งเสริมชื่อยาวบางทีอาจเป็นเพราะ IDEs มาพร้อมกับการเติมข้อความอัตโนมัติที่ดี

ไซต์นี้บอกว่าชื่อคลาสที่ยาวที่สุดใน JRE นั้นInternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedStateยาว 92 ตัวอักษร

สำหรับชื่อเมธอดที่ยาวที่สุดฉันได้พบอันนี้supportsDataDefinitionAndDataManipulationTransactionsซึ่งก็คือ 52 ตัวอักษร

อย่าใช้คำยาว ๆ เมื่อคำสั่งจิ๋วจะทำ

ฉันไม่คิดว่าวิทยานิพนธ์ของคุณ "ความยาวของชื่อวิธีเป็นสัดส่วนกับความยาวของวิธีการ" ถือน้ำจริงๆ

นำตัวอย่างที่คุณให้: "getNumberOfSkinCareEligibleItemsWithinTransaction" ฟังดูเหมือนว่าฉันจะทำสิ่งเดียว: นับจำนวนรายการในธุรกรรมที่ตกอยู่ในหมวดหมู่ที่แน่นอน แน่นอนว่าฉันไม่สามารถตัดสินได้โดยไม่เห็นรหัสที่แท้จริงสำหรับวิธีการ แต่ดูเหมือนว่าเป็นวิธีที่ดีสำหรับฉัน

ในทางกลับกันฉันได้เห็นวิธีการมากมายที่มีชื่อที่สั้นและกระชับซึ่งทำให้วิธีการทำงานมากมายเช่น "processSale" หรือ "doStuff" ที่เป็นที่นิยม

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

สองฉันคิดว่ามันไม่สมจริงอย่างที่คิดว่าชื่อของความยาวที่สามารถจัดการได้จะบอกคุณว่าฟังก์ชั่นนี้ทำอะไรได้บ้าง แต่เป็นกรณีที่น่ารำคาญที่สุด เป้าหมายที่สมจริงคือสร้างชื่อที่ให้เบาะแสผู้อ่านและสามารถจดจำได้ในภายหลัง เช่นถ้าฉันพยายามหารหัสที่คำนวณว่าปฏิสสารที่เราต้องใช้เพื่อให้ได้ความเร็ววาร์ปถ้าฉันดูชื่อฟังก์ชั่นและดู "calibrateTransporter", "firePhasers" และ "calcAntimatterBurn" มันค่อนข้างชัดเจนว่า สองอันแรกไม่ใช่มัน แต่อันที่สามอาจเป็น ถ้าฉันตรวจสอบและพบว่าเป็นสิ่งที่ฉันกำลังมองหามันจะเป็นการง่ายที่จะจำได้ว่าเมื่อฉันกลับมาพรุ่งนี้เพื่อแก้ไขปัญหานี้อีก นั่นดีพอ

ชื่อยาวสามชื่อที่คล้ายกันทำให้สับสนมากกว่าชื่อสั้น ๆ หากฉันมีฟังก์ชั่นสองอย่างที่เรียกว่า "calcSalesmanPay" และ "calcGeekPay" ฉันสามารถคาดเดาได้อย่างรวดเร็วว่าเป็นแบบไหน แต่ถ้าพวกเขาถูกเรียกว่า "calculMonthlyCheckAmountForSalesmanForExportToAccountingSystemAndReconciliation" และ "calculMonthlyCheckAmountForProgrammersForExportToAccountingSystemAndReconciliation" (ฉันต้องศึกษาชื่อเพื่อดูว่าตัวไหนเป็นแบบไหน ข้อมูลเพิ่มเติมในชื่อนั้นอาจมีผลในกรณีดังกล่าว เปลี่ยนความคิดครึ่งวินาทีเป็นความคิด 30 วินาที

ออกแบบอินเทอร์เฟซของคุณในแบบที่คุณต้องการและทำการจับคู่การใช้งาน

ตัวอย่างเช่นบางทีฉันอาจจะเขียนว่าเป็น

getTransaction().getItems(SKIN_CARE).getEligible().size()

หรือกับสตรีม Java 8:

getTransaction().getItems().stream()
    .filter(item -> item.getType() == SKIN_CARE)
    .filter(item -> item.isEligible())
    .count();

กฎของฉันมีดังนี้: หากชื่อยาวจนต้องปรากฏในบรรทัดของมันเองมันก็ยาวเกินไป (ในทางปฏิบัติหมายความว่าฉันไม่ค่อยมีอักขระเกิน 20 ตัว)

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

เพิ่มความคิดเห็นที่มีการประกาศเมธอด / คลาสและให้ IDE นำคุณไปที่นั่นหากคุณต้องการคำอธิบายแบบยาวเกี่ยวกับสิ่งที่มันมีไว้

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

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

"The man who is going to maintain your code is a phyco who knows where you stay"

ชื่อวิธีนั้นยาวเกินไปอย่างแน่นอน ใจของฉันมีแนวโน้มที่จะเร่าร้อนเมื่อฉันอ่านชื่อวิธีการขนาดดังกล่าว มันเหมือนกับการอ่านประโยคที่ไม่มีช่องว่าง

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

"getNumberOfSkinCareEligibleItemsWithinTransaction" อาจกลายเป็น:

com.mycompany.app.product.SkinCareQuery.getNumEligibleItems ();

จากนั้นเมื่อใช้งานวิธีการอาจมีลักษณะ "query.getNumEligibleItems ()"

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

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

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

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

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

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

เช่นเดียวกับภาษาอื่น ๆ : เมื่อมันไม่ได้อธิบายการกระทำเดียวฟังก์ชั่นจะดำเนินการอีกต่อไป

ฉันว่าจะใช้คำตอบที่ดีและมีเหตุผล

อธิบายอย่างชัดเจนชัดเจนและอ่านง่ายว่าวิธีการนี้ทำอะไร

ถ้าชื่อเมธอดยาวเกินไปให้ทำการรีแฟคเตอร์ให้น้อยลง

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

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

มันยาวเกินไปเมื่ออธิบายด้วยวาจาอย่างเกินไป

ตัวอย่างเช่นชื่อเหล่านี้เทียบเท่ากับหน้าที่

ใน Java: java.sql.SQLIntegrityConstraintViolationException

ใน Python / Django: django.db.IntegrityError

ถามตัวคุณเองในแพ็คเกจ SQL / db คุณจะพบข้อผิดพลาดด้านความสมบูรณ์อีกจำนวนเท่าใด ;) db.IntegrityErrorก็เพียงพอแล้ว

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

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

ชื่อยาวเกินไปถ้ามัน:

• ใช้เวลาอ่านมากกว่า 1 วินาที
• ใช้ RAM มากกว่าที่คุณจัดสรรให้กับ JVM ของคุณ
• มันเป็นชื่อที่ไร้สาระ
• หากชื่อที่สั้นลงทำให้รู้สึกที่สมบูรณ์แบบ
• ถ้ามันล้อมรอบใน IDE ของคุณ

โดยสุจริตชื่อจะต้องสื่อถึงจุดประสงค์ของมันต่อนักพัฒนาที่จะใช้มันเป็นวิธีการสาธารณะ API หรือต้องรักษารหัสเมื่อคุณออกจาก แค่จำ KISS (ทำให้มันโง่ง่าย ๆ )