脑壳疼 JS 中令人脑壳疼的 == 与 === 区别到底是什么？ 4字节 4字节 今天

对我来说，平等就是平等，所以第一次接触JS中的三个等号就很迷茫。大多数编程语言都有双等号“= =”，但没有三等号“= = =”。

以下是双等号和三等号之间更正式的区别:

“如果需要判断操作数是否同类型，值是否相等，使用严格相等运算符[= = =]。

否则，使用标准的等式运算符[= =]，它允许您比较两个操作数的值，即使它们是不同的类型。"

- MDN网络文档

认为理解它的关键在于理解“类型转换”，这是“动态类型语言”香草Java中的一个奇怪概念。

之所以有类型转换，是因为JS希望防止编程错误，例如将数字与字符串进行比较:

“在Java中使用双等号时，我们是在测试不精确的等式。双等号也带来了类型转换。

强制转换意味着操作数只有在转换为相同类型时才能进行比较。"

换句话说，由于类型转换，不同类型的值可以通过= =进行比较，但是字符串和数字永远不会通过= = =严格相等。

例如:

console . log(Number(" 7 ")-7 = = 0)；// true

console . log(Number(" 7 ")-7 = = = 0)；// true

console . log(Number(" 7 ")-7 = = = Number(" 0 "))；// true

console . log(" 7 "-7 = = " 0 ")；// true

console . log(" 7 "-7 = = " 0 ")；// false

Java中的真与假

在Java中，我们有六个false值:false、0，“”(空 string)、null、undefined和NaN(不是数字)。这六个伪值有什么关系？

将false、0和“”与(= =)进行比较，结果为真，且不严格相等；Null和undefined只等于它们自己；NaN不等于任何假值，包括它本身。”

Derek Austin博士对Java中错误比较的所有排列

console . log(false = = false)；// true

console . log(false = = = false)；// true

console . log(false = = 0)；// true - false，0和“”大致相等

console . log(false = = = 0)；// false

console . log(false = = " ")；// true - false，0和“”大致相等

console . log(false = = " ")；// false

console . log(false = = null)；// false

console . log(false = = = null)；// false

console . log(false = = undefined)；// false

console . log(false = = = undefined)；// false

console . log(false = = NAn)；// false

console . log(false = = = NAn)；// false

console . log(0 = = 0)；// true

console . log(0 = = = 0)；// true

console . log(0 = = " ")；// true - false，0和“”大致相等

console . log(0 = = " ")；// false

console . log(0 = = null)；// false

console . log(0 = = = null)；// false

console . log(0 = = undefined)；// false

console.log(0 ===未定义)；// false

console . log(0 = = NAn)；// false

console . log(0 = = = NAn)；// false

console . log(“= =”)；// true

console . log(" = = " = " ")；// true

