ฟังก์ชั่นหนึ่งบรรทัดที่เรียกว่าครั้งเดียวเท่านั้น

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

มันสามารถทำการสืบค้นตรวจสอบค่าบางอย่างทำบางสิ่งที่เกี่ยวข้องกับ regex ... อะไรที่คลุมเครือหรือ "แฮ็ค"

เหตุผลเบื้องหลังสิ่งนี้คือการหลีกเลี่ยงการประเมินที่อ่านยาก:

if (getCondition()) {
    // do stuff
}

ซึ่งgetCondition()เป็นฟังก์ชั่นหนึ่งบรรทัด

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

ขึ้นอยู่กับว่าหนึ่งบรรทัด หากบรรทัดสามารถอ่านได้และรัดกุมด้วยตัวเองฟังก์ชันอาจไม่จำเป็น ตัวอย่างง่าย ๆ :

void printNewLine() {
  System.out.println();
}

OTOH ถ้าฟังก์ชั่นให้ชื่อที่ดีกับบรรทัดของรหัสที่มีเช่นการแสดงออกที่ซับซ้อนและยากที่จะอ่านมันเป็นธรรมที่สมบูรณ์แบบ (สำหรับฉัน) ตัวอย่างที่คาดไว้ (แบ่งออกเป็นหลายบรรทัดเพื่อให้สามารถอ่านได้ที่นี่):

boolean isTaxPayerEligibleForTaxRefund() {
  return taxPayer.isFemale() 
        && (taxPayer.getNumberOfChildren() > 2 
        || (taxPayer.getAge() > 50 && taxPayer.getEmployer().isNonProfit()));
}

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

startIgnition();
petrolFlag |= 0x006A;
engageChoke();

ในกรณีนี้จะเป็นการดีกว่าที่จะย้ายเส้นกลางไปยังฟังก์ชั่นที่ตั้งชื่อได้ดี

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

bool someConditionSatisfied = [complex expression];

สิ่งนี้จะให้คำแนะนำแก่ผู้อ่านโค้ดและบันทึกจากการแนะนำฟังก์ชั่นใหม่

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

ทำตามตัวอย่างของปีเตอร์ถ้าเป็นเช่นนี้

boolean isTaxPayerEligibleForTaxRefund() {
  return taxPayer.isFemale() 
        && (taxPayer.getNumberOfChildren() > 2 
        || (taxPayer.getAge() > 50 && taxPayer.getEmployer().isNonProfit()));
}

กลายเป็นสิ่งนี้

boolean isTaxPayerEligibleForTaxRefund() {
  return taxPayer.isMutant() 
        && (taxPayer.getNumberOfThumbs() > 2 
        || (taxPayer.getAge() > 123 && taxPayer.getEmployer().isXMan()));
}

คุณทำการแก้ไขเพียงครั้งเดียวและได้รับการปรับปรุงในระดับสากล การบำรุงรักษาอย่างชาญฉลาดนี่เป็นข้อดี

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

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

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

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

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

ฉันได้ทำสิ่งที่แน่นอนเมื่อเร็ว ๆ นี้ในแอปพลิเคชันที่ฉันได้รับการ refactoring เพื่อให้ความหมายที่แท้จริงของความคิดเห็นรหัส sans:

protected void PaymentButton_Click(object sender, EventArgs e)
    Func<bool> HaveError = () => lblCreditCardError.Text == string.Empty && lblDisclaimer.Text == string.Empty;

    CheckInputs();

    if(HaveError())
        return;

    ...
}

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

แล้วมีจำนวนมากของคำตอบที่ดี แต่มีกรณีพิเศษมูลค่าการกล่าวขวัญ

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

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

def sophisticatedHello():
    # todo set up
    say("hello")
    # todo tear down

สามารถเปลี่ยนเป็นสิ่งนี้ได้เช่นกัน

def sophisticatedHello():
    setUp()
    say("hello")
    tearDown()

¹⁾คุณควรแน่ใจเกี่ยวกับเรื่องนี้จริงๆ (ดูหลักการYAGNI )

หากภาษารองรับฉันมักจะใช้ฟังก์ชั่นที่ไม่ระบุชื่อเพื่อทำสิ่งนี้ให้สำเร็จ

someCondition = lambda p: True if [complicated expression involving p] else False
#I explicitly write the function with a ternary to make it clear this is a a predicate
if (someCondition(p)):
    #do stuff...

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

มันไม่จำเป็นต้องทำหน้าที่ของกริยาเท่านั้น ฉันชอบที่จะห่อหุ้มแผ่นบอยเลอร์ซ้ำ ๆ ในฟังก์ชั่นขนาดเล็กเช่นนี้เช่นกัน (มันทำงานได้ดีเป็นพิเศษสำหรับการสร้างรายการไพ ธ อนโดยไม่ทำให้ไวยากรณ์ของวงเล็บเหลี่ยมยุ่งเหยิง) ตัวอย่างเช่นตัวอย่าง oversimplified ต่อไปนี้เมื่อทำงานกับ PIL ใน python

#goal - I have a list of PIL Image objects and I want them all as grayscale (uint8) numpy arrays
im_2_arr = lambda im: array(im.convert('L')) 
arr_list = [im_2_arr(image) for image in image_list]