相等比较操作

JavaScript 有四种不同的相等比较操作。

SameValue

如果两个操作数属于同一个 Type 并且值相同,则返回 true。

注意:对象的值是引用。

你可以通过 Object.is(ECMAScript 6)使用此比较算法。

例子:

Object.is(1, 1);            // true
Object.is(+0, -0);          // false
Object.is(NaN, NaN);        // true
Object.is(true, "true");    // false
Object.is(false, 0);        // false
Object.is(null, undefined); // false
Object.is(1, "1");          // false
Object.is([], []);          // false

该算法具有等价关系的属性 :

  • 反身性 :Object.is(x, x) 是 true,任何值 x
  • 对称性 :Object.is(x, y) 是 true,如果且仅当 Object.is(y, x) 是 true 时,对于任何值 x 和 y。
  • 及物性 :如果 Object.is(x, y) 和 Object.is(y, z) 是 true,则 Object.is(x, z) 也是 true,对于任何值 x,y 和 z。

SameValueZero

它的行为类似于 SameValue,但认为+0 和 -0 是相同的。

你可以通过 Array.prototype.includes(ECMAScript 7)使用此比较算法。

例子:

[1].includes(1);            // true
[+0].includes(-0);          // true
[NaN].includes(NaN);        // true
[true].includes("true");    // false
[false].includes(0);        // false
[1].includes("1");          // false
[null].includes(undefined); // false
[[]].includes([]);          // false

该算法仍具有等价关系的属性 :

  • 反身性 :[x].includes(x) 是 true,任何值 x
  • 对称性 :[x].includes(y) 是 true,如果且仅当 [y].includes(x) 是 true,对于任何值 x 和 y。
  • 及物性 :如果 [x].includes(y) 和 [y].includes(z) 是 true,则 [x].includes(z) 也是 true,任何值 x,y 和 z。

严格的相等比较

它的行为类似于 SameValue,但是

  • 认为+0 和 -0 是相等的。
  • 认为 NaN 与任何价值都不同,包括其本身

你可以通过 === 运算符(ECMAScript 3)使用此比较算法。

还有 !== 运算符(ECMAScript 3),它否定了 === 的结果。

例子:

1 === 1;            // true
+0 === -0;          // true
NaN === NaN;        // false
true === "true";    // false
false === 0;        // false
1 === "1";          // false
null === undefined; // false
[] === [];          // false

该算法具有以下属性:

  • 对称 :x === y 是 true,当且仅当,y === xistrue, for any valuesxandy`。
  • 及物性 :如果 x === y 和 y === z 是 true,则 x === z 也是 true,对于任何值 x,y 和 z。

但不是等价关系, 因为

  • NaN 不反身 :NaN !== NaN

抽象的相等比较

如果两个操作数属于同一类型,则其行为类似于严格等同比较。

否则,它会强制它们如下:

  • undefined 和 null 被认为是相等的
  • 将数字与字符串进行比较时,字符串将被强制转换为数字
  • 将布尔值与其他值进行比较时,布尔值会被强制转换为数字
  • 将对象与数字,字符串或符号进行比较时,会将对象强制转换为基元

如果存在强制,则递归地比较强制值。否则算法返回 false。

你可以通过 == 运算符(ECMAScript 1)使用此比较算法。

还有 != 运算符(ECMAScript 1),它否定了 == 的结果。

例子:

1 == 1;            // true
+0 == -0;          // true
NaN == NaN;        // false
true == "true";    // false
false == 0;        // true
1 == "1";          // true
null == undefined; // true
[] == [];          // false

该算法具有以下属性:

  • 对称 :x == y 是 true,如果且仅当 y == x 是 true 时,对于任何值 x 和 y。

但不是等价关系, 因为

  • NaN 不反身 :NaN != NaN
  • 传递性不成立,例如 0 == ''和 0 == '0',但是'' != '0'