Haruskah "lain" digunakan dalam situasi di mana aliran kontrol menjadikannya berlebihan?

Saya terkadang menemukan kode yang mirip dengan contoh berikut (apa fungsi ini tidak persis di luar lingkup pertanyaan ini):

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

Seperti yang Anda lihat, if, else ifdan elsepernyataan yang digunakan dalam hubungannya dengan returnpernyataan. Ini tampaknya cukup intuitif untuk pengamat biasa, tapi saya pikir akan lebih elegan (dari perspektif pengembang perangkat lunak) untuk menghapus else-s dan menyederhanakan kode seperti ini:

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

Ini masuk akal, karena segala sesuatu yang mengikuti returnpernyataan (dalam lingkup yang sama) tidak akan pernah dieksekusi, membuat kode di atas secara semantik sama dengan contoh pertama.

Manakah di atas yang lebih cocok dengan praktik pengkodean yang baik? Apakah ada kekurangan pada kedua metode sehubungan dengan keterbacaan kode?

Sunting: Saran rangkap telah dibuat dengan pertanyaan ini disediakan sebagai referensi. Saya percaya pertanyaan saya menyentuh topik yang berbeda, karena saya tidak bertanya tentang menghindari pernyataan rangkap seperti yang disajikan dalam pertanyaan lain. Kedua pertanyaan berusaha mengurangi pengulangan, meskipun dengan cara yang sedikit berbeda.

Saya suka yang tanpa elsedan inilah alasannya:

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

Karena melakukan itu tidak merusak apa pun yang tidak seharusnya.

Benci saling ketergantungan dalam semua bentuk itu (termasuk penamaan fungsi check2()). Isolasi semua yang bisa diisolasi. Terkadang Anda membutuhkan elsetetapi saya tidak melihatnya di sini.

Saya pikir itu tergantung pada semantik kode. Jika ketiga kasus Anda saling bergantung, nyatakan secara eksplisit. Ini meningkatkan keterbacaan kode dan membuatnya lebih mudah dipahami oleh orang lain. Contoh:

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

Di sini Anda jelas tergantung pada nilai xdalam ketiga kasus. Jika Anda menghilangkan yang terakhir else, ini akan menjadi kurang jelas.

Jika kasing Anda tidak saling tergantung satu sama lain, abaikan saja:

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

Sulit untuk menunjukkan ini dalam contoh sederhana tanpa konteks, tetapi saya harap Anda mengerti maksud saya.

Saya lebih suka pilihan kedua (terpisah ifstanpa else ifdan awal return) TAPI yang selama blok kode pendek .

Jika blok kode panjang, lebih baik menggunakan else if, karena selain itu Anda tidak akan memiliki pemahaman yang jelas tentang beberapa titik keluar kode.

Sebagai contoh:

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;
}

Dalam hal ini, lebih baik digunakan else if, simpan kode kembali dalam variabel dan hanya memiliki satu kalimat kembali di akhir.

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;
}

Tetapi sebagai salah satu harus berusaha untuk fungsi menjadi pendek, saya akan mengatakan tetap pendek dan keluar lebih awal seperti dalam cuplikan kode pertama Anda.

Saya menggunakan keduanya dalam keadaan yang berbeda. Dalam pemeriksaan validasi, saya menghilangkan yang lain. Dalam aliran kontrol, saya menggunakan yang lain.

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);
  }
}

Kasing pertama berbunyi lebih seperti Anda memeriksa semua prasyarat terlebih dahulu, menyingkirkan semua itu, lalu maju ke kode aktual yang ingin Anda jalankan. Dengan demikian, kode berair yang benar-benar ingin Anda jalankan termasuk dalam ruang lingkup fungsi secara langsung; itulah fungsi sebenarnya.
Kasus kedua berbunyi lebih seperti kedua jalur adalah kode yang valid untuk dijalankan yang sama relevan dengan fungsi seperti yang lain berdasarkan beberapa kondisi. Dengan demikian, mereka termasuk dalam tingkat cakupan yang sama satu sama lain.

Satu-satunya situasi yang pernah saya lihat benar-benar penting adalah kode seperti ini:

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();
}

Jelas ada sesuatu yang salah di sini. Masalahnya adalah, tidak jelas apakah returnharus ditambahkan atau Arrays.asListdihapus. Anda tidak dapat memperbaikinya tanpa pemeriksaan yang lebih dalam terhadap metode terkait. Anda dapat menghindari ambiguitas ini dengan selalu menggunakan blok if-else yang lengkap. Ini:

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();
    }
}

tidak akan dikompilasi (dalam bahasa yang dicentang secara statis) kecuali Anda menambahkan pengembalian eksplisit terlebih dahulu if.

Beberapa bahasa bahkan tidak mengizinkan gaya pertama. Saya mencoba menggunakannya hanya dalam konteks yang sangat penting atau untuk prasyarat dalam metode panjang:

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

Memiliki tiga keluar dari fungsi seperti itu benar-benar membingungkan jika Anda mencoba mengikuti kode dan praktik yang buruk.

Jika Anda memiliki satu titik keluar untuk fungsi tersebut maka elemen yang diperlukan.

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

Bahkan mari kita melangkah lebih jauh.

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

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

return result;

Cukup adil Anda bisa berdebat untuk pengembalian awal input validasi tunggal. Hanya menghindari membungkus keseluruhan massal jika logika Anda dalam sebuah if.

Saya lebih suka menghilangkan pernyataan redundant else. Setiap kali saya melihatnya (dalam review kode atau refactoring) saya bertanya-tanya apakah penulis memahami aliran kontrol dan bahwa mungkin ada bug dalam kode.

Jika penulis percaya pernyataan lain diperlukan dan dengan demikian tidak memahami implikasi aliran kontrol dari pernyataan kembali tentu saja kurangnya pemahaman adalah sumber utama bug, dalam fungsi ini, dan secara umum.