Czy „innego” należy używać w sytuacjach, w których przepływ sterowania czyni go zbędnym?

Czasami natrafiam na kod podobny do poniższego przykładu (to, co dokładnie robi ta funkcja, jest poza zakresem tego pytania):

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

Jak widać, if, else ifi elseoświadczenia są używane w połączeniu z returnoświadczeniem. Dla zwykłego obserwatora wydaje się to dość intuicyjne, ale myślę, że bardziej eleganckie (z perspektywy programisty) byłoby upuszczenie else-s i uproszczenie kodu w następujący sposób:

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

Ma to sens, ponieważ wszystko, co następuje po returninstrukcji (w tym samym zakresie), nigdy nie zostanie wykonane, dzięki czemu powyższy kod będzie semantycznie równy pierwszemu przykładowi.

Który z powyższych elementów bardziej odpowiada dobrym praktykom kodowania? Czy są jakieś wady obu metod w zakresie czytelności kodu?

Edycja: W tym pytaniu podano jako odniesienie duplikat . Uważam, że moje pytanie dotyczy innego tematu, ponieważ nie pytam o unikanie duplikatów stwierdzeń przedstawionych w drugim pytaniu. Oba pytania mają na celu ograniczenie liczby powtórzeń, choć w nieco inny sposób.

Podoba mi się ten bez elsei oto dlaczego:

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

Ponieważ zrobienie tego nie zepsuło niczego, czego nie powinno było.

Nienawiść współzależności we wszystkich jej formach (w tym nazywanie funkcji check2()). Izoluj wszystko, co można odizolować. Czasami potrzebujesz, elseale nie widzę tego tutaj.

Myślę, że to zależy od semantyki kodu. Jeśli twoje trzy przypadki są od siebie zależne, wyraźnie to zaznacz. Zwiększa to czytelność kodu i ułatwia zrozumienie dla każdego innego. Przykład:

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

Tutaj wyraźnie zależysz od wartości xwe wszystkich trzech przypadkach. Jeśli pominąłbyś ostatni else, byłoby to mniej jasne.

Jeśli twoje sprawy nie są bezpośrednio od siebie zależne, pomiń to:

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

Trudno to pokazać w prostym przykładzie bez kontekstu, ale mam nadzieję, że rozumiesz.

Wolę drugą opcję (oddzielny ifsbez else ifi na początku return) ale to jest tak długo, jak bloki kodu są krótkie .

Jeśli bloki kodu są długie, lepiej użyć else if, ponieważ w przeciwnym razie nie miałbyś jasnego zrozumienia kilku punktów wyjścia, które ma kod.

Na przykład:

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

W takim przypadku lepiej jest użyć else if, przechowywać kod powrotu w zmiennej i mieć tylko jedno zdanie zwrotne na końcu.

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

Ale ponieważ należy dążyć do tego, aby funkcje były krótkie, powiedziałbym, aby były krótkie i wychodziły wcześniej niż w pierwszym fragmencie kodu.

Używam obu w różnych okolicznościach. Podczas sprawdzania poprawności pomijam pozostałe. W przepływie kontrolnym używam innego.

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

Pierwszy przypadek brzmi bardziej tak, jakbyś najpierw sprawdzał wszystkie wymagania wstępne, usuwając je z drogi, a następnie przechodząc do właściwego kodu, który chcesz uruchomić. W związku z tym soczysty kod, który naprawdę chcesz uruchomić, należy bezpośrednio do zakresu funkcji; na tym właśnie polega ta funkcja.
Drugi przypadek brzmi bardziej tak, jakby obie ścieżki były poprawnymi kodami do uruchomienia, które są tak samo istotne dla funkcji, jak inne na podstawie pewnych warunków. Jako takie należą one do siebie w podobnych poziomach zakresu.

Jedyną sytuacją, jaką kiedykolwiek widziałem, to naprawdę ważne, jest taki kod:

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

Jest tu oczywiście coś nie tak. Problem polega na tym, że nie jest jasne, czy returnnależy je dodać, czy Arrays.asListusunąć. Nie można tego naprawić bez głębszej kontroli powiązanych metod. Możesz uniknąć tej dwuznaczności, zawsze stosując w pełni wyczerpujące bloki if-else. To:

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

nie będzie się kompilował (w językach sprawdzanych statycznie), chyba że w pierwszej kolejności dodasz wyraźny zwrot if.

Niektóre języki nie pozwalają nawet na pierwszy styl. Staram się używać go tylko w ściśle imperatywnym kontekście lub jako warunek wstępny w długich metodach:

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

Trzy wyjścia z takiej funkcji są bardzo mylące, jeśli próbujesz postępować zgodnie z kodem i źle postępować.

Jeśli masz pojedynczy punkt wyjścia dla tej funkcji, pozostałe są wymagane.

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

W rzeczywistości idziemy jeszcze dalej.

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

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

return result;

Wystarczająco słuszne, możesz argumentować za jednym wczesnym zwrotem przy sprawdzaniu poprawności danych wejściowych. Po prostu unikaj zawijania całej masy, jeśli logika w if.

Wolę pominąć zbędną instrukcję else. Ilekroć to widzę (podczas przeglądania kodu lub refaktoryzacji), zastanawiam się, czy autor zrozumiał przepływ sterowania i czy w kodzie może być błąd.

Jeśli autor uważa, że ​​instrukcja else jest konieczna, a tym samym nie rozumie konsekwencji instrukcji return dla przepływu kontrolnego, to z pewnością taki brak zrozumienia jest głównym źródłem błędów, w tej funkcji i ogólnie.