JavaScript - 比较运算符

JavaScript 比较运算符

JavaScript 比较运算符比较两个变量或值，并根据比较结果返回布尔值 true 或 false。例如，我们可以使用比较运算符来检查两个操作数是否相等。

比较运算符用于逻辑表达式。逻辑表达式的计算结果为 true 或 false。

比较运算符是二元运算符，因为它们对两个操作数执行操作。操作数可以是数值、字符串、逻辑或对象值。

JavaScript 中有 8 个比较运算符来执行不同类型的比较。在这里，我们给出了一个表格，通过示例解释了每个比较运算符。

运算符	描述	示例
==	等于	x == y
!=	不等于	x != y
===	严格相等（相等值和相等类型）	x === y
!==	严格不等式（不等于值或不等于类型）	x !== y
>	大于	x > y
<	小于	x < y<
>=	大于或等于	x >= y
<=	小于或等于	x <= y

如何进行比较？

如果两个操作数的类型相同，则比较运算符将比较值。但是，如果操作数是不同的类型，JavaScript 会执行适当的类型转换以进行比较。这称为类型强制转换。

如果两个操作数都是数字，则通过检查操作数的数值来进行比较。使用 Unicode 值根据字典顺序对字符串进行比较。当将字符串与数字进行比较时，将执行以下类型的强制转换。

如果字符串仅包含数值，则转换为 number 类型。
如果字符串也包含非数字值，则它将被转换为 NaN。
如果 string 为空，则将其转换为 0。

严格相等（===）和严格不等式（！==）运算符执行严格比较。这些运算符在执行比较操作之前不执行类型转换。

处理假值

JavaScript 中存在一些假值。JavaScript 在执行比较时以不同的方式处理这些假值。以下是 flasy 值 -

0 (zero)
false
' ' or " " (Empty String)
null
undefined
NaN

在执行比较之前，所有比较运算符（=== 和！== 除外）都会将 false 和空字符串转换为 0。

除上述运算符外，小于（<）和大于（>）运算符（<、<=、>、>=）将 null 转换为 0，将 undefined 转换为 NaN。

JavaScript 相等（==）运算符

“等于”运算符检查两个操作数的值是否相等。如果操作数相等，则返回 true，否则返回 false。如果操作数是不同的类型，它将执行类型转换，然后比较操作数。

让我们看一些没有类型转换的比较示例。这两个操作数属于同一类型。


const a = 10;
const b = 20;
a == 10; //true
a == b; // false	
"Hello" == "Hello"; // true

现在让我们看一些与类型转换进行比较的示例。这里的操作数是不同的类型。


5 == '5'; // true
0 == false; // true
0 == ''; // true

在上面的第一个示例中，'5' 被转换为 5（字符串到数字的转换）。在比较之前，false 和空字符串（' '）将转换为零（0）。

例

以下代码显示了如何在 JavaScript 中使用相等运算符 -


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a == b);
	 document.getElementById("output").innerHTML = "(a == b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

JavaScript 不等式（！=）运算符

“不等式” 运算符检查两个操作数的值是否不相等。如果操作数不相等，则返回 true，否则返回 false。与相等运算符相同，如果操作数不是同一类型，则执行类型转换。

在下面的示例中，将比较两个相同类型的值以进行不等式检查。如果值不相等，则不等运算符将返回 true。


10 != 10; // false
10 != 20; // true
"Hello" != "Hello"; // false

当操作数是不同类型的时，让我们检查一下是否相等


10 != '10'; // false
0 != false; // false

在第一个例子中，'10' 是强制转换为 10 的类型。这里 string 被转换为 number 类型。在第二个示例中，false （布尔值）转换为 0 （数字）。

例

以下代码演示如何在 JavaScript 中使用不等运算符。


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a != b);
	 document.getElementById("output").innerHTML = "(a != b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

JavaScript 严格相等（===）运算符

“严格等于” 运算符检查两个操作数的值和数据类型是否相等。如果两个操作数相等且类型相同，则返回 true。

换句话说，它检查操作数的相等性，而不进行类型转换。如果操作数是不同的类型，则返回 false，而不进一步检查值。


10 === 10; // true
10 === 20; // false
'Hello'==='Hello'; // true
10 === '10'; // false
0 === false; // false

例

以下代码演示如何在 JavaScript 中使用严格相等运算符。


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a === b);
	 document.getElementById("output").innerHTML = "(a === b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

严格不等式（！==）运算符

“严格不等式”运算符检查两个操作数的值或类型是否相等。如果操作数的类型相同但不相等或类型不同，则返回 true。

与严格相等运算符相同，它也首先检查操作数的不相等性，而不进行类型转换。如果操作数是不同的类型，它将返回 true，而无需进一步检查值。


10 !== 10; //returns false
10 !== 20; // returns true
'Hello'!=='Hello'; // returns false
10 !== '10'; //return true
0 !== false; //returns true

例

以下代码演示如何在 JavaScript 中使用严格不等运算符。


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a !== b);
	 document.getElementById("output").innerHTML = "(a !== b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

JavaScript 大于（>）运算符

“大于”运算符检查左操作数的值是否大于右操作数的值。如果是，则返回 true，否则返回 false。


20 > 10; // true
10 > 10; // false
"ab" > "aa"; // true
10 > '5'; // true

例

以下代码显示了如何在 JavaScript 中使用大于运算符 -


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a > b);
	 document.getElementById("output").innerHTML = "(a > b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

大于或等于（>=）运算符

“大于或等于”运算符检查左操作数的值是否大于或等于右操作数的值。如果是，则返回 true，否则返回 false。


10 >= 5; // true
5 >= 5; // true
"ab" >= "aa"; // true
10 >= '5'; // true

例

以下代码演示如何在 JavaScript 中使用大于或等于运算符。


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a >= b);
	 document.getElementById("output").innerHTML = "(a >= b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

JavaScript 小于（<）运算符

如果左操作数的值小于右操作数的值，则“小于运算符”返回 true，否则返回 false。


10 < 20; // true
5 < 5; // false
"ab" < "aa"; // true
10 < '5'; // false

例

以下代码显示了如何在 JavaScript 中使用小于运算符 -


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a < b);
	 document.getElementById("output").innerHTML = "(a < b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

JavaScript 小于或等于（<=）运算符

小于或等于运算符检查左操作数的值是否小于或等于右操作数的值。如果是，则条件变为 true。


10 <= 20; // true
5 <= 5; // true
"ab" <= "aa"; // false
10 <= '5'; // false

例

以下代码显示了如何在 JavaScript 中使用小于或等于运算符 -


<html>
<body>
<div id="output"></div>
<script>
	 const a = 10;
	 const b = 20;
	 let result = (a <= b);
	 document.getElementById("output").innerHTML = "(a <= b) => " + result;
</script>
<p> Set the variables to different values and then try...</p>
</body>
</html>

比较 null、undefined 和 NaN

在 JavaScript 中，null、undefined 和 NaN 是未转换为零（0）进行比较的假值。


0 == null; // returns false
0 == undefined; // returns false
0 == NaN; // returns false

null 和 undefined 的周相等。


null == undefined; // returns true
null === undefined; // returns false

NaN 的类型是 number，但它不等于零。有趣的是，NaN 并不等于 NaN 本身。


 NaN == NaN; // returns false

本页

JavaScript - 比较运算符