Compuesto de estilo Y / O si las declaraciones

¿Cómo diseñas las declaraciones compuestas complejas AND / OR if para una máxima legibilidad? ¿Cómo sangras y dónde colocas los saltos de línea? Mi situación particular es algo como lo siguiente. Definitivamente es mejor que romper todo en una línea, pero aún se ve desordenado.

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

Haga variables booleanas para cada pequeño paso:

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

Por supuesto, esto es similar a la respuesta de Lacrymology, excepto con diferentes nombres para cada paso.

Si nombra step1, step2y step3de manera que tenga un buen sentido conceptual, este debería ser, con mucho, el más legible. p.isGood()y a k.isSomething()veces puede invocarse en situaciones en las que no estaría en su código original, por lo que esta no sería una opción si esas funciones son caras o si está ejecutando este código en un ciclo muy cerrado.

Por otro lado, no necesita preocuparse por el impacto en el rendimiento en el que podría incurrir la creación de nuevas variables; un buen compilador los optimizará.

Un ejemplo con la detección de colisión rectangular (que probablemente no usaría debido al impacto de rendimiento mencionado anteriormente):

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(); }

Podría convertirse:

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(); }

Además, si quieres dejar tu código como está, creo que eso también estaría totalmente bien. Sinceramente, creo que su código es bastante legible. Obviamente no sé qué a b x y i u p k m nson exactamente , pero en lo que respecta a la estructura, me parece bien.

Por lo general, vuelvo a factorizar mi código para que sea más modular si mis condicionales se vuelven tan complicados.

Haría algo más como esto, a este nivel de complejidad

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

if(doIt)
{
    doSomething();
}

es feo, pero es legible y estoy bastante seguro de que el compilador sabrá cómo refactorizarlo.

Por otro lado, si alguna vez me veo en la situación de escribir una declaración IF de este tipo, vuelvo a pensar la solución, porque estoy SEGURO de que hay una manera de hacerlo más simple, o al menos abstrayendo parte de esa condición (por ejemplo: tal vez x == y && a != b && p.isGood()realmente solo significa this->isPolygon()y puedo hacer ese método;

Me obsesiono menos con la alineación vertical con el tiempo, pero mi forma general con expresiones de varias líneas es ...

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

Puntos clave...

• Los parens cercanos se alinean verticalmente con los parens abiertos, como con las llaves.
• Las subexpresiones que caben dentro de una línea están dentro de una línea y están alineadas verticalmente a la izquierda. Donde ayuda a la legibilidad, los operadores de infijo dentro de esas partes de una sola línea también están alineados verticalmente.
• Las llaves de cierre crean naturalmente líneas casi en blanco, lo que ayuda a agrupar visualmente las cosas.

A veces, formateo +y / *o algunos otros operadores como este también. Algunas expresiones complejas toman una forma de suma de producto o producto de suma (que puede referirse a "sumas" y "productos" booleanos) por lo que probablemente sea lo suficientemente común que valga la pena usar un estilo consistente.

Pero ten cuidado con esto. A menudo es mejor refactorizar (mover partes de la expresión a una función, o calcular y almacenar partes intermedias en una variable) en lugar de usar sangría para tratar de hacer que una expresión sobrecompleja sea más legible.

Si prefieres apilar a tus parientes cercanos en el lado derecho, no lo odio , pero supongo que no es tan malo. Sin embargo, llevado demasiado lejos, corre el riesgo de que un error pueda dejar la sangría tergiversando lo que hacen los paréntesis.

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

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

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

Estoy de acuerdo con la respuesta de JohnFx y con la de Lacrymology. Construiría un montón de funciones (preferiblemente estáticas) que cumplan objetivos pequeños y luego los desarrolle de manera inteligente.

Entonces, ¿qué tal algo como esto? Tenga en cuenta que esta no es la solución perfecta, pero funciona. Hay formas de limpiar esto aún más, pero se necesita información más específica. Nota: este código debe ejecutarse igual de rápido, ya que el compilador es inteligente.

// 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();
  }
}

Por lo que vale, me sorprendió ver que su ejemplo se parece mucho a los predicados complicados que he escrito. Estoy de acuerdo con otros en que un predicado complicado no es el mejor para la mantenibilidad o la legibilidad, pero a veces surgen.

Permítanme enfatizar que hicieron esta parte correctamente: && a != b NUNCA coloque un conector lógico al final de una línea, es demasiado fácil pasarlo por alto visualmente. Otro lugar donde NUNCA debe colocar un operador al final de la línea es en la concatenación de cadenas, en idiomas con dicho operador.

Hacer esto:

String a = b
   + "something"
   + c
   ;

No hagas esto:

String a = b +
   "something" +
   c;

Si el condicional es tan complicado, generalmente es una indicación de que debe dividirse en partes. Quizás se pueda asignar una cláusula a una variable intermedia. Quizás una cláusula puede convertirse en un método auxiliar. Generalmente prefiero no tener tantos ands y ors en una línea.

Puede dividir el código en varias declaraciones, lo que facilita su comprensión. Pero un verdadero ninja haría algo como esto. :-)

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