為什麼 ==是如此不可預測的?

如果你比较一个空的字符串“”与零的数字,你会得到什么?

它没有结束,这里还有一个:

'0' == false // true

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

随后,用绳子

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

它变得更糟:

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

让我们再说一遍:

(A == B) && (B == C) // true
(A == C) // **FALSE**

而这只是你与原始人得到的疯狂事物。

為什麼會發生這件事?

好吧,这是因为不同于“三重平等”(===),这只是检查两个值是否相同。

它有特殊的处理功能,特殊的处理零,无定义,线条,你命名它。

它变得相当可口可乐。

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // 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 y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    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;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

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

那么这意味着什么呢?

这意味着你可以用错误结束。

让你的生活更不复杂。

使用 === 而不是 ==。

* 主持人 === vs == *

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

操作员称为严格的比较操作员,与操作员不同。

将采取2 vars a 和 b。

对于“a = = b”来评估为真实的 a 和 b 必须是相同的值。

在“a === b”的情况下,a 和 b 必须是相同的值,也必须是相同的类型,以便它被评估为真实。

接下来的例子

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

简而言之,使用 == 操作员可能会在您不希望使用 === 操作员这样做的情况下评估为真实。

在90%的使用场景中,不管你使用哪个,但当你有一天得到一些意想不到的行为时,知道差异是有用的。

操作员只是比较不数据类的值。

=== 运营商将值与其数据类型的比较进行比较。

艾:

1 == "1" //true

1 === "1" //false

此操作员(“===”)用于自动输入字符的语言,例如 PHP,JavaScript。

上述2个答案都意味着平等,而 ===则意味着身份。

如果两个操作员是对象,那么它们是相似的,以确定它们是否是相同的对象;如果两个操作员指向相同的对象,那么相同的操作员会返回真相;否则,两者不相同。

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

在上面的代码中,既 == 又 === 都是虚假的,因为 a 和 b 不是相同的对象。

也就是说,如果两个操作员是 ==的对象, ==行为相同的 ===,这也意味着身份,这两个操作员的基本区别是类型转换。

总是使用“===”并且你会避免成千上万的错误. 如今使用三重平等是由不同的风格指南更受欢迎,因为它比较考虑到类型的歌手。