Сделайте Вы предпочитаете “если (var)” или “если (var! = 0)”? [закрытый]

По-моему, if (var != 0) лучше.

Мне нравятся конструкции Python:

if var:
    return "I like the way I do it!"

Это просто, например ;-)

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

Я нахожу это, если (X) {/*... */} намного легче читать (в C, по крайней мере).

Очень часто я использую:

 if(x) {
       DoSomething;
       DoSomething2;
     }

, поскольку это меньше пишет, и книга который сказанное чтение:

Немного хороших программистов используют форму если (x! =0) , они используют если (x) .

, Но иногда используют и другая форма:

if(x!=0) 

HNY!:-)

VBScript? Хорошо этот бит кода объявляет Вариант, таким образом, bFlag является нулем, который является эффективно Ложью.

Dim bFlag
If bFlag Then

мне не нравится это. Таким образом, даже в VB, с опцией более определенных объявлений, я явный, неважно, что тип.

Dim bFlag As Boolean
If bFlag = False Then

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

Я предпочитаю пустое:

if ($canDo) {
}

вместо чего-то как:

if ($canDo == true) {
}

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

my($canDo) = !0;

к

my($canDo) = 1;

последний сбивает с толку; почему присваивают дискретное значение булевской переменной?

Данный много значений Perl "оценивает к истинному", тем не менее, я вижу, почему быть более явным более практично в конечном счете. Однако, одна из вещей, я больше всего приблизительно как Perl - его естественная лингвистическая текучесть, и я предпочитаю в своем коде придерживаться этого (отъезд комментариев и имен переменной для дальнейшего разъяснения вещей, в случае необходимости).

Если у Вас есть интервал-bool в C, который уже содержит флаг (и не количество), и Вы тестируете его с "если (var! = 0)", где это заканчивается? Не был бы "если ((var! = 0)! = 0)" быть еще лучше?:-)

Я не всегда управляю им, но я пытаюсь использовать

if (0 != var)

, таким образом, это соответствует защитному стилю

if (0 == var)

К моему образу мыслей простота является лучшей.

, Чем более простыми Вы делаете код, тем лучше. Кроме того, менее вероятно Вы сделаете ошибки. Поэтому я использовал бы

if(var)

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

Я обычно предпочитаю if (var) или if ($var), если var используется в качестве булевской переменной, даже если нет никакого подобного типа на языке.

мне очень не нравятся конструкции как if (!strcmp(...)) или if (var == true). Первые попытки быть слишком умным, второе слишком немое - хотя это масштабируется хорошо к if ((var == true) == true)...;-)

Некоторые языки, как Perl и C++, обеспечивают дополнительные или даже определяемые пользователем интерпретации верности. Если преобразование в булевскую переменную кажется слишком волшебным, помните, что это в основном просто is_true(var) или var.booleanValue(), или что-то как этот позади сцены, просто более краткий синтаксис.

Связанный с Вашим вопросом, мне нравится формулировать условия положительным способом. Вместо [1 115]

if (!condition) {
    g();
}
else {
    f();
}

я предпочитаю

if (condition) {
    f();
}
else {
    g();
}

, Даже если существует только единственное ответвление, и условие не ужасно просто. (Признак для этого является потребностью в комментарии.), Например, вместо [1 117]

// explain reason for condition here
if (!condition) {
    f();
}

я предпочитаю формулировать его как [1 118]

if (condition) {
    // explain condition here
}
else {
    f();
}

В C# это было сделано явно недопустимым для записи

if(x){}

, если x не является булевым типом. Нет никакого неявного преобразования в bool от большинства других типов.

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

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

У меня есть набор способы сделать его:

для булевских переменных:

if (x)

для ints:

if (x != 0)  // always compare, never assume true/false on int values

для указателей:

if (x /* != 0 */)  // I've always done this, not sure where I picked it up but I like it

В эти дни, я думаю, что более хорошо иметь вызов функции, который описывает то, что логика на самом деле означает в если РЕДАКТИРОВАНИЕ оператора

