Composé de coiffage ET / OU if

Comment stylisez-vous les instructions complexes ET / OU if pour une lisibilité maximale? Comment indentez-vous et où placez-vous les sauts de ligne? Ma situation particulière ressemble à ce qui suit. C'est certainement mieux que de tout casser en une seule ligne, mais ça a toujours l'air désordonné.

if (
    (
        x == y
        && a != b
        && p.isGood() 
        && (
            i + u == b
            || q >= a
        )
    )
    || k.isSomething()
    || m > n
) {
    doSomething();
}

Créez des variables booléennes pour chaque petite étape:

bool step1 = i + u == b || q >= a;
bool step2 = a != b && p.isGood() && group1;
bool step3 = group2 || k.isSomething() || m > n;
if (step3) { doSomething(); }

Ceci est bien sûr similaire à la réponse de Lacrymologie, sauf avec des noms différents pour chaque étape.

Si vous nommez step1, step2et step3d'une manière qui a un bon sens conceptuel, cela devrait être de loin le plus lisible. p.isGood()et k.isSomething()peut parfois être invoqué dans des situations où il ne serait pas dans votre code d'origine, donc ce ne serait pas une option si ces fonctions sont coûteuses ou si vous exécutez ce code dans une boucle très serrée.

D'un autre côté, vous n'avez pas à vous soucier des performances que la création de nouvelles variables pourrait entraîner; un bon compilateur les optimisera.

Un exemple avec la détection de collision rectangle (que vous n'utiliseriez probablement pas en raison de la performance susmentionnée):

if((a.x + a.width >= b.x || b.x + b.width >= a.x)
 && (a.y + a.height >= b.y || b.y + b.width >= a.y)
)
{ collision(); }

Pourrait devenir:

bool horizMatch = a.x + a.width >= b.x || b.x + b.width >= a.x;
bool vertMatch = a.y + a.height >= b.y || b.y + b.width >= a.y;
if(horizMatch && vertMatch) { collision(); }

De plus, si vous voulez laisser votre code tel quel, je pense que ce serait tout aussi bien. Je pense honnêtement que votre code est assez lisible. Évidemment, je ne sais pas exactement ce que a b x y i u p k m nsont, mais en ce qui concerne la structure, cela me semble bien.

En général, je re-factorise mon code pour le rendre plus modulaire si mes conditions deviennent compliquées.

Je ferais quelque chose de plus comme ça, à ce niveau de complexité

bool doIt = x == y && a != b && p.isGood();
doIt &= ( i + u == b || q >= a);
doIt |= k.isSomething() || m > n;

if(doIt)
{
    doSomething();
}

c'est moche, mais c'est lisible et je suis presque certain que le compilateur saura comment le refactoriser.

D'un autre côté, si jamais je me vois dans la situation d'écrire une telle déclaration IF, je repense la solution, car je suis CERTAIN qu'il existe un moyen de le faire plus simplement, ou du moins d'abstraire une partie de cette condition (par exemple: peut-être: x == y && a != b && p.isGood()vraiment méchant this->isPolygon()et je peux faire cette méthode;

Je suis de moins en moins obsédé par l'alignement vertical au fil du temps, mais ma forme générale avec des expressions sur plusieurs lignes est ...

if (   (   (expr1 == expr2)
        || (expr3 == expr4)
        || (expr5 == expr6)
       )
    && (   (expr7 == expr8)
        || (expr9 == expra)
       )
   )
{
  blah;
}

Points clés...

• Les parens proches s'alignent verticalement avec les parens ouverts, comme avec les accolades.
• Les sous-expressions qui tiennent dans une ligne sont dans une ligne et sont alignées verticalement à gauche. Là où cela aide à la lisibilité, les opérateurs d'infixe au sein de ces pièces unifilaires sont également alignés verticalement.
• Les accolades de fermeture créent naturellement des lignes presque vides, aidant à regrouper visuellement les choses.

Parfois, je vais formater +et / *ou d'autres opérateurs comme ça aussi. Un certain nombre d'expressions complexes prennent une forme de somme de produit ou de produit de somme (qui peut faire référence à des «sommes» et «produits» booléens), il est donc probablement assez courant qu'un style cohérent en vaille la peine.

Soyez prudent avec cela, cependant. Il est souvent préférable de refactoriser (déplacer des parties de l'expression dans une fonction, ou de calculer et de stocker des parties intermédiaires dans une variable) plutôt que d'utiliser l'indentation pour essayer de rendre une expression trop complexe plus lisible.

Si vous préférez empiler vos parenthèses sur le côté droit, je ne le déteste pas, mais je suppose que ce n'est pas trop mal. Trop poussé, vous courez le risque qu'une erreur puisse laisser l'indentation dénaturer ce que font les parenthèses.

if (   (   (expr1 == expr2)
        || (expr3 == expr4)
        || (expr5 == expr6))

    && (   (expr7 == expr8)
        || (expr9 == expra)))
{
  blah;
}

http://www.codinghorror.com/blog/2006/01/flattening-arrow-code.html

Je suis d'accord avec la réponse de JohnFx ainsi que celle de Lacrymology. Je voudrais créer un tas de fonctions (de préférence statiques) qui atteignent de petits objectifs, puis les développer de manière intelligente.

Alors, que diriez-vous de quelque chose comme ça? Notez que ce n'est pas la solution parfaite, mais cela fonctionne. Il existe des moyens de nettoyer davantage, mais des informations plus spécifiques sont nécessaires. Remarque: ce code devrait fonctionner tout aussi rapidement, car le compilateur est intelligent.

// Currently based on members or global vars
// (which is often a bad idea too)
function doSomethingCondirionally()
{
  if (k.isSomething() || m > n)
  {
    doSomething();
    return;
  }

  // Else ... 
  if (x != y) return;
  if (a == b) return;
  if (!p.isGood()) return;

  // Final, positive check
  if (i + u == b || q >= a)
  {
    doSomething();
  }
}

Pour ce que ça vaut, j'ai été surpris de voir que votre exemple ressemble beaucoup aux prédicats compliqués que j'ai écrits. Je suis d'accord avec les autres pour dire qu'un prédicat compliqué n'est pas le meilleur pour la maintenabilité ou la lisibilité, mais il arrive parfois qu'il apparaisse.

Permettez-moi de souligner que vous avez fait cette partie correctement: && a != b NE JAMAIS mettre de connecteur logique à la fin d'une ligne, c'est trop facile de manquer visuellement. Un autre endroit où vous ne devez JAMAIS mettre un opérateur à la fin de la ligne est la concaténation de chaînes, dans les langues avec un tel opérateur.

Faites ceci:

String a = b
   + "something"
   + c
   ;

Ne faites pas ça:

String a = b +
   "something" +
   c;

Si le conditionnel est si compliqué, c'est généralement une indication qu'il doit être divisé en plusieurs parties. Peut-être qu'une clause peut être affectée à une variable intermédiaire. Peut-être qu'une clause peut être transformée en une méthode d'assistance. Je préfère généralement ne pas avoir autant d'and et d'ou sur une même ligne.

Vous pouvez diviser le code en plusieurs instructions, ce qui le rend facile à comprendre. Mais un vrai ninja ferait quelque chose comme ça. :-)

if
(
    (
        x == y
    &&
        a != b
    &&
        p.isGood()
    &&
        (
            i + u == b
        ||
            q >= a
        )
    )
||
    k.isSomething()
||
    m > n
)
{
    doSomething();
}