Вы обычно устанавливаете значение по умолчанию прежде или еще устанавливаете его в?

Я предпочитаю второе в Java, делая что-то вроде этого:

int x;
if (cond) {
  x = 1;
} else {
  x = 5;
}

потому что, если что-то изменяется позже (например, я поворачиваюсь else блок в else if), компилятор скажет мне, что переменной не удалось быть инициализированной, который я мог бы пропустить, если бы я использовал Вашу первую стратегию.

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

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

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

Зависит от контекста. Я использовал бы вторую опцию, когда ясно, что 'var' должен быть верным когда ЕСЛИ сбои.

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

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

if (a==b) {
  if (a==c) {
    [new logic]
    var=false
  }
}
else {
  var = false
}

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

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

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

int final = 27;

if ( some condition ) final = 86;

if ( another condition ) {
    final = 98;
    return final;
}

if ( some state ) {
   final += 2;
}

return final;

Или что-то подобное этому.

BTW: в Вашем примере при установке 'var', затем следующая строка просто тестирует 'var', Вам действительно не нужен 'var', делают Вас? Если условие так ужасно, что использование 'var' помогает сделать его читаемым, то Ваш, вероятно, лучший для перемещения условия в свою собственную функцию, признавая, что дополнительный вызов функции там для помощи удобочитаемости. В целом можно потратить впустую ресурсы, если и только если Вы получаете что-то значительное, такое как удобочитаемость, в ответ.

Paul.

Вы предпочитаете код, который короток и компактен, или кодируйте, который легче считать?

Если Вы предпочитаете код, который является коротким и компактным использованием

var x = true;
if (...) x = false;

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

var x;
if (...) x = true;

Если Вы предпочитаете код, который легок считать использование

if (...) var x = false;
else var x = true;

потому что это ясно дает понять Ваши намерения.

Производительность обоих является тем же.

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

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

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

final Type var;
if (cond)
{
    var = value1;
}
else
{
     var = value2;
}

Компилятор Java зафиксирует ошибку, что var не присваивают значение, прежде чем это будет использоваться. Заключительное ключевое слово выражает то, что переменная является постоянной после условного выражения.

В Вашем точном случае с булевскими переменными я использовал бы

final boolean var = !cond;

Используя условное выражение в этом случае указывает, что Вы сокрушены "booleanophobia".

В C я инициализировал бы переменную в ее объявлении.

Я обычно устанавливал значение "по умолчанию" и использование если операторы для изменения его. Если никакое значение по умолчанию не существует затем только если операторы.

int timeout = 100;
if (moreTime) timeout = 1000;

int searchOption = null;
if (sometest1) searchOption = 1;
if (sometest2) searchOption = 2;

// then later..
if (searchOption != null)
  .....

Везде, где Вы пишете, если () также еще пишут - даже если это пусто.
Компилятор оптимизирует его далеко, но это вынуждает Вас (и какие-либо программисты после Вас) думать о том, когда, если () не инициирован, каковы последствия?

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

boolean isFoo = determineWhetherFoo(...);

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