ควรใช้ "อย่างอื่น" ในสถานการณ์ที่การควบคุมการไหลทำให้ซ้ำซ้อนหรือไม่?

บางครั้งฉันสะดุดกับรหัสที่คล้ายกับตัวอย่างต่อไปนี้ (สิ่งที่ฟังก์ชั่นนี้ทำไม่ตรงกับขอบเขตของคำถามนี้):

function doSomething(value) {
  if (check1(value)) {
    return -1;
  }
  else if (check2(value)) {
    return value;
  }
  else {
    return false;
  }
}

ในขณะที่คุณสามารถดูif, else ifและelseงบที่ใช้ร่วมกับreturnคำสั่ง ดูเหมือนว่าจะใช้งานง่ายสำหรับผู้สังเกตการณ์ทั่วไป แต่ฉันคิดว่ามันจะดูสง่างามกว่า (จากมุมมองของนักพัฒนาซอฟต์แวร์) เพื่อวางelse-s และทำให้รหัสง่ายขึ้นดังนี้:

function doSomething(value) {
  if (check1(value)) {
    return -1;
  }
  if (check2(value)) {
    return value;
  }
  return false;
}

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

ข้อใดข้างต้นที่เหมาะกับวิธีการเข้ารหัสที่ดีมากกว่า มีข้อเสียเปรียบกับวิธีการอย่างใดอย่างหนึ่งเกี่ยวกับการอ่านรหัส?

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

ฉันชอบที่ไม่มีelseและนี่คือเหตุผล:

function doSomething(value) {
  //if (check1(value)) {
  //  return -1;
  //}
  if (check2(value)) {
    return value;
  }
  return false;
}

เพราะการทำเช่นนั้นไม่ได้ทำลายอะไรเลยไม่ควรทำ

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

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

if (x < 0) {
    return false;
} else if (x > 0) {
    return true;
} else {
    throw new IllegalArgumentException();
}

ที่นี่คุณชัดเจนขึ้นอยู่กับมูลค่าของxทั้งสามกรณี หากคุณไม่ใช้สิ่งelseนี้สิ่งนี้จะชัดเจนน้อยลง

หากกรณีของคุณไม่ได้ขึ้นอยู่กับแต่ละอื่น ๆ โดยตรงละเว้น:

if (x < 0) {
    return false;
}
if (y < 0) {
    return true;
}
return false;

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

ฉันชอบตัวเลือกที่สอง (แยกifsไม่มีelse ifและต้นreturn) แต่นั่นคือตราบใดที่บล็อกรหัสสั้น

หากการบล็อกโค้ดใช้เวลานานจะดีกว่าelse ifเพราะเหตุใดคุณจะไม่มีความเข้าใจที่ชัดเจนเกี่ยวกับการออกหลายจุดที่รหัสมี

ตัวอย่างเช่น:

function doSomething(value) {
  if (check1(value)) {
    // ...
    // imagine 200 lines of code
    // ...
    return -1;
  }
  if (check2(value)) {
    // ...
    // imagine 150 lines of code
    // ...
    return value;
  }
  return false;
}

ในกรณีนั้นควรใช้ให้ดีกว่าelse ifเก็บรหัสส่งคืนไว้ในตัวแปรและมีประโยคส่งคืนหนึ่งประโยคที่สิ้นสุด

function doSomething(value) {
  retVal=0;
  if (check1(value)) {
    // ...
    // imagine 200 lines of code
    // ...
    retVal=-1;
  } else if (check2(value)) {
    // ...
    // imagne 150 lines of code
    retVal=value;
  }
  return retVal;
}

แต่เป็นหนึ่งควรพยายามให้ฟังก์ชั่นจะสั้นฉันจะบอกว่ามันสั้นและออกก่อนในรหัสตัวอย่างแรกของคุณ

ฉันใช้ทั้งในสถานการณ์ที่แตกต่างกัน ในการตรวจสอบความถูกต้องฉันไม่ต้องทำอย่างอื่น ในโฟลว์การควบคุมฉันใช้อย่างอื่น

bool doWork(string name) {
  if(name.empty()) {
    return false;
  }

  //...do work
  return true;
}

VS

bool doWork(int value) {
  if(value % 2 == 0) {
    doWorkWithEvenNumber(value);
  }
  else {
    doWorkWithOddNumber(value);
  }
}

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

สถานการณ์เดียวที่ฉันเคยเห็นมันมีความสำคัญคือรหัสเช่นนี้:

List<?> toList() {
    if (left != null && right != null) {
        Arrays.asList(merge(left, right));
    }
    if (left != null) {
        return Arrays.asList(left);
    }
    if (right != null) {
        return Arrays.asList(right);
    }
    return Arrays.asList();
}

เห็นได้ชัดว่ามีบางอย่างผิดปกติ ปัญหาคือมันไม่ชัดเจนว่าreturnควรจะเพิ่มหรือArrays.asListลบออก คุณไม่สามารถแก้ไขได้หากไม่ตรวจสอบวิธีการที่เกี่ยวข้องให้ลึกซึ้งยิ่งขึ้น คุณสามารถหลีกเลี่ยงความคลุมเครือนี้ได้โดยการใช้บล็อก if-else แบบละเอียดถี่ถ้วน นี้:

List<?> toList() {
    if (left != null && right != null) {
        Arrays.asList(merge(left, right));
    } else if (left != null) {
        return Arrays.asList(left);
    } else if (right != null) {
        return Arrays.asList(right);
    } else {
        return Arrays.asList();
    }
}

จะไม่รวบรวม (ในภาษาการตรวจสอบแบบคงที่) ifจนกว่าคุณจะเพิ่มผลตอบแทนที่ชัดเจนในครั้งแรก

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

List<?> toList() {
    if (left == null || right == null) {
        throw new IllegalStateException()
    }
    // ...
    // long method
    // ...
}

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

หากคุณมีจุดออกเดียวสำหรับฟังก์ชั่นแล้วจำเป็นต้องใช้ elses

var result;
if(check1(value)
{
    result = -1;
}
else if(check2(value))
{
    result = value;
}
else 
{
    result = 0;
}
return result;

ในความเป็นจริงให้ไปไกลยิ่งขึ้น

var result = 0;
var c1 = check1(value);
var c2 = check2(value);

if(c1)
{
    result = -1;
}
else if(c2)
{
    result = value;
}

return result;

ยุติธรรมมากพอที่คุณจะโต้กลับสำหรับการตรวจสอบอินพุตล่วงหน้า เพียงหลีกเลี่ยงการห่อทั้งกลุ่มถ้าตรรกะของคุณอยู่ใน if

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

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