JS判断相等或者不等于（==、===、!=、!==）运算符

╰+哭是因爲堅強的太久メ 2024-03-31 10:22 5阅读 0赞

等值检测运算符包括 4 个，详细说明如表所示。

<table> 
 <thead> 
  <tr> 
   <th>等值检测运算符</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==（相等）</td> 
   <td>比较两个操作数的值是否相等</td> 
  </tr> 
  <tr> 
   <td>!=（不想等）</td> 
   <td>比较两个操作数的值是否不相等</td> 
  </tr> 
  <tr> 
   <td>===（全等）</td> 
   <td>比较两个操作数的值是否相等，同时检测它们的类型是否相同</td> 
  </tr> 
  <tr> 
   <td>!==（不全等）</td> 
   <td>比较两个操作数的值是否不相等，同时检测它们的类型是否不相同</td> 
  </tr> 
 </tbody> 
</table>

在相等运算中，应注意以下几个问题：

*  如果操作数是布尔值，则先转换为数值，其中 false 转为 0，true 转换为 1。
 *  如果一个操作数是字符串，另一个操作数是数字，则先尝试把字符串转换为数字。
 *  如果一个操作数是字符串，另一个操作数是对象，则先尝试把对象转换为字符串。
 *  如果一个操作数是数字，另一个操作数是对象，则先尝试把对象转换为数字。
 *  如果两个操作数都是对象，则比较引用地址。如果引用地址相同，则相等；否则不等。

示例1

下面是特殊操作数的相等比较。

> 1.  `console.log("1" == 1); //返回true。字符串被转换为数字`
> 2.  `console.log(true == 1); //返回true。true被转换为1`
> 3.  `console.log(false == 0); //返回true。false被转换为0`
> 4.  `console.log(null == 0); //返回false`
> 5.  `console.log(undefined == 0); //返回false`
> 6.  `console.log(undefined == null); //返回true`
> 7.  `console.log(NaN == "NaN"); //返回false`
> 8.  `console.log(NaN ==1); //返回false`
> 9.  `console.log(NaN == NaN); //返回false`
> 10. `console.log(NaN != NaN); //返回true`

NaN与任何值都不相等，包括它自己。null 和 undefined 值相等，但是它们是不同类型的数据。在相等比较中，null 和 undefined 不允许被转换为其他类型的值。

示例2

下面两个变量的值是相等的。

> 1.  `var a = "abc" + "d";`
> 2.  `var b = "a" + "bcd";`
> 3.  `console.log(a == b); //返回true`

数值和布尔值的相等比较运算效率比较高，而字符串需要逐个字符进行比较，相等比较运算效率比较低。

在全等运算中，应注意以下几个问题：

*  如果两个操作数都是简单的值，则只要值相等，类型相同，就全等。
 *  如果一个操作数是简单的值，另一个操作数是复合型对象，则不全等。
 *  如果两个操作数都是复合型对象，则比较引用地址是否相同。

示例3

下面是特殊操作数的全等比较。

> 1.  `console.log(null === undefined); //返回false`
> 2.  `console.log(0 === "0"); //返回false`
> 3.  `console.log(0 === false); //返回false`

示例4

下面是两个对象的比较，由于它们都引用了相同的地址，所以返回 true。

> 1.  `var a = {};`
> 2.  `var b = a;`
> 3.  `console.log(a === b); //返回true`

下面两个对象虽然结构相同，但是地址不同，所以不全等。

> 1.  `var a = {};`
> 2.  `var b = {};`
> 3.  `console.log(a === b); //返回false`

示例5

对于复合型对象，主要比较引用的地址，不比较对象的值。

> 1.  `var a = new String("abcd); //定义字符串“abcd”对象`
> 2.  `var b = new String("abcd); //定义字符串“abcd”对象`
> 3.  `console.log(a === b); //返回false`
> 4.  `console.log(a == b); //返回false`

在上面示例中，两个对象的值相等，但是引用地址不同，所以它们既不想等，也不全等。因此，对于复合型对象来说，相等`==`和全等`===`运算的结果是相同的。

示例6

对于简单的值，只要类型相同、值相等，它们就是全等，不考虑表达式运算的过程变化，也不用考虑变量的引用地址。

> 1.  `var a = "1" + 1;`
> 2.  `var b = "11";`
> 3.  `console.log(a ===b); //返回true`

示例7

表达式（a>b || a==b）与表达式（a>=b）并不完全相等。

> 1.  `var a = 1;`
> 2.  `var b = 2;`
> 3.  `console.log((a > b || a == b) == (a >= b)); //返回true，此时似乎相等`

如果为变量 a 和 b 分别赋值 null 和 undefined，则返回值 false，说明这两个表达式并非完全等价。

> 1.  `var a = null;`
> 2.  `var b = undefined;`
> 3.  `console.log((a > b || a == b) == (a >= b)); //返回false，表达式的值并非相等`

因为 null == undefined 等于 true，所以表达式（a > b || a == b）的返回值为 true，但是表达式 null >= undefined 的返回值为 false。