Лучший способ отформатировать оператор if с несколькими условиями

Если вы хотите, чтобы какой-то код выполнялся на основе двух или более условий, как лучше всего отформатировать этот оператор if?

первый пример: -

if(ConditionOne && ConditionTwo && ConditionThree)
{
   Code to execute
}

Второй пример: -

if(ConditionOne)
{
   if(ConditionTwo )
   {
     if(ConditionThree)
     {
       Code to execute
     }
   }
}

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

Я предпочитаю вариант А

bool a, b, c;

if( a && b && c )
{
   //This is neat & readable
}

Если у вас есть особенно длинные переменные / условия метода, вы можете просто разорвать их на строку

if( VeryLongConditionMethod(a) &&
    VeryLongConditionMethod(b) &&
    VeryLongConditionMethod(c))
{
   //This is still readable
}

Если они еще более сложные, то я бы подумал о том, чтобы делать методы условия отдельно вне оператора if.

bool aa = FirstVeryLongConditionMethod(a) && SecondVeryLongConditionMethod(a);
bool bb = FirstVeryLongConditionMethod(b) && SecondVeryLongConditionMethod(b);
bool cc = FirstVeryLongConditionMethod(c) && SecondVeryLongConditionMethod(c);

if( aa && bb && cc)
{
   //This is again neat & readable
   //although you probably need to sanity check your method names ;)
}

IMHO Единственная причина для варианта «B» - это если у вас есть отдельные elseфункции для запуска для каждого условия.

например

if( a )
{
    if( b )
    {
    }
    else
    {
        //Do Something Else B
    }
}
else
{
   //Do Something Else A
}

Другие ответы объясняют, почему обычно лучше всего первый вариант. Но если у вас несколько условий, подумайте о создании отдельной функции (или свойства), выполняющей проверку условий в варианте 1. Это значительно упрощает чтение кода, по крайней мере, при использовании хороших имен методов.

if(MyChecksAreOk()) { Code to execute }

...

private bool MyChecksAreOk()
{ 
    return ConditionOne && ConditionTwo && ConditionThree;
}

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

Первый пример более «читаемый».

На самом деле, на мой взгляд, вы должны использовать только второй вариант, когда вам нужно добавить некоторую «логику else», но для простого Conditional используйте первый вариант. Если вас беспокоит длина условия, вы всегда можете использовать следующий синтаксис:

if(ConditionOneThatIsTooLongAndProbablyWillUseAlmostOneLine
                 && ConditionTwoThatIsLongAsWell
                 && ConditionThreeThatAlsoIsLong) { 
     //Code to execute 
}

Удачи!

Вопрос был задан и до сих пор получен ответ, как будто решение должно приниматься исключительно на «синтаксических» основаниях.

Я бы сказал, что правильный ответ о том, как вы выкладываете ряд условий в if, также должен зависеть от «семантики». Итак, условия должны быть разбиты и сгруппированы в соответствии с тем, что «концептуально» сочетается друг с другом.

Если два теста действительно являются двумя сторонами одной медали, например. если (x> 0) && (x <= 100), то поместите их в одну строку. Если другое условие концептуально гораздо более отдаленное, например. user.hasPermission (Admin ()), затем поместите его в отдельную строку

Например.

if user.hasPermission(Admin()) {
   if (x >= 0) && (x < 100) {
      // do something
   }
}

if (   ( single conditional expression A )
    && ( single conditional expression B )
    && ( single conditional expression C )
   )
{
   opAllABC();
}
else
{
   opNoneABC();
}

Форматирование нескольких условных выражений в выражении if-else следующим образом:

1. обеспечивает улучшенную читаемость:
   a. все двоичные логические операции {&&, ||} в выражении, показанном первым
   b. оба условных операнда каждой бинарной операции очевидны, потому что они выровнены по вертикали
   c. Операции вложенных логических выражений становятся очевидными с помощью отступов, как и вложения операторов внутри предложения
2. требует явных скобок (не полагаться на правила приоритета операторов)
   a. это позволяет избежать распространенных ошибок статического анализа
3. позволяет упростить отладку файла
   . отключить отдельные одиночные условные тесты с помощью только a //
   b. установить точку
   останова непосредственно перед или после любого отдельного теста ceg ...

// disable any single conditional test with just a pre-pended '//'
// set a break point before any individual test
// syntax '(1 &&' and '(0 ||' usually never creates any real code
if (   1
    && ( single conditional expression A )
    && ( single conditional expression B )
    && (   0
        || ( single conditional expression C )
        || ( single conditional expression D )
       )
   )
{
   ... ;
}

else
{
   ... ;
}

Второй - классический пример антипаттерна стрелки, поэтому я бы его избегал ...

Если ваши условия слишком длинные, извлеките их в методы / свойства.

Первый вариант проще, потому что, если вы читаете его слева направо, вы получите: «Если что-то И что-то еще И что-то еще ТО», что легко понять. Второй пример гласит: «Если что-то ТО, если что-то еще ТО, если что-то еще ТО», что неуклюже.

Также подумайте, хотите ли вы использовать несколько OR в своем предложении - как бы вы это сделали во втором стиле?

В Perl вы могли сделать это:

{
  ( VeryLongCondition_1 ) or last;
  ( VeryLongCondition_2 ) or last;
  ( VeryLongCondition_3 ) or last;
  ( VeryLongCondition_4 ) or last;
  ( VeryLongCondition_5 ) or last;
  ( VeryLongCondition_6 ) or last;

  # Guarded code goes here
}

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

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

Если альтернативы нет, то, как предлагали другие, - разбейте ее на отдельные и сократите имена или сгруппируйте их, и, например, если все должно быть истинным, используйте что-то вроде «если нет ложного в массиве x, тогда запускайте».

Если ничего не получится, @Eoin Campbell высказал довольно хорошие идеи.

Когда условие действительно сложное, я использую следующий стиль (пример из реальной жизни PHP):

if( $format_bool &&
    (
        ( isset( $column_info['native_type'] )
            && stripos( $column_info['native_type'], 'bool' ) !== false
        )
        || ( isset( $column_info['driver:decl_type'] )
            && stripos( $column_info['driver:decl_type'], 'bool' ) !== false
        )
        || ( isset( $column_info['pdo_type'] )
            && $column_info['pdo_type'] == PDO::PARAM_BOOL
        )
    )
)

Я считаю, что это лучше и удобнее, чем вложение нескольких уровней if(). И в некоторых случаях, подобных этому, вы просто не можете разбить сложное условие на части, потому что в противном случае вам пришлось бы if() {...}многократно повторять одни и те же операторы в блоке.

Я также считаю, что добавление «воздуха» в код - всегда хорошая идея. Это значительно улучшает читаемость.