console . log(" = = = null)；// false

console . log(" = = " = null)；// false

console . log(" = " =未定义)；// false

console . log(" = = = undefined)；// false

console . log(" = " = NAn)；// false

console . log(" = = " = NAn)；// false

console . log(null = = null)；// true

console . log(null = = = null)；// true

console . log(null = = undefined)；// true - null大致等于未定义

console.log(null ===未定义)；// false

console . log(null = = NAn)；// false

console . log(null = = = NAn)；// false

console . log(undefined = = undefined)；// true

console . log(undefined = = = undefined)；// true

console . log(undefined = = NAn)；// false

console . log(undefined = = = NAn)；// false

console . log(NAn = = NAn)；// false - NaN不等于NaN，并且

console . log(NAn = = = NAn)；// false - NaN不等于自身

JS中的假值虽然这么精彩，但幸运的是，除了这些假值以外的所有值都是真的:

在Java中，真值是在布尔类型的上下文中被认为是“真”的所有值。除非定义为false，否则所有值都为true，例如false、0、“”、null、undefined和NaN。

ECMA怎么样？

如果有兴趣，下面是Java使用的具体算法。

严格相等运算符

严格相等运算符(= = = and！= =)使用严格的等式比较算法来比较两个操作数:

11.9.6严格相等比较算法

当比较x===y，x和y为值时，表达式返回true或false，表达式执行如下:

1.如果类型(x)和类型(y)不同，则返回false。

2.如果类型(x)未定义，则返回真。

3.如果类型(x)为空，返回真。

4.如果类型(x)是一个数字，那么

→ a .如果x是NaN，则返回false。

→ B .如果y是NaN，则返回false。

→ C .如果x和y的数值相等，则返回true。

→ D .如果x为+0，y为0，则返回true。

→ e .如果x为0，y为+0，则返回true。

→ F .返回false。

5.如果Type(x)是字符串，如果X和Y中的字符序列完全相同(长度相同，字符位置相同)，则返回true；否则，返回false。

6.如果类型(x)是布尔型，如果x和y都为真或假，则返回真；否则，返回false。

7.如果X和Y引用同一个对象，返回true；否则，返回false。

注-这个算法d如果FERS从相同的价值算法(9.12)在其处理有符号的零和南数。

标准等式运算符

标准等式运算符(= =和！=)使用抽象等式比较算法来比较两个操作数:

11.9.3抽象等式比较算法(抽象等式比较算法)

Compare x == y，x和y是值，表达式返回true或false。表达式执行如下:

1.如果类型(x)与类型(y)相同，则

→ a .如果类型(x)未定义，返回真。

→ B .如果类型(x)为空，则返回真。

→如果类型(x)是一个数字，那么

→→→ i .如果x是NaN，则返回false。

→→→ ii。如果y是NaN，则返回false。

→→→ iii。如果x和y的数值相等，则返回true。

→→→ iv。如果x为+0，y为0，则返回true。

→→→ v .如果x为0，y为+0，则返回true。

→ → vi。返回false。

→ D .如果Type(x)是字符串，如果x和y中的字符序列完全相同(长度相同，字符位置相同)，则返回true；否则，返回false。

→ e .如果Type(x)为boolean，如果x和y都为true或false，则返回true；否则，返回false。

→ F .如果x和y指的是同一个对象，返回true；否则，返回false。

2.如果x为null，y未定义，则返回true。

3.如果x未定义，y为空，则返回true。

4.如果类型(x)是数字，类型(y)是字符串，则返回x == ToNumber(y)的结果。

5.如果类型(x)是字符串，类型(y)是数字，则返回数字(x)= y的结果。

6.如果类型(x)是布尔值，则返回数字(x)= y的结果。

7.如果类型(y)是布尔值，则返回x == ToNumber(y)的结果。

8.如果类型(x)是数字或字符串，类型(y)是对象，则返回x == ToPrimitive(y)的结果。

9.如果类型(x)是对象，类型(y)是数字或字符串，则返回Toprimitive(x)= y的结果。

10.返回false。

注1——鉴于上述平等的定义:

字符串比较可以通过以下方式强制进行:“+ a == "" + b”。

可以通过以下方式强制进行数值比较:+a == +b。

布尔比较可以通过以下方式强制执行:！a ==！b.

注2 —等式运算符维护以下不变量:

答！= B相当于！(A == B)。

A == B相当于B == A，除了A和B的求值顺序

注3:等式运算符不总是可传递的。例如，可能有两个不同的字符串对象，每个对象代表相同的字符串值；通过==运算符，每个字符串对象将被视为等于字符串值，但是这两个字符串对象并不相等。例如:

新字符串(“a”)= =“a”和“a”= =新字符串(“a”)均为真。

新字符串(“a”)= =新字符串(“a”)为假。

注4:字符串比较对代码单元值序列使用简单的相等性测试。没有尝试使用在unicode规范中定义的更复杂的、面向语义的字符或字符串相等性和排序顺序的定义。根据Unicode标准，哪些是标准相等的，哪些是不相等的。实际上，该算法假设两个字符串都已经是规范化形式。

结论

一般来说我更喜欢用= = =和！= =，除非必须使用= =和！=，如检查空的值。

此外，在检查空的值时，请记住，与双等号相比，null和undefined是相等的。