Clean Code - ฉันควรเปลี่ยน 1 ตัวอักษรเป็นค่าคงที่หรือไม่

เพื่อหลีกเลี่ยงตัวเลขเวทย์มนตร์เรามักได้ยินว่าเราควรให้ชื่อที่มีความหมายตามตัวอักษร เช่น:

//THIS CODE COMES FROM THE CLEAN CODE BOOK
for (int j = 0; j < 34; j++) {
    s += (t[j] * 4) / 5;
}

-------------------- Change to --------------------

int realDaysPerIdealDay = 4;
const int WORK_DAYS_PER_WEEK = 5;
int sum = 0;
for (int j = 0; j < NUMBER_OF_TASKS; j++) {
    int realTaskDays = taskEstimate[j] * realDaysPerIdealDay;
    int realTaskWeeks = (realdays / WORK_DAYS_PER_WEEK);
    sum += realTaskWeeks;
}

ฉันมีวิธีการหลอกตาแบบนี้:

อธิบาย: ฉันคิดว่าฉันมีรายชื่อคนที่จะให้บริการและโดยค่าเริ่มต้นเราใช้จ่าย $ 5 เพื่อซื้ออาหารเท่านั้น แต่เมื่อเรามีมากกว่าหนึ่งคนเราต้องซื้อน้ำและอาหารเราต้องใช้เงินมากขึ้นอาจจะ $ 6 ฉันจะเปลี่ยนรหัสของฉันโปรดมุ่งเน้นไปที่ 1 ตัวอักษรคำถามของฉันเกี่ยวกับมัน

public int getMoneyByPersons(){
    if(persons.size() == 1){ 
        // TODO - return money for one person
    } else {
        // TODO - calculate and return money for people.
    }

}

เมื่อฉันขอให้เพื่อนของฉันตรวจสอบโค้ดของฉันมีคนบอกว่าให้ชื่อสำหรับค่า 1 จะให้โค้ดที่สะอาดกว่าและอีกคนบอกว่าเราไม่ต้องการชื่อคงที่ที่นี่เพราะค่านั้นมีความหมายโดยตัวมันเอง

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

ไม่ในตัวอย่างนั้น 1 มีความหมายอย่างสมบูรณ์

อย่างไรก็ตามถ้า person.size () เป็นศูนย์จะเป็นอย่างไร ดูเหมือนว่าแปลกที่persons.getMoney()เหมาะกับ 0 และ 2 แต่ไม่ใช่สำหรับ 1

ทำไมรหัสส่วนหนึ่งถึงมีค่าตามตัวอักษรนั้น

• ค่านี้มีความหมายพิเศษในโดเมนปัญหาหรือไม่
• หรือค่านี้เป็นเพียงรายละเอียดการใช้งานซึ่งค่านั้นเป็นผลโดยตรงของรหัสที่อยู่รอบ ๆ ?

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

• ในตัวอย่างแรกของคุณ, ความหมายของตัวอักษรเช่น34, 4, 5ไม่ได้เป็นที่เห็นได้ชัดจากบริบท แต่ค่าเหล่านี้บางส่วนมีความหมายพิเศษในโดเมนปัญหาของคุณ ดังนั้นจึงเป็นการดีที่จะให้ชื่อแก่พวกเขา

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

ในความเป็นจริงการแนะนำชื่อสำหรับค่าที่ชัดเจนอาจไม่ดีเมื่อมันซ่อนค่าจริง

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

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

ไม่มีการ จำกัด ขนาดตัวอักษร“ ชัดเจน” เพราะขึ้นอยู่กับบริบทโดยสิ้นเชิง เช่นตัวอักษร1024อาจชัดเจนโดยสิ้นเชิงในบริบทของการคำนวณขนาดไฟล์หรือตัวอักษร31ในบริบทของฟังก์ชันแฮชหรือตัวอักษรpadding: 0.5emในบริบทของ CSS สไตล์ชีท

มีปัญหาหลายประการเกี่ยวกับโค้ดส่วนนี้ซึ่งสามารถตัดให้สั้นลงได้ดังนี้:

public List<Money> getMoneyByPersons() {
    return persons.size() == 1 ?
        moneyService.getMoneyIfHasOnePerson() :
        moneyService.getMoney(); 
}

1. มันไม่ชัดเจนว่าทำไมคนคนหนึ่งเป็นคดีพิเศษ ฉันคิดว่ามีกฎเกณฑ์ทางธุรกิจเฉพาะที่บอกว่าการรับเงินจากคนคนหนึ่งแตกต่างอย่างสิ้นเชิงจากการรับเงินจากคนหลายคน อย่างไรก็ตามฉันต้องไปดูทั้งสองข้างgetMoneyIfHasOnePersonและgetMoneyหวังว่าจะเข้าใจว่าทำไมถึงมีกรณีที่แตกต่างกัน

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

3. มีเหตุผลใดที่จะส่งคืนList<Money>คอลเลกชันมากกว่าหรือไม่?

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

