Который является лучшим стилем кодирования?

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

if(!condition1)
{
    log("condition1 failed");
    return false;
}

if(!condition2)
{
    log("condition2 failed");
    return false;
}

if(!condition3)
{
    log("condition3 failed");
    return false;
}

return true;

Может быть, это равносильное неприятие супервложенности, но это определенно чище, чем его хрень, хранящий логические условия в определенных значениях. Однако он может быть менее читабельным в контексте: подумайте, было ли одно из условий isreadable () . Яснее сказать if (isreadable ()) , потому что мы хотим знать, можно ли что-то прочитать. if (! Isreadable ()) подсказывает, хотим ли мы узнать, не читается ли он, что не является нашим намерением. Это, конечно, спорно, что может возникнуть ситуации, когда один является более удобным для чтения / понятнее, чем другие, но я фанат этого пути самого.

Подобно вложенной версии, но намного чище для меня:

if not condition1:
    log("condition 1 failed")
else if not condition2:
    log("condition 2 failed")
else if not condition3:
    log("condition 3 failed")
else
    return true;
return false;

Помните, что каждое условие оценивается один раз.

Лично я считаю, что вложенный код значительно легче читать.

Второй стиль абсурдно многословен: действительно ли он предлагал именно это? Вам не понадобится большинство из этих операторов if , потому что в части else есть return .

Во вложенном примере вы полагаетесь на то, что не забываете включать любые возможные else пункты.

Ни один из них не кажется мне удовлетворительным.

Путь, управляемый bool, сбивает с толку. Вложенность - это нормально, если требуется, но вы можете удалить часть глубины вложенности, объединив условия в один оператор или вызвав метод, в котором выполняется некоторая дальнейшая оценка.

Я бы, вероятно, выбрал

   if (!condition1)      log("condition 1 failed");
   else if (!condition2) log("condition 2 failed");
   else if (!condition3) log("condition 3 failed");
   // -------------------------------------------
   return condition1 && condition2 && condition3;

, который, на мой взгляд, эквивалентен и намного чище ...

Кроме того, как только клиент решит, что все условия должны быть оценены и зарегистрированы в случае их неудачи , а не только первый сбой, это гораздо проще изменить:

   if (!condition1) log("condition 1 failed");
   if (!condition2) log("condition 2 failed");
   if (!condition3) log("condition 3 failed");
   // -------------------------------------------
   return condition1 && condition2 && condition3;

Я думаю, что возможны оба варианта, и у них есть свои плюсы и минусы. Я бы использовал стиль, управляемый bool, в тех случаях, когда у меня было бы действительно глубокое вложение (8 или 10 или что-то в этом роде). В вашем случае с 3 уровнями я бы выбрал ваш стиль, но для точного примера сверху я бы сказал так:

void YourMethod(...)
{
  if (condition1 && condition2 && consition3)
    return true;

  if (!condition 1)
    log("condition 1 failed");

  if (!condition 2)
    log("condition 2 failed");

  if (!condition 3)
    log("condition 3 failed");

  return result;
}

... или так, если вы предпочитаете одну точку выхода (как я) ...

void YourMethod(...)
{
  bool result = false;

  if (condition1 && condition2 && consition3)
  { 
    result = true;
  }
  else
  {
    if (!condition 1)
      log("condition 1 failed");

    if (!condition 2)
      log("condition 2 failed");

    if (!condition 3)
      log("condition 3 failed");
  }
  return result;
}

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

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

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

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

Существует слишком много реализаций в зависимости от ваших потребностей, поэтому создание примера кода было бы бессмысленным.

Как правило, когда ваш код выглядит слишком сложным, он отстой :). Попробуйте переосмыслить это. Следование методам кодирования в большинстве случаев делает код более эстетичным и коротким; и, очевидно, также умнее.

Код должен повторить проблему в данный язык. Поэтому я утверждаю, что любой фрагмент может быть «лучше». Это зависит от моделируемой задачи. Хотя я предполагаю, что ни одно из решений не будет соответствовать реальной проблеме. Если вы поместите реальные термины вместо условия 1,2,3, это может полностью изменить "лучший" код.
Я подозреваю, что есть лучший (трехмерный) способ написать все это вместе.

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

if (!condition1) {
    log("condition1 failed");
    return false;
}
if (!condition2) {
    log("condition2 failed");
    return false;
}
if (!condition3) {
    log("condition3 failed");
    return false;
}
return true;

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

result = true;
if (!condition1) {
    log("condition1 failed");
    result = false;
}
if (!condition2) {
    log("condition2 failed");
    result = false;
}
if (!condition3) {
    log("condition3 failed");
    result = false;
}
return result;

Если язык поддерживает обработку исключений, я бы выполните следующее:

try {
    if (!condition1) {
        throw "condition1 failed";
    }

    if (!condition2) {
        throw "condition2 failed";
    }

    if (!condition3) {
        throw "condition3 failed";
    }

    return true;

} catch (e) {
    log(e);
    return false;
}

РЕДАКТИРОВАТЬ От charles bretana: См. Использование исключений для потока управления

if( condition1 && condition2 && condition3 )
    return true;

log(String.Format("{0} failed", !condition1 ? "condition1" : (!condition2 ? "condition2" : "condition3")));
return false;

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