这是一个严格的检查测试。

这是一个很好的事情,特别是如果你在0和虚假和零之间检查。

例如,如果你有:

$a = 0;

然后:

$a==0; 
$a==NULL;
$a==false;

所有返回是真实的,你可能不想这样做. 假设你有一个功能可以返回一个序列的 0th 指数或错误的故障. 如果你检查“=="错误,你可以得到一个混乱的结果。

所以,与上面的相同,但严格的测试:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

JavaScript 有严格的和类型转换的比较. 一个严格的比较(例如, ===)仅是真实的,如果操作器是相同的类型. 更常用的抽象比较(例如, ==)在进行比较之前将操作器转换为相同的类型。

平等(==)操作员将操作员转换为操作员,如果它们不属于相同类型,则适用严格的比较;如果操作员是数字或波兰,操作员将转换为数字,如果可能;否则如果操作员是序列,操作员将转换为数字,如果可能。

参考:比较运营商(Mozilla Developer Network)

平等比较:

运营商 =

回归是真实的,当两个操作员是平等的时,操作员在比较之前转换为相同的类型。

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

平等与类型比较:

主持人 ===

回来是真实的,如果两个操作员是相同的和类型。 一般情况下,如果你比较这个方式,它是更好的和更安全的,因为没有背后的场景类型转换。

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

我的理性过程使用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 + "]")
    };
}

我在Firefox使用Firebug测试了此类代码:

console.time(“testEquality”); var n = 0; while (true) { n++; if (n == 100000) break; } console.timeEnd(“testEquality”);

和

console.time(“testTypeEquality”); var n = 0; while (true) { n++; if (n === 100000) break; } console.timeEnd(“testTypeEquality”);

我的结果(每次测试5次,平均):

==: 115.2
===: 114.4

所以我会说小差异(这是超过100000 iterations,记住)是不可忽视的。 性能不是一个理由做 ===. 类型安全(好,安全,你会得到在JavaScript),和代码质量是。

一个简单的例子是

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.