Sollte „else“ in Situationen verwendet werden, in denen der Kontrollfluss ihn überflüssig macht?

Manchmal stoße ich auf Code, der dem folgenden Beispiel ähnelt (was diese Funktion genau tut, ist nicht Gegenstand dieser Frage):

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

Wie Sie sehen, ifwerden else ifund else-Anweisungen in Verbindung mit der returnAnweisung verwendet. Für einen zufälligen Betrachter scheint dies ziemlich intuitiv zu sein, aber ich denke, es wäre eleganter (aus der Sicht eines Softwareentwicklers), das else-s wegzulassen und den Code wie folgt zu vereinfachen:

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

Dies ist sinnvoll, da alles, was auf eine returnAnweisung folgt (im selben Bereich), niemals ausgeführt wird, sodass der obige Code semantisch dem ersten Beispiel entspricht.

Welche der oben genannten Optionen passt besser zu den bewährten Codierungsmethoden? Gibt es bei beiden Methoden Nachteile hinsichtlich der Lesbarkeit des Codes?

Bearbeiten: Es wurde ein doppelter Vorschlag mit dieser Frage als Referenz gemacht. Ich glaube, meine Frage berührt ein anderes Thema, da ich nicht nach doppelten Aussagen frage, wie sie in der anderen Frage dargestellt sind. Beide Fragen zielen darauf ab, Wiederholungen zu reduzieren, wenn auch auf leicht unterschiedliche Weise.

Ich mag das ohne elseund hier ist warum:

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

Weil das nichts kaputt machte, was es nicht sollte.

Hassen Sie die gegenseitige Abhängigkeit in all ihren Formen (einschließlich der Benennung einer Funktion check2()). Isolieren Sie alles, was isoliert werden kann. Manchmal braucht man das, elseaber das sehe ich hier nicht.

Ich denke, es hängt von der Semantik des Codes ab. Wenn Ihre drei Fälle voneinander abhängig sind, geben Sie dies explizit an. Dies erhöht die Lesbarkeit des Codes und erleichtert das Verständnis für andere. Beispiel:

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

Hier sind Sie eindeutig auf den Wert von xin allen drei Fällen angewiesen. Wenn Sie den letzten weglassen elsewürden, wäre dies weniger klar.

Wenn Ihre Fälle nicht direkt voneinander abhängen, lassen Sie es weg:

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

Es ist schwer, dies in einem einfachen Beispiel ohne Kontext zu zeigen, aber ich hoffe, Sie verstehen meinen Standpunkt.

Ich ziehe die zweite Option (trennen ifsohne else ifund früh return) ABER das ist , solange die Codeblöcke kurz sind .

Wenn Codeblöcke lang sind, ist es besser else if, sie zu verwenden , da Sie ansonsten nicht genau wissen, über welche Ausstiegspunkte der Code verfügt.

Beispielsweise:

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

In diesem Fall ist es besser else if, den Rückgabewert in einer Variablen zu speichern und am Ende nur einen Rückgabesatz zu haben.

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

Da man sich jedoch darum bemühen sollte, dass Funktionen kurz sind, würde ich sagen, halten Sie sie kurz und beenden Sie sie früh wie in Ihrem ersten Code-Snippet.

Ich benutze beides unter verschiedenen Umständen. Bei einer Validierungsprüfung lasse ich das übrige weg. In einem Kontrollfluss verwende ich das else.

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

Der erste Fall sieht eher so aus, als würden Sie zuerst alle Voraussetzungen prüfen, diese aus dem Weg räumen und dann zum eigentlichen Code übergehen, den Sie ausführen möchten. Daher gehört der Code, den Sie unbedingt ausführen möchten, direkt zum Funktionsumfang. darum geht es in der Funktion wirklich.
Der zweite Fall sieht eher so aus, als ob beide Pfade gültiger auszuführender Code sind, der für die Funktion genauso relevant ist wie der andere, basierend auf einer bestimmten Bedingung. Als solche gehören sie in ähnlichen Umfangsebenen zueinander.

Die einzige Situation, in der ich jemals gesehen habe, dass es wirklich darauf ankommt, ist folgender Code:

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

Hier stimmt eindeutig etwas nicht. Das Problem ist, es ist nicht klar, ob returnes hinzugefügt oder Arrays.asListentfernt werden sollte. Sie können dies nicht beheben, ohne die zugehörigen Methoden eingehender zu untersuchen. Sie können diese Mehrdeutigkeit vermeiden, indem Sie immer vollständige if-else-Blöcke verwenden. Dies:

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

Kompiliert nicht (in statisch überprüften Sprachen), es sei denn, Sie fügen explizite Rückgabe zuerst hinzu if.

Einige Sprachen erlauben nicht einmal den ersten Stil. Ich versuche es nur im zwingenden Kontext oder als Voraussetzung für lange Methoden zu verwenden:

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

Es ist wirklich verwirrend, drei Abbrüche von dieser Funktion zu haben, wenn Sie versuchen, dem Code zu folgen und schlechte Praktiken anzuwenden.

Wenn Sie einen einzelnen Austrittspunkt für die Funktion haben, sind die anderen erforderlich.

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

Lassen Sie uns sogar noch weiter gehen.

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

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

return result;

Fairerweise könnte man für eine einzelne vorzeitige Rückkehr bei der Eingabevalidierung argumentieren. Vermeiden Sie es einfach, die gesamte Masse in ein Wenn zu packen.

Ich ziehe es vor, die redundante else-Anweisung wegzulassen. Wann immer ich es sehe (bei der Codeüberprüfung oder beim Refactoring), frage ich mich, ob der Autor den Kontrollfluss verstanden hat und ob möglicherweise ein Fehler im Code vorliegt.

Wenn der Autor der Meinung ist, dass die else-Anweisung notwendig ist und daher die Auswirkungen der return-Anweisung auf den Kontrollfluss nicht versteht, ist ein solches Unverständnis sicherlich eine Hauptursache für Fehler in dieser Funktion und im Allgemeinen.