JavaScript中的相等性判断

最新推荐文章于 2021-12-28 15:35:29 发布

周晓风

最新推荐文章于 2021-12-28 15:35:29 发布

阅读量1.2k

点赞数 1

分类专栏： JS web 文章标签： javascript 前端

本文链接：https://blog.csdn.net/u011140116/article/details/121846423

版权

web 同时被 2 个专栏收录

18 篇文章 2 订阅

订阅专栏

9 篇文章 0 订阅

订阅专栏

ES2015中有四种相等算法：

严格相等 ===
非严格相等 ==
同值相等
零值相等

JavaScript提供三种不同的值比较操作：

严格相等比较 ==> Strict Equality，使用 ===
抽象相等比较 ==> Loose Equality，使用 ==
Object.is （ECMAScript 2015/ ES6 新特性）判断两个参数是否是同一个值

简而言之，在比较两个对象时:

双等号将执行类型转换;
三等号将进行相同的比较，而不进行类型转换 (如果类型不同, 只是总会返回 false );
Object.is的行为方式与三等号相同，但是对于NaN和-0和+0进行特殊处理。

通常使用双等号或三等号将NaN与NaN进行比较，结果为false，而Object.is（NaN，NaN）将为 true。

严格相等===

全等操作符比较两个值是否相等，两个被比较的值在比较前都不进行隐式转换。如果两个被比较的值具有不同的类型，这两个值是不全等的。否则，如果两个被比较的值类型相同，值也相同，并且都不是 number 类型时，两个值全等。最后，如果两个值都是 number 类型，当两个都不是 NaN，并且数值相同，或是两个值分别为 +0 和 -0 时，两个值被认为是全等的。

1 === '1' // false
+0 === -0 // true
NaN === NaN // false
null === null // true
undefined === undefined // true
Infinity === Infinity // true
+Infinity === -Infinity // false

let a = NaN
isNaN(a) // true
a === a // false, 唯一一个变量和自身不相等的，可用于判断一个变量是否是NaN

全等操作符认为 +0 和 -0 是全等的
全等操作符认为 NaN 与其他任何值都不全等，包括它自己(等式 (x !== x) 成立的唯一情况是 x 的值为 NaN)

非严格相等==

相等操作符比较两个值是否相等，在比较前将两个被比较的值转换为相同类型。在转换后（等式的一边或两边都可能被转换），最终的比较方式等同于全等操作符 === 的比较方式。相等操作符满足交换律。

相等操作符对于不同类型的值，进行的比较如下图所示：

	被比较值 B
		Undefined	Null	Number	String	Boolean	Object
被比较值 A	Undefined	`true`	`true`	`false`	`false`	`false`	`IsFalsy(B)`
	Null	`true`	`true`	`false`	`false`	`false`	`IsFalsy(B)`
	Number	`false`	`false`	`A === B`	`A === ToNumber(B)`	`A=== ToNumber(B)`	`A== ToPrimitive(B)`
	String	`false`	`false`	`ToNumber(A) === B`	`A === B`	`ToNumber(A) === ToNumber(B)`	`ToPrimitive(B) == A`
	Boolean	`false`	`false`	`ToNumber(A) === B`	`ToNumber(A) === ToNumber(B)`	`A === B`	ToNumber(A) == ToPrimitive(B)
	Object	false	false	`ToPrimitive(A) == B`	`ToPrimitive(A) == B`	ToPrimitive(A) == ToNumber(B)	`A === B`

在上面的表格中，ToNumber(A) 尝试在比较前将参数 A 转换为数字，这与 +A（单目运算符+）的效果相同。ToPrimitive(A)通过尝试调用 A 的A.toString() 和 A.valueOf() 方法，将参数 A 转换为原始值（Primitive）。

一般而言，根据 ECMAScript 规范，所有的对象都与 undefined 和 null 不相等。但是大部分浏览器允许非常窄的一类对象（即，所有页面中的 document.all 对象），在某些情况下，充当效仿 undefined 的角色。相等操作符就是在这样的一个背景下。因此，IsFalsy(A) 方法的值为 true ，当且仅当 A 效仿 undefined。在其他所有情况下，一个对象都不会等于 undefined 或 null。

通常情况下，任何对象和undefined和null都不相等，但是，存在一类窄对象，在某些情况下，充当效仿 undefined 的角色，在这样的条件下，就会出现对象等于undefined的情况，如：document.all，这和浏览器的发展史有关。

document.all[1] // <head>...</head>
document.all.length // 2377
typeof document.all // undefined
document.all == undefined // true
document.all === undefined // false

在这里插入图片描述

同值相等

