Comment arrêter l'écriture de code de chaîne?

Question

par exemple ...

if ( /* Condition */ ) {

    if ( /* Condition */ ) {

        if ( /* Condition */ ) {

          // Superb!

        } else {

          // Error 3

        }

    } else {

      // Error 2

    }

} else {

  // Error 1

}

Savez-vous comment éviter cela? Merci!

Answer 1

Si cela est une fonction de bibliothèque, throw peut être l'action appropriée.

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

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

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

// Superb!

D'autres actions pourraient être acceptables:

• De retour 0, null ou undefined.
• Affichage d'une erreur à l'utilisateur et le retour.

Vous devez déterminer quelle action l'échec est pour votre cas d'utilisation.

Answer 2

Il semble que vous avez 3 conditions pour vérifier et 4 actions (3 erreurs différentes + 1 succès). Malheureusement, dans le cas général, il va exiger 3 contrôles conditionnels et 4 actions. Je pense que le code peut être nettoyé un peu en utilisant la structure suivante si

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

Answer 3

Eh bien, vous pouvez utiliser des exceptions ou des pauses dans un bloc ou plusieurs fonctions. Souvent, cela nécessite inverser vos conditions pour obtenir le code ordonné la bonne façon.

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

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

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

    // Superb!
} while (false);

La boucle do-while (false) est une façon de faire un bloc que vous pouvez sortir de dans les langues qui ne tolérera pas un bloc anonyme. Il pourrait tout aussi bien être une fonction et retourne utiliser, ou try-catch avec des exceptions.

Answer 4

Préférez-vous cela?

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!

En fonction de la situation, votre code peut être préféré. Vous aurez probablement envie de prendre ces exceptions quelque part, par exemple.

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

Oui; vous pouvez composer ensemble vos déclarations de if en une seule instruction composée avec l'opérateur, et de gérer les conditions d'erreur dans un seul bloc. En fonction de vos besoins de gestion des erreurs, cependant, vous devrez peut-être encore une fois avoir plusieurs ifs pour faire vous assurer que la manipulation correctement l'erreur (cela dépend de votre résolution gestion des erreurs, vraiment).

A savoir:

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

Il y a quelques façons, le plus simple est de buste simplement des fonctions et abstraite sur les différentes couches (cela doit être fait de toute façon si vous vous trouvez aller en profondeur.)

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

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

Le principe de base est qu'une fonction doit vivre sur une couche d'abstraction si possible, et faire une chose.

La possibilité suivante consiste à aplatir tous dehors, c'est supérieur à votre méthode imbriquée initiale, mais a essentiellement complexité similaire. Il pourrait être beaucoup plus propre que l'approche fonctionnelle si vous avez seulement quelques options et que vous ne prévoyez pas d'ajouter plus.

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

Enfin, vous pouvez stocker un hachage ou d'une carte avec les réponses souhaitées et retirez le si complètement, la capacité de mettre en œuvre cette repose sur votre capacité à hash un résultat:

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

return Results[ConditionHash(Condition)];