Meilleure façon de formater une instruction if avec plusieurs conditions

Question

Si vous voulez qu'un code soit exécuté en fonction de deux ou plusieurs conditions, quelle est la meilleure façon de formater cette instruction if ?

premier exemple:-

if(ConditionOne && ConditionTwo && ConditionThree)
{
   Code to execute
}

Deuxième exemple:-

if(ConditionOne)
{
   if(ConditionTwo )
   {
     if(ConditionThree)
     {
       Code to execute
     }
   }
}

qui est le plus facile à comprendre et à lire, sachant que chaque condition peut être un long nom de fonction ou autre.

Answer 1

Je préfère l'option A

bool a, b, c;

if( a && b && c )
{
   //This is neat & readable
}

Si vous avez des variables/conditions de méthode particulièrement longues, vous pouvez simplement les séparer par un saut de ligne

if( VeryLongConditionMethod(a) &&
    VeryLongConditionMethod(b) &&
    VeryLongConditionMethod(c))
{
   //This is still readable
}

Si elles sont encore plus compliquées, j'envisagerais d'appliquer les méthodes de condition séparément, en dehors de l'instruction if.

bool aa = FirstVeryLongConditionMethod(a) && SecondVeryLongConditionMethod(a);
bool bb = FirstVeryLongConditionMethod(b) && SecondVeryLongConditionMethod(b);
bool cc = FirstVeryLongConditionMethod(c) && SecondVeryLongConditionMethod(c);

if( aa && bb && cc)
{
   //This is again neat & readable
   //although you probably need to sanity check your method names ;)
}

IMHO La seule raison pour l'option 'B' serait si vous avez des systèmes séparés. else fonctions à exécuter pour chaque condition.

par exemple

if( a )
{
    if( b )
    {
    }
    else
    {
        //Do Something Else B
    }
}
else
{
   //Do Something Else A
}

Answer 2

D'autres réponses expliquent pourquoi la première option est normalement la meilleure. Mais si vous avez plusieurs conditions, envisagez de créer une fonction (ou une propriété) distincte pour vérifier les conditions de l'option 1. Cela rend le code beaucoup plus facile à lire, du moins lorsque vous utilisez de bons noms de méthodes.

if(MyChecksAreOk()) { Code to execute }

...

private bool MyChecksAreOk()
{ 
    return ConditionOne && ConditionTwo && ConditionThree;
}

Si les conditions ne reposent que sur des variables de portée locale, vous pouvez rendre la nouvelle fonction statique et y passer tout ce dont vous avez besoin. S'il y a un mélange, passez les variables locales.

Answer 3

if (   ( single conditional expression A )
    && ( single conditional expression B )
    && ( single conditional expression C )
   )
{
   opAllABC();
}
else
{
   opNoneABC();
}

Formater une expression conditionnelle multiple dans une instruction if-else de cette façon :

1. permet d'améliorer la lisibilité :
   a. toutes les opérations logiques binaires {&&, ||} dans l'expression représentée en premier lieu
   b. les deux opérandes conditionnels de chaque opération binaire sont évidents car ils sont alignés verticalement
   c. les opérations d'expressions logiques imbriquées sont rendues évidentes par l'indentation, tout comme l'imbrication d'instructions à l'intérieur d'une clause.
2. nécessite des parenthèses explicites (ne pas se fier aux règles de précédence des opérateurs)
   a. cela permet d'éviter une erreur courante d'analyse statique

3. permet un débogage plus facile
   a. désactiver les tests conditionnels individuels avec seulement un //.
   b. fixer un point de rupture juste avant ou après une épreuve individuelle
   c. e.g. ...

   // disable any single conditional test with just a pre-pended '//' // set a break point before any individual test // syntax '(1 &&' and '(0 ||' usually never creates any real code if ( 1 && ( single conditional expression A ) && ( single conditional expression B ) && ( 0 || ( single conditional expression C ) || ( single conditional expression D ) ) ) { ... ; }

   else { ... ; }

Answer 4

Le premier exemple est plus "facile à lire".

En fait, à mon avis, vous ne devriez utiliser le second que lorsque vous devez ajouter une logique "else", mais pour un simple conditionnel, utilisez le premier. Si vous êtes préoccupé par la longueur de la condition, vous pouvez toujours utiliser la syntaxe suivante :

if(ConditionOneThatIsTooLongAndProbablyWillUseAlmostOneLine
                 && ConditionTwoThatIsLongAsWell
                 && ConditionThreeThatAlsoIsLong) { 
     //Code to execute 
}

Bonne chance !

Answer 5

La question a été posée et il y a été répondu, jusqu'à présent, comme si la décision devait être prise sur des bases purement "syntaxiques".

Je dirais que la bonne réponse est la façon dont vous disposez un certain nombre de conditions dans un if, devrait dépendent aussi de la "sémantique". Les conditions doivent donc être décomposées et regroupées en fonction des éléments qui vont ensemble "conceptuellement".

Si deux tests sont en fait les deux faces d'une même pièce, par exemple si (x>0) && (x<=100), mettez-les ensemble sur la même ligne. Si une autre condition est conceptuellement beaucoup plus éloignée, par exemple user.hasPermission(Admin()), mettez-la sur sa propre ligne.

Eg.

if user.hasPermission(Admin()) {
   if (x >= 0) && (x < 100) {
      // do something
   }
}