操作员 = = = = = = = = = = = = = = = = = = = = = = = = = = =

此分類上一篇

缺乏过渡性是令人担忧的,我的建议是永远不要使用邪恶的双胞胎,相反,总是使用 === 和!== 所有仅仅显示的比较都是与 === 运营商虚假的。

更新:

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

在这里 ==运营商正在检查两个对象的值,并返回真实,但 ===看到它们不是相同的类型,并返回虚假。 哪一个是正确的? 这真的取决于你正在试图比较什么。

参考 http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

我的理性过程使用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 有严格的和类型转换的比较. 一个严格的比较(例如, ===)仅是真实的,如果操作器是相同的类型. 更常用的抽象比较(例如, ==)在进行比较之前将操作器转换为相同的类型。

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

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

我在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),和代码质量是。

从核心JavaScript参考

=== 返回是真实的,如果操作员是严格平等的(见上)没有类型转换。

不同之間的 =, =, = =

= 操作员 只用来指定值 = = 操作员 只用来比较不数据型值 = = 操作员 只用来比较值和数据型值。