ฉันควรกลับจากฟังก์ชันก่อนหน้าหรือใช้คำสั่ง if [ปิด]

ฉันมักจะเขียนฟังก์ชันประเภทนี้ทั้งสองรูปแบบและฉันสงสัยว่ารูปแบบใดรูปแบบหนึ่งที่ต้องการมากกว่าอีกรูปแบบหนึ่งและทำไม

public void SomeFunction(bool someCondition)
{
    if (someCondition)
    {
        // Do Something
    }
}

หรือ

public void SomeFunction(bool someCondition)
{
    if (!someCondition)
        return;

    // Do Something
}

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

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

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

public int SomeFunction(bool cond1, string name, int value, AuthInfo perms)
{
    int retval = SUCCESS;
    if (someCondition)
    {
        if (name != null && name != "")
        {
            if (value != 0)
            {
                if (perms.allow(name)
                {
                    // Do Something
                }
                else
                {
                    reval = PERM_DENY;
                }
            }
            else
            {
                retval = BAD_VALUE;
            }
        }
        else
        {
            retval = BAD_NAME;
        }
    }
    else
    {
        retval = BAD_COND;
    }
    return retval;
}

สามารถอ่านได้มากกว่า

public int SomeFunction(bool cond1, string name, int value, AuthInfo perms)
{
    if (!someCondition)
        return BAD_COND;

    if (name == null || name == "")
        return BAD_NAME;

    if (value == 0)
        return BAD_VALUE;

    if (!perms.allow(name))
        return PERM_DENY;

    // Do something
    return SUCCESS;
}

ฉันยอมรับอย่างเต็มที่ว่าฉันไม่เคยเข้าใจถึงข้อดีของจุดออกเดียว

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

ที่กล่าวว่าแม้ว่าหากฟังก์ชั่นต้องการข้อมูลบางอย่างเมื่อมีการเรียกฉันมักจะโยนข้อยกเว้น (ดูตัวอย่าง) เมื่อเทียบกับที่เพิ่งกลับมา

public int myFunction(string parameterOne, string parameterTwo) {
  // Can't work without a value
  if (string.IsNullOrEmpty(parameterOne)) {
    throw new ArgumentNullException("parameterOne");
  } 
  if (string.IsNullOrEmpty(parameterTwo)) {
    throw new ArgumentNullException("parameterTwo");
  }

  // ...      
  // Do some work
  // ...

  return value;
}

ฉันชอบผลตอบแทนเร็ว

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

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

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

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

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

C # ฉันไม่สามารถตอบได้อย่างแน่นอน

D-language ให้การปกป้องขอบเขตการออกในตัวที่เหมาะสมและพร้อมสำหรับการออกก่อนกำหนดดังนั้นจึงไม่ควรแสดงปัญหาอื่นนอกเหนือจากรูปแบบ

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

ผลตอบแทนก่อนการชนะ พวกเขาสามารถดูน่าเกลียด แต่น่าเกลียดน้อยกว่าifห่อใหญ่โดยเฉพาะอย่างยิ่งถ้ามีหลายเงื่อนไขให้ตรวจสอบ

ฉันใช้ทั้งสองอย่าง

หากDoSomethingเป็นโค้ด 3-5 บรรทัดโค้ดจะดูสวยงามโดยใช้วิธีการจัดรูปแบบแรก

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

เหตุผลคลาสสิกสำหรับ single-entry-single-exit คือมิฉะนั้นความหมายที่เป็นทางการจะกลายเป็นสิ่งที่น่าเกลียดอย่างไม่น่าเชื่อ (เหตุผลเดียวกัน GOTO ถือว่าเป็นอันตราย)

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

โดยปกติฉันจะย่อเล็กสุดวิธีคืนต้น

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

มันขึ้นอยู่กับ.

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

ตั้งค่า Retval + ผลตอบแทนเดียวหากฟังก์ชั่นมีความซับซ้อนมากขึ้นและอาจมีจุดทางออกหลายจุดเป็นอย่างอื่น (ปัญหาการอ่านได้)

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

ใช้ถ้า

ในหนังสือของ Don Knuth เกี่ยวกับ GOTO's ฉันอ่านเขาให้เหตุผลว่าการมีสภาพที่เป็นไปได้มากที่สุดมาก่อนเสมอในประโยค if ภายใต้สมมติฐานที่ว่านี้ยังคงเป็นความคิดที่สมเหตุสมผล (และไม่ใช่หนึ่งในการพิจารณาที่บริสุทธิ์สำหรับความเร็วของยุคนั้น) ฉันจะบอกว่าผลตอบแทนในช่วงต้นนั้นไม่ใช่วิธีการเขียนโปรแกรมที่ดีโดยเฉพาะอย่างยิ่งเมื่อพิจารณาถึงความจริงที่ว่าพวกเขาใช้บ่อยกว่าที่ไม่ได้ใช้ในการจัดการข้อผิดพลาดเว้นแต่ว่าโค้ดของคุณมีแนวโน้มที่จะล้มเหลวมากกว่าไม่ล้มเหลว :-)

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

เฉพาะ Delphi ...

ฉันคิดว่านี่เป็นวิธีการเขียนโปรแกรมที่ดีสำหรับโปรแกรมเมอร์ Delphi แม้ว่าฉันจะไม่มีข้อพิสูจน์ใด ๆ Pre-D2009 เราไม่มีวิธีปรมาณูที่จะคืนค่าเรามีexit;และresult := foo;หรือเราอาจโยนข้อยกเว้น

หากคุณต้องเปลี่ยน

if (true) {
 return foo;
} 

สำหรับ

if true then 
begin
  result := foo; 
  exit; 
end;

คุณอาจเบื่อที่จะเห็นสิ่งนั้นที่อยู่เหนือสุดในทุกฟังก์ชั่นของคุณและชอบ

if false then 
begin
  result := bar;

   ... 
end
else
   result := foo;

และเพียงหลีกเลี่ยงexitทั้งหมด

ฉันเห็นด้วยกับข้อความต่อไปนี้:

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

ที่นำมาจากคำถามนี้ใน StackOverflow

ฉันใช้ผลตอบแทนในช่วงต้นเกือบจะทุกวันนี้ ฉันเขียนสิ่งนี้

self = [super init];

if (self != nil)
{
    // your code here
}

return self;

เช่น

self = [super init];
if (!self)
    return;

// your code here

return self;

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

ฉันต้องการเขียน:

if(someCondition)
{
    SomeFunction();
}

เช่นเดียวกับคุณฉันมักจะเขียนคนแรก แต่ชอบคนสุดท้าย ถ้าฉันมีการตรวจสอบซ้อนกันมากฉันมักจะ refactor วิธีที่สอง

ฉันไม่ชอบว่าการจัดการข้อผิดพลาดถูกย้ายออกไปจากเช็คอย่างไร

if not error A
  if not error B
    if not error C
      // do something
    else handle error C
  else handle error B
else handle error A

ฉันชอบสิ่งนี้:

if error A
  handle error A; return
if error B
  handle error B; return
if error C
  handle error C; return

// do something

เงื่อนไขด้านบนเรียกว่า "เงื่อนไข" โดยการใส่if(!precond) return;คุณจะเห็นรายการเงื่อนไขทั้งหมด

การใช้บล็อก "if-else" ขนาดใหญ่อาจเพิ่มค่าใช้จ่ายการเยื้อง

ฉันชอบที่จะรักษาถ้างบน้อย

ดังนั้นเลือกระหว่าง:

if condition:
   line1
   line2
    ...
   line-n

และ

if not condition: return

line1
line2
 ...
line-n

ฉันจะเลือกสิ่งที่คุณอธิบายว่าเป็น "ผลตอบแทนเร็ว"

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

ซ้อนกันถ้าและสำหรับและในขณะที่น่ากลัวหลีกเลี่ยงค่าใช้จ่ายทั้งหมด

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

ฉันฝึกปฏิบัติไม่สำเร็จในระดับฟังก์ชั่น มันทำให้รหัสสอดคล้องและสะอาด (สำหรับฉันและคนที่ฉันเคยทำงานด้วย) เพราะการที่ฉันกลับก่อนเสมอ

สำหรับเงื่อนไขที่มีการตรวจสอบบางส่วนคุณสามารถใช้แง่มุมต่างๆสำหรับการตรวจสอบเหล่านั้นหากคุณใช้ AOP