使用 = = 运营商(平等)

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

使用 === 运营商(身份)

true === 1; //false
"2" === 2;  //false

这是因为平等运营商 = = 输入强迫,这意味着翻译者在比较之前暗示地试图转换值。

另一方面,身份操作员 === 不做类型强制,因此在比较时不转换值。

严格的平等在大多数情况下更好。

只要数据结构是相同的,真的没有理由不使用严格的平等,经常的平等,你经常有一个暗示的转换的值发生自动,这可能会对你的代码有遥远的影响。

严格的平等,没有自动的随机转换,因为值必须是正确的数据结构。

我的理性过程使用eMAcs org-mode和node.js进行测试。

| use ==     | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | t     | f       | f         | f    | f          |
| '0'        |    | x   | t     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | t          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | t    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          | 



| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | f     | f       | f         | f    | f          |
| '0'        |    | x   | f     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | f          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | f    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |

下面的我的测试脚本:运行 > node xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems

for(var i = 0; i < rowItems.length; i++) {
    for (var j = 0; j < colItems.length; j++) {
        var r = (rowItems[i] === colItems[j]) ? true : false;
        console.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}

简单

= = = = = = = = = = = = = = = = = = = = = =

和

=== 是指在没有类型强迫的情况下进行操作的比较。

格式强制在JavaScript中意味着自动将数据类型转换为其他数据类型。

例如:

123 == "123"  // Returns true, because JS coerces string "123" to number 123
              // and then goes on to compare `123 == 123`.

123 === "123" // Returns false, because JS does not coerce values of different types here.

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

看到这一点在一个答案. a 和 b 不是真正相同的类型在这种情况下,如果你检查 tipof(a) 你会得到“对象” 和 tipof(b) 是“紧张”。

JavaScript 执行流图为严格的平等 / 比较 '==='

此分類上一篇

JavaScript 执行流图为非严格的平等/比较“==”

此分類上一篇