เป็นสไตล์ที่ดีที่จะกลับมาทับทิมอย่างชัดเจนหรือไม่?

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

มันเป็น "The Ruby Way" หรือไม่ที่จะพิมพ์ออกมาreturnในวิธีการอย่างชัดเจน? ฉันเคยเห็นมันเสร็จแล้วทั้งที่มีและไม่มี แต่มีวิธีที่ถูกต้องหรือไม่ อาจมีเวลาที่เหมาะสมในการทำหรือไม่? ตัวอย่างเช่น:

def some_func(arg1, arg2, etc)
  # Do some stuff...
  return value # <-- Is the 'return' needed here?
end

คำถามเก่า (และ "ตอบ") แต่ฉันจะโยนในสองเซ็นต์ของฉันเป็นคำตอบ

TL; DR - คุณไม่จำเป็นต้องทำ แต่มันสามารถทำให้โค้ดของคุณชัดเจนยิ่งขึ้นในบางกรณี

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

มันเป็นตัวอย่างที่วางแผนไว้ แต่ลองนึกภาพว่ามีฟังก์ชั่นเล็ก ๆ น้อย ๆ เช่นนี้ซึ่งบวกหนึ่งจำนวนที่ผ่านไปและกำหนดให้กับตัวแปรอินสแตนซ์

def plus_one_to_y(x)
    @y = x + 1
end

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

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

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
end

ตอนนี้ฟังก์ชั่นที่ถูกทำลายถ้ามีอะไรที่คาดว่าจะมีค่าที่ส่งกลับ หากไม่มีสิ่งใดคาดหวังว่าจะได้รับมูลค่าที่คืนมาก็ดี เห็นได้ชัดว่าหากมีการลดลงของ chain code สิ่งที่เรียกว่าคาดหวังว่าจะได้ค่าที่ส่งคืนกลับมาก็จะล้มเหลวเนื่องจากไม่ได้รับสิ่งที่คาดหวังกลับมา

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

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

ดังนั้นในกรณีของฟังก์ชั่นตัวอย่างเล็ก ๆ น้อย ๆ ของเราสมมติว่าเราต้องการให้มันคืนค่ามันจะถูกเขียนแบบนี้ ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
    return @y
end

และมันจะชัดเจนมากสำหรับโปรแกรมเมอร์ที่จะคืนค่าและยากกว่าสำหรับพวกเขาที่จะทำลายมันโดยไม่ทราบ

อีกทางเลือกหนึ่งสามารถเขียนเช่นนี้และออกจากงบกลับ ...

def plus_one_to_y(x)
    @y = x + 1
    puts "In plus_one_to_y"
    @y
end

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

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

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

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

ฉันใช้ความแตกต่างเดียวกันเมื่อเรียกเมธอด: เมธอดที่ใช้งานได้รับวงเล็บเมธอดโพรซีเดอร์ไม่ได้

และสุดท้าย แต่ไม่น้อยผมยังใช้ความแตกต่างที่มีบล็อก: บล็อกการทำงานได้รับเครื่องหมายปีกกาบล็อกขั้นตอน (บล็อคเช่นที่ว่า "ทำ" อะไรบางอย่าง) ได้รับ/doend

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

จริงๆแล้วสิ่งสำคัญคือการแยกแยะระหว่าง:

1. ฟังก์ชั่น - วิธีการดำเนินการสำหรับค่าตอบแทนของพวกเขา
2. ขั้นตอน - วิธีการดำเนินการสำหรับผลข้างเคียงของพวกเขา

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

ในการแก้ไขปัญหานี้ให้นำหนังสือของสกาล่าและแฮสเค็ลออกมาและให้กระบวนการของคุณกลับมาอย่างชัดเจนnil( Unitหรือ()ในภาษาอื่น ๆ )

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

เพื่อแยกความแตกต่างระหว่างฟังก์ชั่นและขั้นตอนเพิ่มเติม:

1. คัดลอกความคิดที่ดีของJörg W Mittag ในการเขียนบล็อกที่ใช้งานได้ด้วยเครื่องหมายปีกกาและบล็อกขั้นตอนด้วย do/end
2. เมื่อคุณเรียกใช้โพรซีเดอร์ให้ใช้()ในขณะที่เมื่อคุณเรียกใช้ฟังก์ชัน

โปรดทราบว่าJörg W Mittag จริงสนับสนุนวิธีอื่น ๆ - หลีกเลี่ยง()สำหรับขั้นตอน - แต่ที่ไม่แนะนำเพราะคุณต้องการด้านที่มีผลต่อการเรียกวิธีการที่จะแตกต่างอย่างชัดเจนจากตัวแปรโดยเฉพาะอย่างยิ่งเมื่อ arity เป็น 0 เห็นคู่มือสไตล์ Scala กับวิธีการภาวนาสำหรับ รายละเอียด

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

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

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

heuristic ทั่วไปสำหรับความยาวของเมธอด (ไม่รวม getters / setters) ใน java คือหน้าจอเดียว ในกรณีดังกล่าวคุณอาจไม่เห็นคำจำกัดความวิธีการและ / หรือลืมไปแล้วว่าคุณกลับมาจากที่ใด

บนมืออื่น ๆ ในทับทิมดีที่สุดคือการยึดติดกับวิธีการน้อยกว่า 10 เส้นยาว เมื่อพิจารณาแล้วจะมีใครสงสัยว่าทำไมเขาถึงต้องเขียนเพิ่มอีก ~ 10% งบเมื่อพวกเขามีนัยโดยนัย

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

ฉันเห็นด้วยกับเบ็นฮิวจ์และไม่เห็นด้วยกับทิมโฮลท์เพราะคำถามดังกล่าวระบุวิธีการที่ไพ ธ อนทำและถามว่ารูบี้มีมาตรฐานที่คล้ายคลึงกันหรือไม่

มันทำ

นี่เป็นคุณสมบัติที่เป็นที่รู้จักกันดีของภาษาที่ทุกคนคาดว่าจะทำการแก้ไขปัญหาในทับทิมควรได้รับการคาดหวังว่าจะรู้เกี่ยวกับมัน

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

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

def some_func_which_returns_a_list( x, y, z)
  return nil if failed_some_early_check


  # function code 

  @list     # returns the list
end