重新回顾JS的笔记系列(三)

1.基础运算符

基础运算符包括有：+、-、*、/、%(取余)、**（求幂）

按照数学上的计算方法来使用就可以了。

• 特殊用法1—用二元运算符+来连接字符串

示例：

let s = "my" + "string";
alert(s); // mystring

//注意，此处的加法如果其中一个是字符串，那么在运算之后就会将整个式子全部转成一串字符串。
alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"
alert(2 + 2 + '1' ); // "41"，不是 "221"
alert('1' + 2 + 2); // "122"，不是 "14"

//此外在二元运算符当中，只有+会触发这种形式，其余都不会
alert( 6 - '2' ); // 4，将 '2' 转换为数字
alert( '6' / '2' ); // 3，将两个运算元都转换为数字

• 特殊用法2—使用一元运算符+来进行数字转化

// 转化非数字,效果类似 number()
alert( +true ); // 1
alert( +"" );   // 0

//这个方法可以用来改善特殊用法1中的转化字符串
//示例：
let apples = "2";
let oranges = "3";

alert( apples + oranges ); // "23"，二元运算符加号合并字符串

let apples = "2";
let oranges = "3";

// 在二元运算符加号起作用之前，所有的值都被转化为了数字
alert( +apples + +oranges ); // 5

2.运算符优先级

存在规则：

• 一元优先级大于二元优先级
• 数字越大，越先执行

3.自增、自减

示例：

let counter = 2;
counter++;      // 和 counter = counter + 1 效果一样，但是更简洁
alert( counter ); // 3
counter--;      // 和 counter = counter - 1 效果一样，但是更简洁
alert( counter ); // 2

• 不同形式的自增自减：

​ 当运算符置于变量后，被称为“后置形式”：counter++。

​ 当运算符置于变量前，被称为“前置形式”：++counter。

（自增的优先级高于绝大多数的运算符）

示例：

let counter = 1;
alert( 2 * ++counter ); // 4

let counter = 1;
alert( 2 * counter++ ); // 2，因为 counter++ 返回的是“旧值”

4.位运算符（使用的频率比较低）

• 按位与 ( & )
• 按位或 ( | )
• 按位异或 ( ^ )
• 按位非 ( ~ )
• 左移 ( << )
• 右移 ( >> )
• 无符号右移 ( >>> )

5.值的比较

• 基本编写方式如下：

​ [1] 大于 / 小于：a > b，a < b。

​ [2] 大于等于 / 小于等于：a >= b，a <= b。

​ [3] 检查两个值的相等：a == b，请注意双等号 == 表示相等性检查，而单等号 a = b 表示赋值。

​ [4] 检查两个值不相等：不相等在数学中的符号是 ≠，但在 JavaScript 中写成 a != b。

• 注意，比较后返回的结果是 Boolean 类型

示例：

alert( 2 > 1 );  // true（正确）
alert( 2 == 1 ); // false（错误）
alert( 2 != 1 ); // true（正确）

6.字符串的比较

注意，在JS当中，JS会按照从前往后的顺序来比较字符。

换言之，字符串是按字符（母）逐个进行比较的。

示例：

alert( 'Z' > 'A' ); // true
alert( 'Glow' > 'Glee' ); // true
alert( 'Bee' > 'Be' ); // true

比较的方法如下：

1. 首先比较两个字符串的首位字符大小。
2. 如果一方字符较大（或较小），则该字符串大于（或小于）另一个字符串。算法结束。
3. 否则，如果两个字符串的首位字符相等，则继续取出两个字符串各自的后一位字符进行比较。
4. 重复上述步骤进行比较，直到比较完成某字符串的所有字符为止。
5. 如果两个字符串的字符同时用完，那么则判定它们相等，否则未结束（还有未比较的字符）的字符串更大。

7.不同类型之间的比较

当对不同类型的值进行比较时，JavaScript 会首先将其转化为数字（number）再判定大小。

例如：

alert( '2' > 1 ); // true，字符串 '2' 会被转化为数字 2
alert( '01' == 1 ); // true，字符串 '01' 会被转化为数字 1

对于布尔类型值，true 会被转化为 1、false 转化为 0。

例如：

alert( true == 1 ); // true
alert( false == 0 ); // true

8.严格相等

普通的相等性检查 == 存在一个问题，它不能区分出 0 和 false：

alert( 0 == false ); // true

也同样无法区分空字符串和 false：

alert( '' == false ); // true

为了区分两者，这里采用了===来进行区别（原理为：===在进行比较的时候是不会进行类型转化的）

alert( 0 === false ); // false，因为被比较值的数据类型不同

同样的，与“不相等”符号 != 类似，“严格不相等”表示为 !==。

• 特殊情况：

一、对 null 和 undefined 进行比较

1. 当使用严格相等 === 比较二者时，它们不相等，因为它们属于不同的类型。

2. 当使用非严格相等 == 比较二者时，会判定它们相等。

注意：当使用数学式或其他比较方法 < > <= >= 时：

null/undefined 会被转化为数字：null 被转化为 0，undefined 被转化为 NaN。

比较 null 和 0 可得：

alert( null > 0 );  // (1) false
alert( null == 0 ); // (2) false
alert( null >= 0 ); // (3) true

是的，上面的结果完全打破了你对数学的认识。在最后一行代码显示“null 大于等于 0”的情况下，前两行代码中一定会有一个是正确的，然而事实表明它们的结果都是 false。

为什么会出现这种反常结果，这是因为相等性检查 == 和普通比较符 > < >= <= 的代码逻辑是相互独立的。进行值的比较时，null 会被转化为数字，因此它被转化为了 0。这就是为什么（3）中 null >= 0 返回值是 true，（1）中 null > 0 返回值是 false。

另一方面，undefined 和 null 在相等性检查 == 中不会进行任何的类型转换，它们有自己独立的比较规则，所以除了它们之间互等外，不会等于任何其他的值。这就解释了为什么（2）中 null == 0 会返回 false。

undefined 不应该被与其他值进行比较：

alert( undefined > 0 ); // false (1)
alert( undefined < 0 ); // false (2)
alert( undefined == 0 ); // false (3)

为何它看起来如此厌恶 0？返回值都是 false！

原因如下：

• (1) 和 (2) 都返回 false 是因为 undefined 在比较中被转换为了 NaN，而 NaN 是一个特殊的数值型值，它与任何值进行比较都会返回 false。
• (3) 返回 false 是因为这是一个相等性检查，而 undefined 只与 null 相等，不会与其他值相等。

Last modified on 2023-03-03