ฉันจะแยกแยะบริบทเพื่อเลือกทางออกที่ดีที่สุดได้อย่างไร

คุณทำสิ่งที่ทำให้รหัสของคุณชัดเจนยิ่งขึ้น

ตัวอย่างที่ 1

ลองนึกภาพโค้ดต่อไปนี้:

if (sequence.size() == 0) {
    return null;
}

return this.processSequence(sequence);

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

if (sequence.isEmpty()) {
    return null;
}

return this.processSequence(sequence);

ที่นี่ไม่มีค่าคงที่อีกต่อไปและรหัสก็ชัดเจนยิ่งขึ้น

ตัวอย่างที่ 2

ใช้รหัสอื่น:

const result = Math.round(input * 1000) / 1000;

ไม่ต้องใช้เวลามากเกินไปในการทำความเข้าใจกับสิ่งที่ทำในภาษาเช่น JavaScript ซึ่งไม่มีround(value, precision)โอเวอร์โหลด

ทีนี้ถ้าคุณต้องการแนะนำค่าคงที่มันจะถูกเรียกว่าอย่างไร? Precisionคำที่ใกล้เคียงที่สุดคุณจะได้รับคือ ดังนั้น:

const precision = 1000;
const result = Math.round(input * precision) / precision;

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

const result = Math.round(input * 100) / 1000;

เปลี่ยนค่าในสถานที่หนึ่งและลืมที่จะทำในที่อื่น

ตัวอย่างที่ 3

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

รับรหัสต่อไปนี้:

class Point
{
    ...
    public void Reset()
    {
        x, y = (0, 0);
    }
}

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

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

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

ฉันแค่เสนอกลยุทธ์ตามปกติของตัวเอง แต่บางทีฉันก็จะได้เรียนรู้อะไรบางอย่างเช่นกัน

สิ่งที่ฉันคิดคือ

// Just an example name  
function normalize_task_value(task) {  
    return (task * 4) / 5;  // or to `return (task * 4) / NUMBER_OF_TASKS` but it really matters what logic you want to convey and there are reasons to many ways to make this logical. A comment would be the greatest improvement

}  

// Is it possible to just use tasks.length or something like that?  
// this NUMBER_OF_TASKS is the only one thats actually tricky to   
// understand right now how it plays its role.  

function normalize_all_task_values(tasks, accumulator) {  
    for (int i = 0; i < NUMBER_OF_TASKS; i++) {  
        accumulator += normalize_task_value(tasks[i]);
    }
}  

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

เลข 1 นั่นอาจเป็นตัวเลขที่ต่างออกไปได้ไหม มันอาจเป็น 2 หรือ 3 หรือมีเหตุผลเชิงตรรกะว่าทำไมมันต้องเป็น 1? หากต้องเป็น 1 การใช้ 1 จะใช้ได้ มิฉะนั้นคุณสามารถกำหนดค่าคงที่ อย่าเรียกว่าค่าคงที่ ONE (ฉันได้เห็นสิ่งที่ทำ)

60 วินาทีในหนึ่งนาที - คุณต้องการค่าคงที่หรือไม่? มันคือ 60 วินาทีไม่ใช่ 50 หรือ 70 และทุกคนก็รู้ เพื่อให้สามารถอยู่เป็นจำนวน

พิมพ์ 60 รายการต่อหน้า - จำนวนนั้นอาจเป็น 59 หรือ 55 หรือ 70 จริง ๆ แล้วถ้าคุณเปลี่ยนขนาดตัวอักษรอาจกลายเป็น 55 หรือ 70 ดังนั้นค่าคงที่ที่มีความหมายจะถูกถามมากขึ้น

นอกจากนี้ยังเป็นเรื่องที่ความหมายชัดเจนแค่ไหน หากคุณเขียน "นาที = วินาที / 60" นั่นก็ชัดเจน หากคุณเขียน "x = y / 60" นั่นไม่ชัดเจน ต้องมีบางชื่อที่มีความหมายอยู่ที่ไหนสักแห่ง

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

ฉันเห็นโค้ดในจำนวนที่พอใช้เช่นใน (แก้ไข) OP ในการดึง DB แบบสอบถามส่งคืนรายการ แต่กฎทางธุรกิจบอกว่าสามารถมีได้เพียงองค์ประกอบเดียวเท่านั้น และแน่นอนว่ามีบางสิ่งเปลี่ยนไปสำหรับ 'แค่กรณีนี้' เป็นรายการที่มีมากกว่าหนึ่งรายการ (ใช่ฉันพูดจำนวนครั้งพอใช้เกือบจะเหมือนพวกเขา ... nm)

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

public int getMoneyByPersons(){
  if(isSingleDepartmentHead()){ 
    // TODO - return money for one person
  } else {
    // TODO - calculate and return money for people.
  }
}

public boolean isSingleDepartmentHead() {
   return persons.size() == 1;
}