Операторы сравнения JavaScript: идентичность и равенство

Я пытался понять разницу между операторами сравнения JavaScript: личность и равенство. Из того, что я прочитал, если вы проверите равенство двух объектов с помощью ==, JavaScript попытается выяснить, являются ли они одним и тем же типом, а если нет, попытайтесь получить их для того же типа. Однако === не ведет себя одинаково. Итак, пример:

var n = "1";
console.log(n==1);        // outputs true
console.log(n===1);       // outputs false

В чем же разница между этими "идентичными" операторами и регулярными операторами равенства? В чем преимущество обоих?

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

Кроме того, как они отличаются друг от друга, когда речь идет о более сложных объектах, например массивах? Самое главное, что говорят в конвенциях о том, когда нужно использовать друг друга, почему?

Ответ 1

Оператор равенства попытается сделать типы данных одинаковыми до проведения сравнения. С другой стороны, оператор идентификации требует, чтобы оба типа данных были такими же, как необходимое условие.

Есть довольно много других сообщений, похожих на эти вопросы. См:

Каким образом отличаются операторы сравнения равенства между равными (== double equals) и идентичность (=== triple equals)? (имеет хорошую сравнительную таблицу)
Какой оператор равен (== vs ===) должен использоваться при сравнении JavaScript?

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

1 == true     => true
true == true  => true
1 === true    => false
true === true => true

Ответ 2

Разница в том, что ==, < =, >= и!= будет делать тип coercion — например, заставить строку оценивать как число. ===, < ==, > ==, и! == не будет делать принуждение типа. Они будут сравнивать строку с числом, и поскольку строка "1" не совпадает с числовым значением 1, результат будет ложным.

Ссылка находится здесь:
https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators

Ответ 3

== - это те же вещи, что и ===, за исключением того, что == делает преобразование типа

Чтобы показать, что я имею в виду здесь, это функция JavaScript, которая ведет себя точно так же, как ==:

// loseEqual() behaves just like `==`
function loseEqual(x, y) {
    // notice the function only uses "strict" operators 
    // like `===` and `!==` to do comparisons

    if(typeof y === typeof x) return y === x;

    if(typeof y === "function" || typeof x === "function") return false;

    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);

    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;

    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Эта функция должна помочь объяснить, почему люди говорят, что не следует использовать ==.

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

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

Неожиданные истины

[1] == true // returns true
'0' == false // returns true
[] == false // returns true
[[]] == false // returns true
[0] == false // returns true

'\r\n\t' == 0 // returns true

Неожиданные выводы

// IF an empty string '' is equal to the number zero (0)
'' == 0 // return true

// AND the string zero '0' is equal to the number zero (0)
'0' == 0 // return true

// THEN an empty string must be equal to the string zero '0'
'' == '0' // returns **FALSE**

Объекты со специальными функциями

// Below are examples of objects that
// implement `valueOf()` and `toString()`

var objTest = {
    toString: function() {
        return "test";
    }
};

var obj100 = {
    valueOf: function() {
        return 100;
    }
};

var objTest100 = {
    toString: function() {
        return "test";
    },
    valueOf: function() {
        return 100;
    }
};

objTest == "test" // returns true
obj100 == 100 // returns true
objTest100 == 100 // returns true

objTest100 == "test" // returns **FALSE**

Ответ 4

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

Более ясное объяснение в следующей ссылке:

https://medium.com/@ludico8/identity-vs-equality-battle-of-understanding-vs-758d396e922#.hhg396ey9