Wie zu stoppen Chain Code zu schreiben?

Question

zum Beispiel ...

if ( /* Condition */ ) {

    if ( /* Condition */ ) {

        if ( /* Condition */ ) {

          // Superb!

        } else {

          // Error 3

        }

    } else {

      // Error 2

    }

} else {

  // Error 1

}

Sie wissen, wie dies zu vermeiden? Vielen Dank!

Answer 1

Wenn dies eine Bibliotheksfunktion ist, throw kann die geeignete Maßnahme sein.

if (!condition1) {
    throw "Condition 1 failed.";
}

if (!condition2) {
    throw "Condition 2 failed.";
}

if (!condition3) {
    throw "Condition 3 failed.";
}

// Superb!

Andere akzeptable Maßnahmen könnten sein:

• Rückkehr 0, null oder undefined.
• Anzeige einen Fehler an den Benutzer und zurück.

Sie müssen die Sicherheitsaktion bestimmen das Richtige für Ihren Anwendungsfall ist.

Answer 2

Es sieht aus wie Sie 3 Bedingungen zu überprüfen und 4 Aktionen (3 verschiedene Fehler + 1 Erfolg). Leider im allgemeinen Fall geht es 3 bedingte Kontrollen und 4 Maßnahmen erfordern. Ich denke, der Code kann mit der folgenden Struktur obwohl

ein wenig gereinigt werden

if (! /* condition 1 */ ) {
  // Error 1
} else if (! /* condition 2 */ ) { 
  // Error 2
} else if (! /* condition 3 */ ) { 
  // Error 3
} else {
  // superb
}

Answer 3

Nun können Sie Ausnahmen verwenden, oder Brüche innerhalb eines Blocks oder mehrere Funktionen. Oft erfordert dies Ihre Bedingungen invertiert den Code zu erhalten, den richtigen Weg geordert.

do {
    if (! /* Condition 1 */ ) {
        // Error 1
        break;
    }

    if (! /* Condition 2 */ ) {
        // Error 2
        break;
    }

    if (! /* Condition 3 */ ) {
        // Error 3
        break;
    }

    // Superb!
} while (false);

Die do-while (false) Schleife ist ein Weg, um einen Block zu machen, dass Sie in Sprachen brechen aus kann, die keine anonymen Block toleriert. Es könnte genauso gut eine Funktion und Verwendung zurückkehrt, oder ein Try-Catch mit Ausnahmen.

Answer 4

Möchten Sie lieber das?

if ( /* Condition 1*/ && /* Condition 2*/ && /* Condition 3 */) {
  // Superb!
}
else if (! /* Condition 1*/){
  // Error 1
}
else if (! /* Condition 2*/){
  // Error 2
}
else if (! /* Condition 3*/){
  // Error 3
}

Answer 5

if ( ! /* Condition */ ) {
Error 1
throw someSortOfException
}

if (! condition 2){
Error 2
throw someSortOfOtherException
}

if (! condition 3){
Error 3
throw another Exception
}

// Success!

Je nach Situation kann der Code bevorzugt werden. Sie werden wahrscheinlich wollen diese Ausnahmen irgendwo zum Beispiel fangen.

Answer 6

if (!condition1)
    // Error 1 (and exit scope if necessary)

if (!condition2)
    // Error 2 (and exit scope if necessary)

if (!condition3)
    // Error 3 (and exit scope if necessary)

// Superb!

Answer 7

Ja; Sie können Ihre if-Anweisungen in einer einzigen Verbindung Anweisung mit dem AND-Operator, und behandeln Sie die Fehlerbedingungen in einem einzigen Block zusammenstellen zusammen. Je nach Ihren Bedürfnissen Fehler Handhabung, obwohl, müssen Sie sich unter Umständen wieder mehrere ifs haben, um sicherzustellen, sind Sie richtig die Fehlerbehandlung (auf den Fehler hängt Auflösung Handhabung, wirklich).

Nämlich:

if (CondA && CondB && CondC)
   {
   // Execute success
   }
else
   {
   if (!CondA)
      // Do error A
   else if (!CondB)
      // Do error B
   else if (!CondC)
     // Do error C
   }
}

Answer 8

Es gibt ein paar Möglichkeiten gibt, die einfachste ist, einfach einige Funktionen Büste und abstrakt aus den verschiedenen Schichten (dies ohnehin getan werden soll, wenn Sie sich tief gehen finden.)

if ( /* Condition */ ) {
    value = aFunctionSaysWhat();
} else {
  // value = Error 1
}

....
value aFunctionSaysWhat(){
    if ( /* Condition */ ) {
         return aSecondFunctionHere();
    } else {
      // return Error 2
    }
}

Die Grundvoraussetzung ist, dass eine Funktion auf einer Ebene der Abstraktion, wenn möglich leben soll, und eine Sache tun.

Die nächste Möglichkeit ist, sie alle aus abzuzuflachen, dies zu Ihren ersten verschachtelten Verfahren überlegen ist, hat aber im Grunde ähnlich komplex. Es könnte viel sauberer als der funktionalen Ansatz sein, wenn Sie nur ein paar Optionen und Sie nicht Plan auf mehr hinzuzufügen.

if(ErrorCondition1){
   //Error 1
}else if(ErrorCondition2){
   //Error 2
}else if(ErrorCondition3){
   //Error 3
}else{
   //Superb
}

Schließlich können Sie speichern eine Hash oder eine Karte mit den gewünschten Antworten und entfernen Sie das, wenn vollständig, die Fähigkeit, diese auf Ihre Fähigkeit, Hash zu implementieren verlässt sich einige Ergebnis:

Results = {'Result1':'Error1', 'Result2':'Error2', 'Result3':'Error3', 'Success':'Superb'}

return Results[ConditionHash(Condition)];