Составная стили И / ИЛИ, если заявления

Как вы разрабатываете сложные составные И / ИЛИ операторы для максимальной читабельности? Как вы делаете отступ и где размещаете разрывы строк? Моя конкретная ситуация выглядит примерно так. Это определенно лучше, чем разбивать все на одну строчку, но все равно выглядит грязно.

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

Сделайте логические переменные для каждого маленького шага:

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

Это, конечно, похоже на ответ лакримологии, но с разными именами для каждого шага.

Если вы назовете step1, step2и так step3, чтобы это имело хороший концептуальный смысл, это должно быть наиболее разборчиво. p.isGood()и k.isSomething()иногда может быть вызван в ситуациях, когда это не будет в вашем исходном коде, так что это не вариант, если эти функции дороги или если вы выполняете этот код в очень узком цикле.

С другой стороны, вам не нужно беспокоиться о падении производительности, которое может возникнуть при создании новых переменных; хороший компилятор их оптимизирует.

Пример с обнаружением столкновения прямоугольника (который вы, вероятно, не будете использовать из-за вышеупомянутого снижения производительности):

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

Может стать:

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

Кроме того, если вы хотите оставить свой код как есть, я думаю, что это тоже будет нормально. Честно говоря, я думаю, что ваш код вполне читабелен. Очевидно, я не знаю, что именно a b x y i u p k m n, но что касается структуры, она выглядит хорошо для меня.

Я обычно перефакторинг своего кода, чтобы быть более модульным, если мои условия усложняют.

Я бы сделал что-то подобное на этом уровне сложности

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

if(doIt)
{
    doSomething();
}

это уродливо, но это читабельно, и я уверен, что компилятор будет знать, как его реорганизовать.

С другой стороны, если я когда-нибудь увижу себя в ситуации написания такого оператора IF, я переосмысливаю решение, потому что я УВЕРЕН, что есть способ сделать это проще или, по крайней мере, абстрагировать некоторые из этих условий (например, возможно, x == y && a != b && p.isGood()на самом деле просто имею в виду, this->isPolygon()и я могу сделать этот метод;

Я становлюсь менее одержимым вертикальным выравниванием с течением времени, но моя общая форма с многострочными выражениями ...

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

Ключевые моменты ...

• Закрытые парены выровнены вертикально с открытыми паренями, как с фигурными скобками.
• Подвыражения, которые помещаются в одну строку, находятся в пределах одной строки и выровнены по вертикали слева. Там, где это помогает читабельности, инфиксные операторы в этих однострочных частях также выровнены по вертикали.
• Закрывающие скобки, естественно, создают почти пустые строки, помогая визуально группировать вещи.

Иногда я буду форматировать +и / *или некоторые другие операторы, как это тоже. Довольно много сложных выражений принимают форму суммы продукта или продукта суммы (которая может относиться к логическим «суммам» и «продуктам»), так что, вероятно, достаточно распространено, что стоит придерживаться согласованного стиля для него.

Будьте осторожны с этим, хотя. Часто лучше выполнить рефакторинг (переместить части выражения в функцию или вычислить и сохранить промежуточные части в переменной), а не использовать отступы, чтобы сделать более сложное выражение более читабельным.

Если вы предпочитаете ставить своих близких парней на правой стороне, я не ненавижу это, но думаю, это не так уж плохо. Слишком далеко, вы рискуете, что из-за ошибки отступы могут искажать то, что делают скобки.

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

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

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

Я согласен с ответом JohnFx, а также ответом по Lacrymology. Я хотел бы создать набор функций (предпочтительно статических), которые выполняют небольшие задачи, а затем разумно их использовать.

Итак, как насчет этого? Обратите внимание, что это не идеальное решение, но оно работает. Есть способы убрать это дальше, но нужна более конкретная информация. Примечание: этот код должен выполняться так же быстро, потому что компилятор умен.

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

Что бы это ни стоило, я был удивлен, увидев, что ваш пример очень похож на сложные предикаты, которые я написал. Я согласен с другими, что сложный предикат не самый лучший для удобства обслуживания или читабельности, но иногда они появляются.

Позвольте мне подчеркнуть, что вы сделали эту часть правильно: && a != b НИКОГДА не ставьте логический разъем в конце строки, это слишком легко пропустить визуально. Еще одно место, где вы НИКОГДА не должны ставить оператор в конце строки, - это конкатенация строк на языках с таким оператором.

Сделай это:

String a = b
   + "something"
   + c
   ;

Не делай этого:

String a = b +
   "something" +
   c;

Если условие настолько сложное, это обычно указывает на то, что оно должно быть разбито на части. Возможно, одному предложению можно присвоить промежуточную переменную. Возможно, одно предложение можно превратить в вспомогательный метод. Я вообще предпочитаю не иметь так много ands и ors в одной строке.

Вы можете разбить код на несколько операторов, что облегчает понимание. Но настоящий ниндзя сделал бы что-то подобное. :-)

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