Welcher Kodierungsstil ist besser?

Question

Während einer Codeüberprüfung hat ein erfahrener Entwickler einige Verschachtelungen in meinem Code bemängelt. Er schlug vor, einen bool-Wert zu setzen, damit ich nie mehr als eine Verschachtelungsebene habe. Ich denke, dass mein Code besser lesbar ist, aber ich möchte die Meinung anderer Entwickler dazu hören. Welcher Stil ist besser? Ist seine spontane Abneigung gegen Verschachtelungen begründet?

Nachstehend finden Sie einige vereinfachte Code-Beispiele.

Verschachtelt:

If(condition1)
{
    If(condition2)
    {
        if(condition3)
        {
            return true;
        }
        else
        {
            log("condition3 failed");
        }
    else
    {
        log("condition2 failed")
    }
}
else
{
    log("condition1 failed")
}

return false;

oder

Bool Getrieben:

bool bRC = false;

bRC = (condition1);
if(brc)
{
    bRC = (condition2);
}
else
{
    log("condition1 failed");
    return false;
}

if(bRC)
{
    bRC = (condition3);
}
else
{
    log("condition2 failed");
    return false;
}

if(bRC)
{
    return true;
}
else
{
    log("condition3 failed");
    return false;
}

Answer 1

Der boolsche Weg ist verwirrend. Eine Verschachtelung ist in Ordnung, wenn sie erforderlich ist, aber Sie könnten einen Teil der Verschachtelungstiefe beseitigen, indem Sie die Bedingungen in einer Anweisung zusammenfassen oder eine Methode aufrufen, in der einige der weiteren Auswertungen vorgenommen werden.

Answer 2

Ich denke, beide Wege sind möglich und haben ihre Vor- und Nachteile. Ich würde den bool-gesteuerten Stil in Fällen verwenden, in denen ich wirklich tiefe Verschachtelungen habe (8 oder 10 oder so ähnlich). In Ihrem Fall mit 3 Ebenen, würde ich Ihren Stil wählen, aber für das genaue Beispiel von oben, würde ich so gehen:

void YourMethod(...)
{
  if (condition1 && condition2 && consition3)
    return true;

  if (!condition 1)
    log("condition 1 failed");

  if (!condition 2)
    log("condition 2 failed");

  if (!condition 3)
    log("condition 3 failed");

  return result;
}

... oder so, wenn Sie einen einzigen Ausstiegspunkt bevorzugen (wie ich) ...

void YourMethod(...)
{
  bool result = false;

  if (condition1 && condition2 && consition3)
  { 
    result = true;
  }
  else
  {
    if (!condition 1)
      log("condition 1 failed");

    if (!condition 2)
      log("condition 2 failed");

    if (!condition 3)
      log("condition 3 failed");
  }
  return result;
}

Auf diese Weise werden alle fehlgeschlagenen Bedingungen im ersten Durchgang protokolliert. In Ihrem Beispiel wird nur eine fehlgeschlagene Bedingung protokolliert, auch wenn es mehr als eine fehlgeschlagene Bedingung gibt.

Answer 3

Ich würde mich wahrscheinlich für

   if (!condition1)      log("condition 1 failed");
   else if (!condition2) log("condition 2 failed");
   else if (!condition3) log("condition 3 failed");
   // -------------------------------------------
   return condition1 && condition2 && condition3;

was meiner Meinung nach gleichwertig und viel sauberer ist...

Wenn der Kunde beschließt, dass alle Bedingungen ausgewertet und protokolliert werden sollen, wenn sie fehlschlagen, und nicht nur die erste, die fehlschlägt, ist es viel einfacher, dies zu ändern:

   if (!condition1) log("condition 1 failed");
   if (!condition2) log("condition 2 failed");
   if (!condition3) log("condition 3 failed");
   // -------------------------------------------
   return condition1 && condition2 && condition3;

Answer 4

Wenn die Sprache die Behandlung von Ausnahmen unterstützt, würde ich das Folgende wählen:

try {
    if (!condition1) {
        throw "condition1 failed";
    }

    if (!condition2) {
        throw "condition2 failed";
    }

    if (!condition3) {
        throw "condition3 failed";
    }

    return true;

} catch (e) {
    log(e);
    return false;
}

EDIT von charles bretana: Bitte siehe Verwendung von Ausnahmen für den Kontrollfluss

Answer 5

So würde ich es implementieren, vorausgesetzt, Ihre Implementierungen entsprechen tatsächlich dem gewünschten Verhalten.

if (!condition1) {
    log("condition1 failed");
    return false;
}
if (!condition2) {
    log("condition2 failed");
    return false;
}
if (!condition3) {
    log("condition3 failed");
    return false;
}
return true;

Ich halte es jedoch für wahrscheinlicher, dass jede fehlgeschlagene Bedingung protokolliert werden sollte.

result = true;
if (!condition1) {
    log("condition1 failed");
    result = false;
}
if (!condition2) {
    log("condition2 failed");
    result = false;
}
if (!condition3) {
    log("condition3 failed");
    result = false;
}
return result;