Composições de estilo AND / OR if

Como você denomina instruções complexas AND / OR complexas para obter a máxima legibilidade? Como você recua e onde coloca as quebras de linha? Minha situação particular é algo como o seguinte. É definitivamente melhor do que quebrar tudo em uma linha, mas ainda parece confuso.

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

Faça variáveis ​​booleanas para cada pequena etapa:

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

Naturalmente, isso é semelhante à resposta da lacrologia, exceto com nomes diferentes para cada etapa.

Se você citar step1, step2e step3de maneiras que façam um bom senso conceitual, isso deve ser de longe o mais legível. p.isGood()e k.isSomething()às vezes pode ser invocado em situações em que não estaria no seu código original; portanto, isso não seria uma opção se essas funções fossem caras ou se você estiver executando esse código em um loop muito restrito.

Por outro lado, você não precisa se preocupar com o impacto no desempenho que pode resultar na criação de novas variáveis; um bom compilador os otimizará.

Um exemplo com detecção de colisão de retângulo (que você provavelmente não usaria devido ao desempenho acima mencionado):

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

Pode se tornar:

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

Além disso, se você quiser deixar seu código como está, acho que também seria ótimo. Sinceramente, acho que seu código é bastante legível. Obviamente, não sei exatamente o que a b x y i u p k m nsão, mas, no que diz respeito à estrutura, parece bom para mim.

Normalmente, refiz meu código para ser mais modular se meus condicionais ficarem tão complicados.

Eu faria algo mais parecido com este, neste nível de complexidade

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

if(doIt)
{
    doSomething();
}

é feio, mas é legível e tenho certeza de que o compilador saberá como refatorá-lo.

Por outro lado, se eu me encontrar na situação de escrever uma declaração IF, repenso a solução, porque CERTINOS há uma maneira de simplificá-la ou, pelo menos, abstrair algumas dessas condições (por exemplo: talvez x == y && a != b && p.isGood()realmente apenas significa this->isPolygon()e eu posso fazer esse método;

Estou ficando menos obcecado com o alinhamento vertical ao longo do tempo, mas minha forma geral com expressões de várias linhas é ...

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

Pontos chave...

• Os parênteses próximos alinham-se verticalmente com os parênteses abertos, assim como com os chavetas.
• As subexpressões que se encaixam em uma linha estão dentro de uma linha e são alinhadas verticalmente à esquerda. Onde isso ajuda na legibilidade, os operadores infix nessas peças de linha única também são alinhados verticalmente.
• As chaves de fechamento criam naturalmente linhas quase vazias, ajudando a agrupar visualmente as coisas.

Às vezes, formato +e / *ou outros operadores como esse também. Algumas expressões complexas assumem a forma de soma do produto ou produto da soma (que pode se referir a "somas" e "produtos" booleanos), portanto é provavelmente bastante comum que um estilo consistente valha a pena.

Tenha cuidado com isso, no entanto. Muitas vezes, é melhor refatorar (mover partes da expressão para uma função ou calcular e armazenar partes intermediárias em uma variável) em vez de usar o recuo para tentar tornar uma expressão de excesso de complexidade mais legível.

Se você prefere empilhar seus parênteses no lado direito, eu não odeio , mas acho que não é tão ruim. Levando longe demais, você corre o risco de que um erro possa deixar o recuo deturpando o que os parênteses fazem.

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

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

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

Concordo com a resposta de JohnFx e com a de Lacrymology. Eu construí um monte de funções (de preferência estáticas) que atingem pequenos objetivos e depois os desenvolvemos de maneira inteligente.

Então, que tal algo assim? Observe que essa não é a solução perfeita, mas funciona. Existem maneiras de limpar isso ainda mais, mas são necessárias informações mais específicas. Nota: esse código deve ser executado tão rápido quanto o compilador é 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();
  }
}

Pelo que vale, fiquei surpreso ao ver que seu exemplo se parece muito com os complicados predicados que escrevi. Concordo com os outros que um predicado complicado não é o melhor para manutenção ou legibilidade, mas ocasionalmente eles surgem.

Deixe-me enfatizar que você fez esta parte correta: && a != b NUNCA coloque o conector lógico no final de uma linha, é muito fácil perder visualmente. Outro local em que você nunca deve colocar um operador no final da linha está na concatenação de cadeias, em idiomas com esse operador.

Faça isso:

String a = b
   + "something"
   + c
   ;

Não faça isso:

String a = b +
   "something" +
   c;

Se o condicional é tão complicado, geralmente é uma indicação de que ele deve ser dividido em partes. Talvez uma cláusula possa ser atribuída a uma variável intermediária. Talvez uma cláusula possa ser transformada em um método auxiliar. Geralmente, prefiro não ter tantos ands e ors em uma linha.

Você pode dividir o código em várias instruções, facilitando a compreensão. Mas um ninja de verdade faria algo assim. :-)

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