JavaScript - 比较运算符

JavaScript 比较运算符

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

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

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

JavaScript 中有八种比较运算符，用于执行不同类型的比较。这里，我们提供了一个表格，并附上示例解释了每个比较运算符。

如何进行比较?

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

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

• 如果字符串仅包含数字值，则会转换为数字类型。

• 如果字符串还包含非数字值，则会转换为 NaN。

• 如果字符串为空，则会转换为零。

严格相等运算符 (===) 和严格不等运算符 (!==) 执行严格比较。这些运算符在执行比较操作之前不会执行类型转换。

处理假值

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

• 0(零)
• false
• ' ' 或 " '(空字符串)
• null
• undefined
• NaN

所有比较运算符(除了 === 和 !==)在执行比较之前都会将 false 和空字符串转换为零。

除上述运算符外，小于和大于运算符(以及 >=)会将 null 转换为零，将 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。这里字符串被转换为数字类型。在第二个示例中，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。

换句话说，它检查操作数的相等性，而不进行类型转换。如果操作数的类型不同，则返回 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; //返回 false
10 !== 20; //返回 true
'Hello'!=='Hello'; //返回 false
10 !== '10'; //返回 true
0 !== false; //返回 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 小于或等于 (<=) 运算符

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

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; // 返回 false
0 == undefined; // 返回 false
0 == NaN; // 返回 false

null 和 undefined 是等价的。

null == undefined; // 返回 true
null === undefined; // 返回 false

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

NaN == NaN; // 返回 false