确定两个值是否在任何情况下功能上是相同的。Object.is是同值相等算法的一种实现，该方法是ES6暴露出来的，ES5下并没有暴露出来。
同值相等算法下：

NaN 和 NaN，以及值为 NaN 的变量和他自身，相等
+0 和 -0 不相等

Object.is(NaN, NaN) // true
Object.is(+0, -0) // false
Object.is({}, {}) // false

// 向 Nmuber 构造函数添加一个不可变的属性 NEGATIVE_ZERO
Object.defineProperty(Number, "NEGATIVE_ZERO",{
  value: -0,
  writable: false,
  configurable: false,
  enumerable: false
});

Object.defineProperty(Number, "NEGATIVE_ZERO", { value: +0 });  // TypeError
Object.defineProperty(Number, "NEGATIVE_ZERO", { value: 0 });   // TypeError
Object.defineProperty(Number, "NEGATIVE_ZERO", { value: -0 });

零值相等

与同值相等类似，不过会认为 +0 与 -0 相等。

+0 === -0 // true

理解相等比较的模型

在 ES2015 以前，你可能会说双等和三等是“扩展”的关系。比如有人会说双等是三等的扩展版，因为他处理三等所做的，还做了类型转换。例如 6 == “6” 。反之另一些人可能会说三等是双等的扩展，因为他还要求两个参数的类型相同，所以增加了更多的限制。怎样理解取决于你怎样看待这个问题。

但是这种比较的方式没办法把 ES2015 的 Object.is 排列到其中。因为 Object.is 并不比双等更宽松，也并不比三等更严格，当然也不是在他们中间。从下表中可以看出，这是由于 Object.is 处理 NaN 的不同。注意假如 Object.is(NaN, NaN) 被计算成 false ，我们就可以说他比三等更为严格，因为他可以区分 -0 和 +0 。但是对 NaN 的处理表明，这是不对的。 Object.is 应该被认为是有其特殊的用途，而不应说他和其他的相等更宽松或严格。

判等
x	y	`==`	`===`	`Object.is`
`undefined`	`undefined`	`true`	`true`	`true`
`null`	`null`	`true`	`true`	`true`
`true`	`true`	`true`	`true`	`true`
`false`	`false`	`true`	`true`	`true`
`"foo"`	`"foo"`	`true`	`true`	`true`
`0`	`0`	`true`	`true`	`true`
`+0`	`-0`	`true`	`true`	`false`
`0`	`false`	`true`	`false`	`false`
`""`	`false`	`true`	`false`	`false`
`""`	`0`	`true`	`false`	`false`
`"0"`	`0`	`true`	`false`	`false`
`"17"`	`17`	`true`	`false`	`false`
`[1,2]`	`"1,2"`	`true`	`false`	`false`
`new String("foo")`	`"foo"`	`true`	`false`	`false`
`null`	`undefined`	`true`	`false`	`false`
`null`	`false`	`false`	`false`	`false`
`undefined`	`false`	`false`	`false`	`false`
`{ foo: "bar" }`	`{ foo: "bar" }`	`false`	`false`	`false`
`new String("foo")`	`new String("foo")`	`false`	`false`	`false`
`0`	`null`	`false`	`false`	`false`
`0`	`NaN`	`false`	`false`	`false`
`"foo"`	`NaN`	`false`	`false`	`false`
`NaN`	`NaN`	`false`	`false`	`true`

Object.is实现

Object.myIs = function (a, b) {
  if (a === b) {
	return a !== 0 || 1 / a === 1 / b
  }

  return a !== a && b !== b
}

falsy值：8个

false
0
+0 、 -0
0n // BigInt
“” 、’’ 、``
null
undefined
NaN

名词解释：

ECMA 262

ECMAScript标准

IEEE 754

IEEE二进制浮点数算术标准（IEEE 754）是20世纪80年代以来最广泛使用的浮点数运算标准，为许多CPU与浮点运算器所采用。这个标准定义了表示浮点数的格式（包括负零-0）与反常值（denormal number）），一些特殊数值（无穷（Inf）与非数值（NaN）），以及这些数值的“浮点数运算符”

周晓风

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JavaScript中的相等性判断

ES2015中有四种相等算法：严格相等 ===非严格相等 ==同值相等零值相等JavaScript提供三种不同的值比较操作：严格相等比较 ==> Strict Equality，使用 ===抽象相等比较 ==> Loose Equality，使用 ==Object.is （ECMAScript 2015/ ES6 新特性）判断两个参数是否是同一个值简而言之，在比较两个对象时:双等号将执行类型转换;三等号将进行相同的比较，而不进行类型转换 (如果类型不同, 只是总会
复制链接

扫一扫