Стильний склад І / АБО, якщо твердження

Як ви створюєте складний склад І / АБО, якщо висловлювання для максимальної читабельності? Як робити відступ і де розміщувати перерви рядка? Моя конкретна ситуація є приблизно такою. Це, безумовно, краще, ніж розбити все в одну лінію, але все одно виглядає безладним.

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;

Якщо умовне настільки складне, зазвичай це є ознакою того, що його слід розбити на частини. Можливо, одне застереження може бути віднесено до проміжної змінної. Можливо, одне застереження можна перетворити на допоміжний метод. Я, як правило, вважаю, що в одному рядку не так багато анс і ор.

Ви можете розбити код на кілька заяв, що полегшує розуміння. Але справжня ніндзя зробила б щось подібне. :-)

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