Подтвердить что ты не робот

Boolean в выражении if

Сегодня я получил замечание о коде, рассматривая, как я проверяю, истинна или ложна переменная в школьном задании.

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

var booleanValue = true;

function someFunction(){
    if(booleanValue === true){
        return "something";
    }
}

Они сказали, что лучше/аккуратно написать это так:

var booleanValue = true;

function someFunction(){
    if(booleanValue){
        return "something";
    }
}

Замечание, которое я получил о части "=== true", было то, что он не был нужен и мог создать путаницу.

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

Во втором примере строка также вернет "что-то";

Итак, мой вопрос; Непосредственно ли потерять часть "=== true" в будущем, или это хорошая практика, чтобы проверить тип переменной.

Edit: В моем "реальном" коде логическое выражение представляет, было ли удалено изображение или нет, поэтому значения boolValue, которые должны быть когда-либо, должны быть истинными или ложными.

0 и 1, например, не должны находиться в этой переменной.

4b9b3361

ОТВЕТЫ

Ответ 1

Прежде всего, факты:

if (booleanValue)

Будет удовлетворять оператору if для любого правдивого значения booleanValue, включая true, любое ненулевое число, любое непустое строковое значение, любую ссылку на объект или массив и т.д.

С другой стороны:

if (booleanValue === true)

Это будет удовлетворять только условию if, если booleanValue точно равно true. Никакое другое истинное значение не удовлетворит его.

С другой стороны, если вы это сделаете:

if (someVar == true)

Затем, что Javascript будет делать, это тип coerce true, чтобы соответствовать типу someVar, а затем сравнить две переменные. Есть много ситуаций, когда это, скорее всего, не то, что можно было бы намереваться. Из-за этого в большинстве случаев вам нужно избегать ==, потому что существует довольно длинный набор правил о том, как Javascript будет вводить принуждение, чтобы две вещи были одного типа, и если вы не понимаете все эти правила и не можете предвидеть все, что интерпретирует JS может возникнуть при использовании двух разных типов (которые большинство разработчиков JS не могут), вы, вероятно, хотите полностью избежать ==.

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

var x;

x = 0;
console.log(x == true);   // false, as expected
console.log(x == false);  // true as expected

x = 1;
console.log(x == true);   // true, as expected
console.log(x == false);  // false as expected

x = 2;
console.log(x == true);   // false, ??
console.log(x == false);  // false

Ответ 2

Если вы пишете: if(x === true), это будет верно только для x = true

Если вы пишете: if(x), это будет верно для любого x, который не является: '' (пустая строка), false, null, undefined, 0, NaN.

Ответ 3

В обычном "if" переменная будет принудительно введена в значение Boolean и она использует toBoolean для объекта: -

    Argument Type   Result

    Undefined       false
    Null            false
    Boolean         The result equals the input argument (no conversion).
    Number          The result is false if the argument is +0, −0, or NaN;
                    otherwise the result is true.
    String          The result is false if the argument is the empty 
                    String (its length is zero); otherwise the result is true.
    Object          true.

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

Если вы говорите, что объект может быть даже не логическим, вам может потребоваться больше, чем просто true/false.

if(x===true){
...
} else if(x===false){
....
} else {
....
}

Ответ 4

Это зависит от вашего использования. Возможно, имеет смысл также проверить тип, но если это просто флаг, это не так.

Ответ 5

В общем, чище и проще опустить === true.

Однако в Javascript эти выражения различны.

if (booleanValue) будет выполняться, если booleanValue - правша – ничего, кроме 0, false, '', NaN, null и undefined.

if (booleanValue === true) будет выполняться только в том случае, если booleanValue точно равно true.

Ответ 6

Поскольку проверенное значение - Boolean, оно предпочитает использовать его напрямую для меньшего количества кодирования, и вообще оно делает то же самое ==true

Ответ 7

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

if (booleanValue) по существу if (booleanValue==true)

Ответ 8

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

Ответ 9

Это зависит. Если вас беспокоит, что ваша переменная может оказаться чем-то, что разрешает TRUE. Тогда жесткая проверка является обязательной. Иначе это зависит от вас. Однако я сомневаюсь, что синтаксис whatever == TRUE никогда не смутил бы всех, кто знал, что они делают.

Ответ 10

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

Если потенциально можно назначить другие типы, и вам нужно отличить true от 1 или "foo", тогда вы должны использовать === true.

Ответ 11

В Javascript идея булевы довольно неоднозначна. Рассмотрим это:

 var bool = 0 
 if(bool){..} //evaluates to false

 if(//uninitialized var) //evaluates to false

Поэтому, когда вы используете оператор if (или любой другой управляющий оператор), не нужно использовать "логический" тип var. Поэтому, на мой взгляд, "=== истинная" часть вашего утверждения не нужна, если вы знаете, что она является логической, но абсолютно необходимой, если ваше значение является двусмысленным "правдивым" var. Подробнее о boolean в javscript можно найти здесь.

Ответ 12

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

  • Обычно это не добавляет значения выражения - что в тех случаях, когда значение известно как булево, все равно.
  • Поскольку в JavaScript существует большая неопределенность типов, принудительная проверка типа имеет тенденцию укусить вас, когда вы получаете неожиданное значение undefined или null. Часто вы просто хотите, чтобы ваш тест потерпел неудачу в таких случаях. (Хотя я стараюсь сбалансировать это мнение с девизом "fail fast" ).
  • Программисты JavaScript любят играть быстро и свободно с типами - особенно в булевых выражениях - потому что мы можем.

Рассмотрим следующий пример:

var someString = getInput();
var normalized = someString && trim(someString);  
// trim() removes leading and trailing whitespace

if (normalized) {
    submitInput(normalized);
}

Я думаю, что такой код не редкость. Он обрабатывает случаи, когда getInput() возвращает undefined, null или пустую строку. Из-за двух булевых оценок submitInput() вызывается только в том случае, если данный ввод представляет собой строку, содержащую символы без пробелов.

В JavaScript && возвращается свой первый аргумент, если он является ложным или его вторым аргументом, если первый аргумент правдив; поэтому normalized будет undefined, если someString undefined и т.д. Это означает, что ни один из входных данных для булевых выражений выше не является фактически логическими значениями.

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

Ответ 13

Ревиза https://www.w3schools.com/js/js_comparisons.asp

Пример:

var p=5;

p==5 ? true
p=="5" ?  true
p==="5" ? false

=== означает тот же тип и то же значение == точно такое же значение

enter image description here