: Отметьте, 0 (intsead ПУСТОГО УКАЗАТЕЛЯ) - то, потому что я главным образом использую C++ в эти дни

Для скаляров числового значения я склонен писать if ( $num_foo ), когда $num_foo находится в моем управлении. Если it’s ввод данных пользователем или передал в снаружи меня или numify это сначала, или обстоятельно объясните тест явно. Это зависит от большого количества факторов. Основной критерий - когда и то, как it’s удобный для контакта с неопределенными значениями для предотвращения предупреждений.

Для тестирования на непустую строку я раньше писал if ( $foo ), потому что корректное колдовство просто слишком очень вводит:

if ( defined $foo and length $foo )

, Но я wasn’t удовлетворенный этим положением дел так я спровоцировал изменение поведения для length undef в Perl 5.12, который бросает предупреждение и возвращается 0 до Perl 5.10 включительно. В 5,12 это просто тихо возвратится undef . Поэтому в небулевых контекстах Вы все еще получаете предупреждение, это просто происходит после эти length вызов оценен, а не прежде. Но в булевых контекстах, нет никакого предупреждения, таким образом проверение на непустую строку намного легче сделать правильно:

if ( length $foo )

Я иду с удобочитаемостью как большинство людей, мне нравится способность просканировать мой код и считать ее, не имея необходимость думать слишком много, она идет рука об руку хотя с хорошо именованными именами переменной. Если Ваши имена переменной заставляют его казаться, что это должна быть плоскость if(isPurchasable) тогда, я иду с ним однако, это относится к числу или дате или подобному виду, который я использую if(stock > 0).

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

if(isPurchasable && stock > 0 && credit >= cost && !reserved) { 
     // Checks to see if customer can purchase product.
}

В JavaScript (я не знаю о других динамических языках)

if (x) 

и

if (x != 0)

средние разные вещи. Я буду использовать первого, когда я будет ожидать, что x будет содержать ссылку на объект или строку, которая не должна быть нулевой длиной. Это - достаточно известная идиома.

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

if ( var )
if ( $var )

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

$shouldDoSomething = ( defined $var and $var ne '' ) ? 1 : 0;

if ( $shouldDoSomething ) {
    // Handle this case.
}

Это может очистить код вполне немного. Также помогает, намереваетесь ли Вы использовать это условие несколько раз. Я нахожу, что это довольно часто происходит на самом деле. Кроме того, я чувствую, что вышеупомянутое намного более читаемо, чем выполнение, это встраивает:

if ( defined $var and $var ne '' ) {
    // Handle this case.
}

В Perl if (defined $var and $var ne '') и if( $var) не эквивалентны. Попробуйте его $var=0. С другой стороны, если Вы протестируете на $var!=0 все строки, которые не могут быть преобразованы в числа, то провалит тест (с предупреждением, если у Вас будут они на).

, Таким образом, необходимо знать точно, что содержит переменная (число или строка, может ли это быть undef), таким образом, можно протестировать соответственно.

я обычно просто пишу if( $var) и позволяю Perl заботиться он. Я полагаю, что это легче считать, и это - наиболее распространенный стиль в Perl.

Очень часто, на самом деле, надлежащий тест заканчивает тем, что был if( defined $var). Это - то, где новый perl's (в 5,10) // оператор пригождается. $var= $val // $default или часто $var //= $default, где $var получит $default, только если $val (resp $var) undef.

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

, Но с другой стороны то, что стиль так популярен, вероятно, не является слишком большим из соглашения, но от моей работы с C#, я пишу свой код C++ в этом стиле:

булевская переменная или интервал, который является в основном булевской переменной:

if (val)

Истинное целое число с больше, чем истинным/ложным, являющимся важным:

if (val != 0)

Указатель некоторого вида:

if (val != NULL)

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

Я предпочитаю явные тесты, если результатом в круглых скобках не является явная булевская переменная. Фраза, "если (1)", в то время как синтаксически и семантически исправляют с точки зрения языка, не логична. Это должен быть TRUE или FALSE, не бросок автоматически.

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

