JavaScript правдивые числа

Question

На основании этих правил:

Ложь:

• false
• 0 (ноль)
• ''или "" (пустая строка)
• null
• неопределенный
• NaN (например, результат 1/0)

Truthy: Все остальное

Я не могу найти правильное объяснение того, почему в следующих тестах только номер 1 оценивается как "истина"

0 == true ("false")
1 == true ("true")
2 == true ("false")
othernumber == true ("false")

Answer 1

0 является ложным, что не означает, что другое число будет истинным. Простой пример Если вы используете === в условии, тогда вы увидите false для всех чисел.

(0 == true) // false
(1 == true) // true

Работает нормально. Однако, в приведенном ниже примере, я не использовал оператор not (!) В условии. Поэтому, если условие истинно, оно должно вывести true, иначе false. Тем не менее, это даст вам обратный результат.

if(0){console.log("true")}else{console.log("false")} // false
if(1){console.log("true")}else{console.log("false")} // true
if(15){console.log("true")}else{console.log("false")} // true

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

Boolean(0) == true // false
Boolean(1) == true // true
Boolean(2) == true // true
Boolean(othernumber) == true // true

Спасибо

Answer 2

Based on these rules: Проблема в том, что == НЕ работает по этим правилам. Является ли что-то правдивым или нет, и как оно ведет себя во время тестов на равенство - это две разные вещи. Для записи, более правильный тест на правдивость будет

if (value) 
    return true;
else
    return false;

или даже короче - прямое преобразование Boolean(value) (и неявное преобразование !!value.

Однако, во время теста на равенство обе стороны == будут преобразованы в один и тот же базовый тип, и , а затем будет выполнен фактический тест. В MDN есть список правил для конвертации - прямо с него 1 == true использует число и логическое значение, поэтому базовый тип для обоих: число . Синтаксический анализатор JS выполнит ToNumber(booleanValue), поэтому вот что на самом деле тестирует равенство

var convertedBooleanOperand = Number(true);

console.log("convertedBooleanOperand", convertedBooleanOperand);

На самом деле 2 == true преобразуется в 2 == 1, что составляет false.

Answer 3

В JavaScript (==) - оператор равенства, где выполняется преобразование типа.Более строгий (===) оператор идентификации не будет выполнять преобразование типов.

Например, даже если число не является логическим, вы можете использовать числовое значение, где ожидается логическое значение, если использовать (==) operator.

Но если вы введете более строгий оператор (===), вы увидите, что '1 === true' будет иметь значение false.

Answer 4

Это очень интересная причина, согласно этой книге , когда вы сравниваете что-либо с логическим значением, как вы делаете, например, в x == y это следует такой схеме:

Если тип (x) является логическим, вернуть результат сравнения ToNumber (x) == y.

Если тип (y) является логическим, вернуть результат сравнения x == ToNumber (y).

Таким образом, когда вы сравниваете 1 == true, на самом деле он делает 1 == ToNumber(true), который затем превращается в 1 == 1, но когда вы делаете 2 == true, он превращается в 2 == 1, что ложно дляКонечно.

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

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

Надеюсь, вы найдете этот ответ удовлетворительным.

Answer 5

использование == отличается от if(something) Этот тест даст вам ожидаемые результаты:

function truthyFalsyTest()
{
    if(0) 
    {
       console.log("true");
    }
    else
    {
        console.log("false");
    }

    if(1) 
    {
       console.log("true");
    }
    else
    {
        console.log("false");
    }

    if(2) 
    {
       console.log("true");
    }
    else
    {
        console.log("false");
    }

    if(2222) 
    {
       console.log("true");
    }
    else
    {
        console.log("false");
    }
}

truthyFalsyTest();

Answer 6

Правила "правдивости" и "ложности" применяются только тогда, когда само значение используется в качестве теста, например:

var str = "";
if (str) {
    // It's truthy
} else {
    // It's falsy
}

== имеет свой собственный, другой, набор правил для определенияслабое равенство его операндов, которое подробно объясняется в алгоритме абстрактного равенства равенства спецификации :

1. Если тип (x) совпадает с типом (y), тогда
   • Возвращает результат выполнения сравнения строгого равенства x === y.
2. Если x равно нулю, а y не определено, вернуть true.
3. Если x не определено, а y равно нулю, вернуть true.
4. Если тип (x) равен Number, а тип (y) равен String, вернуть результат сравнения x == ToNumber (y).
5. Если Type (x) равен String, а Type (y) равен Number, вернуть результат сравнения ToNumber (x) == y.
6. Если Type (x) равен Boolean, вернутьрезультат сравнения ToNumber (x) == y.
7. Если тип (y) является логическим значением, вернуть результат сравнения x == ToNumber (y).
8. If Тип (x) - это String, Number или Symbol, а Type (y) - Object. Возвращает результат сравнения. x == ToPrimitive (y).
9. Если Type (x) равен Object и Type(y) это либо String, Number, либо Symbol, возвращающий результат сравнения ToPrimitive (x) == y.
10. Return false.

См. спецификациюдля полных деталей различных абстрактных операций, перечисленных там, хотя названия в значительной степени говорят, что они делают.(Если вы посмотрите на спецификацию, вы увидите ! до ToNumber в разных местах; я удалил ее выше. Это не логический оператор NOT, это спецификациянотация, связанная с «резкими завершениями». )

Давайте рассмотрим это для вашего 2 == true примера:

1. Типы не совпадают, так что продолжайте
2. x не равен нулю, поэтому продолжайте идти
3. x не определено, поэтому продолжайте идти
4. Тип (x) действительно Number, а тип (y) - нетСтрока, так что продолжайте
5. Тип (x) не является строкой, поэтому продолжайте идти
6. Тип (x) не является логическим, поэтому продолжайте:
7. Тип (y) равенЛогическое значение, поэтому возвращаем результат x == ToNumber (y)
   • ToNumber (true) равен 1, а поскольку 2 == 1 равно false, результат равен false

Но обратите внимание, что шаг 7 отличается для вашего 1 == true примера:

Тип (y) является логическим, поэтому возвращаем результат x == ToNumber (y)

• ToNumber (true) равен 1, а так как 1 == 1 соответствует true, результат равен true