я также презираю сильно код формы:

if (gotError == FALSE) ...
if (isComplete == TRUE) ...

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

if (!gotError) ...
if (isComplete) ...

Поэтому (использующий доведение до абсурда) boolVal == TRUE просто другое булево значение, поэтому где Вы останавливаетесь?

if (isComplete == TRUE) ...
if ((isComplete == TRUE) == TRUE) ...
if (((isComplete == TRUE) == TRUE) == TRUE) ...
if ((((isComplete == TRUE) == TRUE) == TRUE) == TRUE)...

И так далее, до бесконечности.

if (var)

Меньше для ввода, пока Вы уверены, что не тестируете неправильную вещь.

Это довольно просто. if( var ) тесты для правдоподобия. if( var != 0 ) тесты, что это не номер 0. , ОНИ НЕ INTERCHANGABLE! существует три причины.

Первый, с помощью if( var != 0 ) для тестирования на истину более сложно. Существует просто больше там, чтобы читать и понять. Вы имеете к grok, который != и 0 является идиомой для, "верно". Испытывая недостаток в отличительном визуальном шаблоне, необходимо сделать немного больше изучения, чтобы знать, что это не то же как if( var == 0). Это - тонкое различие, но стоящий упоминания. То, что эти if( 0 != var ) стиль существует, придает правдоподобность. Лучше просто устранить проблему и использование if( var ) для правдоподобия.

В-третьих, существует предположение здесь о значении истинных и ложных и числовых операторов, которые могли бы удаться на некоторых языках а не в других. В Perl, и я думаю JavaScript также, пустая строка является ложью. Много операторов возвращает пустую строку для лжи. Так тестирование истины с [1 112] приводит к предупреждению. Это становится более абсолютным, когда Вы делаете что-то более наивное как [1 113] для значения истины, явно опасного предположения. Я имею, кажутся, что многие младшие программисты пишут, что и в свою очередь записанные функции, которые возвращают нечетные, но истинные, числа для наказания этого вида вещи. Или когда я нахожусь в настроении предоставления, я санировал свое возвращаемое значение с [1 114].

В связанном примечании, Perl возвратит последнее оцененное выражение из подпрограммы, таким образом, не будет необходимо на самом деле записать return. Объединитесь это с людьми идеи имеет, это явное return медленнее, и Вы получаете много людей, злоупотребляющих этим фактом.

sub set {
    my( $self, $key, $value ) = @_;

    $self->{$key} = $value;
}

set возвратится $value. Это было предназначено? Я не знаю. То, что я действительно знаю, является кем-то, начнет полагаться на него. И программист обслуживания не будет знать, могут ли они изменить его. Таким образом, мне нравится явно помещать возврат в каждую нетривиальную подпрограмму.

sub set {
    my( $self, $key, $value ) = @_;

    $self->{$key} = $value;
    return;
}

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

Я предпочитаю

if (var != 0)

, легче читать/понимать. Так как Вы пишете код однажды, но читаете довольно много раз, легкое чтение более важно, чем легкая запись.

Я удивлен, что никто не упомянул другую опцию, который стандарты кодирования в прошлом моем защищенном работодателе:

if( 0 != x );

, Где константа всегда перечислялась сначала (особенно более важный со сравнениями, поскольку они иногда получают typo'd к присвоениям - источник многих ошибок)

Это - стиль, который я использовал, с тех пор в моем C / Perl / C++ / VB.Net с тех пор (очевидно, точка становится спорной в C# котором, на самом деле не позволяет if (x) сценарий (если x не является на самом деле булевской переменной, конечно).

Есть языки, на которых у вас нет выбора. В Specman, например, нельзя писать:

var x: uint;

if (x) {
    bla
};

Но Вы можете:

var x: uint;

if (x != 0) {
    bla
};

var x: bool;

if (x) {
    bla
};

var x: bool;

if (x != 0) {
    bla
};