JavaScript运算符三、JavaScript运算符 3.1 运算元在JavaScript中，运算元（Operan

三、`JavaScript`运算符

3.1 运算元

在JavaScript中，运算元（Operand）是指在运算符（Operator）操作时被操作的值或变量。运算元可以是任何有效的JavaScript数据类型，包括数字、字符串、布尔值、对象等。以下是一些关于运算元的基本概念：

运算符的分类

运算符根据其功能可以分为不同的类型：

算术运算符：用于进行数学运算。
- 示例：+（加）、-（减）、*（乘）、/（除）、%（取模）。
- 运算元示例：
```
let a = 5;
let b = 3;
let sum = a + b; // a 和 b 是运算元
```
比较运算符：用于比较两个值并返回布尔值。
- 示例：==（相等）、===（严格相等）、!=（不相等）、!==（严格不相等）、>（大于）、<（小于）。
- 运算元示例：
```
let isEqual = (a == b); // a 和 b 是运算元
```
逻辑运算符：用于执行逻辑运算。
- 示例：&&（与）、||（或）、!（非）。
- 运算元示例：
```
let result = (a > 0 && b < 10); // a 和 b 是运算元
```
位运算符：用于对整数的位进行操作。
- 示例：&（按位与）、|（按位或）、^（按位异或）、~（按位非）。
- 运算元示例：
```
let bitwiseAnd = a & b; // a 和 b 是运算元
```
赋值运算符：用于将值赋给变量。
- 示例：=（赋值）、+=（加赋值）、-=（减赋值）。
- 运算元示例：
```
a += b; // a 和 b 是运算元，a 是被赋值的变量
```

运算元的类型

运算元可以是以下类型：

基本数据类型：
- 数字（Number）
- 字符串（String）
- 布尔值（Boolean）
引用数据类型：
- 对象（Object）
- 数组（Array）
- 函数（Function）

示例

下面是一些使用运算元的示例：

let x = 10;
let y = 20;

// 算术运算
let sum = x + y; // x 和 y 是运算元

// 比较运算
let isGreater = x > y; // x 和 y 是运算元

// 逻辑运算
let isValid = (x > 5 && y < 25); // x 和 y 是运算元

// 字符串拼接
let greeting = "Hello, " + "World!"; // "Hello, " 和 "World!" 是运算元

总结:运算元是进行计算或操作的基础部分，可以是任意类型的数据

3.2 算数运算符

算术运算符是JavaScript中用于进行数学计算的运算符。以下是常用的算术运算符及其用法：

1. 加法运算符 (+)

用于计算两个数的和。如果操作数是字符串，则执行字符串拼接。

let sum = 5 + 3;          // 输出: 8
let concatenation = "Hello, " + "World!"; // 输出: "Hello, World!"

2. 减法运算符 (-)

用于计算两个数的差。

let difference = 10 - 4; // 输出: 6

3. 乘法运算符 (*)

用于计算两个数的乘积。

let product = 7 * 6;     // 输出: 42

4. 除法运算符 (/)

用于计算两个数的商。如果除数为零，结果为Infinity或-Infinity。

let quotient = 20 / 4;   // 输出: 5
let divisionByZero = 5 / 0; // 输出: Infinity

5. 取模运算符 (%)

返回两个数相除的余数。

let remainder = 10 % 3;  // 输出: 1

6. 自增运算符 (++)

将变量的值增加1，可以是前置或后置形式。

前置自增：在使用前先增加值。
后置自增：在使用后增加值。

let a = 5;
let preIncrement = ++a; // a 先加1，输出: 6
let postIncrement = a++; // a 先用后加1，输出: 6
console.log(a);         // 输出: 7

7. 自减运算符 (--)

将变量的值减少1，形式与自增运算符相同。

let b = 5;
let preDecrement = --b; // b 先减1，输出: 4
let postDecrement = b--; // b 先用后减1，输出: 4
console.log(b);         // 输出: 3

计算优先级

算术运算符遵循优先级规则，乘法和除法优先于加法和减法。可以使用括号改变优先级。

let result = 2 + 3 * 4;  // 输出: 14（先计算 3 * 4）
let resultWithParentheses = (2 + 3) * 4; // 输出: 20

总结:算术运算符是进行数学计算的基本工具，掌握它们的用法对于编写有效的JavaScript代码非常重要

3.3 赋值运算符

赋值运算符用于将值赋给变量。在JavaScript中，最基本的赋值运算符是=，但还有一些复合赋值运算符可以同时进行赋值和其他运算。以下是常用的赋值运算符及其用法：

1. 基本赋值运算符 (=)

将右侧的值赋给左侧的变量。

let x = 5; // 将 5 赋值给 x

2. 加赋值运算符 (+=)

将右侧的值加到左侧的变量，并将结果赋给左侧的变量。

let a = 10;
a += 5; // 等同于 a = a + 5，结果是 15

3. 减赋值运算符 (-=)

将右侧的值从左侧的变量中减去，并将结果赋给左侧的变量。

let b = 10;
b -= 3; // 等同于 b = b - 3，结果是 7

4. 乘赋值运算符 (*=)

将左侧的变量与右侧的值相乘，并将结果赋给左侧的变量。

let c = 4;
c *= 3; // 等同于 c = c * 3，结果是 12

5. 除赋值运算符 (/=)

将左侧的变量除以右侧的值，并将结果赋给左侧的变量。

let d = 20;
d /= 4; // 等同于 d = d / 4，结果是 5

6. 取模赋值运算符 (%=)

将左侧的变量与右侧的值进行取模运算，并将结果赋给左侧的变量。

let e = 10;
e %= 3; // 等同于 e = e % 3，结果是 1

7. 幂赋值运算符 (**=)

将左侧的变量进行幂运算，并将结果赋给左侧的变量（ES2016引入）。

let f = 2;
f **= 3; // 等同于 f = f ** 3，结果是 8

总结:赋值运算符在JavaScript中非常重要，用于给变量赋值并执行常见的数学运算。

3.4 链式赋值

链式赋值（Chained Assignment）是指在一行代码中使用多个赋值运算符，将相同的值依次赋给多个变量。链式赋值的实现依赖于赋值运算符的右结合性，即从右往左进行赋值操作。

链式赋值的语法

在链式赋值中，多个变量通过赋值运算符（=）连接，最终会将右侧的值依次赋给所有左侧的变量。例如：

let a, b, c;
a = b = c = 10;
console.log(a); // 输出: 10
console.log(b); // 输出: 10
console.log(c); // 输出: 10

链式赋值的工作原理

在链式赋值 a = b = c = 10 中，赋值操作从右到左依次执行：

c = 10，将 10 赋值给 c，并返回 10 作为结果。
b = 10，将 10 赋值给 b，并返回 10 作为结果。
a = 10，将 10 赋值给 a，并返回 10 作为最终结果。

这样，a、b 和 c 都会获得相同的值 10。

链式赋值的应用场景

链式赋值可以用于初始化多个变量为相同的值，在代码中简化对多个变量的赋值操作。

注意事项

值共享：链式赋值中各变量共享一个值，如果该值是引用类型（如对象或数组），它们将指向同一个内存地址。
```
let x = y = z = { name: "Alice" };
x.name = "Bob";
console.log(y.name); // 输出: "Bob"（因为x、y和z指向同一个对象）
```
可读性：链式赋值简化了代码，但可能影响可读性，建议在确保逻辑清晰时使用。

总结:链式赋值是一种便捷的赋值操作，用于让多个变量同时获得相同的值。

3.5 自增和自减

自增（++）和自减（--）运算符是JavaScript中的一元算术运算符，用于对变量的值进行增减1。自增和自减有前置（前缀）和后置（后缀）两种形式。

1. 自增运算符 (++)

自增运算符将变量的值加1。

前置自增（++x）

在前置自增中，变量的值会先加1，然后再返回新的值。

let x = 5;
let result = ++x; // x 先加1，x 变为 6，然后返回 x 的新值
console.log(result); // 输出: 6
console.log(x);      // 输出: 6

后置自增（x++）

在后置自增中，变量的值先返回，然后再加1。

let y = 5;
let result = y++; // y 的原值返回，然后 y 加1
console.log(result); // 输出: 5
console.log(y);      // 输出: 6

2. 自减运算符 (--)

自减运算符将变量的值减1。

前置自减（--x）

在前置自减中，变量的值会先减1，然后再返回新的值。

let a = 5;
let result = --a; // a 先减1，a 变为 4，然后返回 a 的新值
console.log(result); // 输出: 4
console.log(a);      // 输出: 4

后置自减（x--）

在后置自减中，变量的值先返回，然后再减1。

let b = 5;
let result = b--; // b 的原值返回，然后 b 减1
console.log(result); // 输出: 5
console.log(b);      // 输出: 4

注意事项

前置和后置的差异：前置自增/自减会优先执行加/减1，然后返回新值；后置则先返回原值，再执行加/减1。
适用类型：自增和自减通常用于数字类型，其他类型会尝试转换为数字并执行操作（如字符串中的数字或布尔值）。

应用场景

自增和自减运算符常用于循环控制，例如for循环：

for (let i = 0; i < 5; i++) {
    console.log(i); // 输出: 0, 1, 2, 3, 4
}

3.6 比较运算符

比较运算符用于比较两个值，并返回一个布尔值（true或false），以判断比较的结果是否为真。JavaScript中提供了多种比较运算符。

1. 相等运算符 (==)

==运算符检查两个值是否相等，但不会比较数据类型（即进行类型转换后再比较）。

console.log(5 == "5");  // 输出: true（字符串 "5" 被转换为数字 5）
console.log(0 == false); // 输出: true（`false` 被转换为 0）

2. 全等运算符 (===)

===运算符检查两个值是否严格相等，即不仅值要相等，数据类型也必须相同。

console.log(5 === "5");  // 输出: false（类型不同）
console.log(0 === false); // 输出: false（类型不同）
console.log(5 === 5);     // 输出: true

3. 不相等运算符 (!=)

!=运算符检查两个值是否不相等，同样会进行类型转换后再比较。

console.log(5 != "5");   // 输出: false（值相等，类型不同）
console.log(0 != false); // 输出: false
console.log(5 != 6);     // 输出: true

4. 不全等运算符 (!==)

!==运算符检查两个值是否严格不相等，值或类型不同即为true。

console.log(5 !== "5");  // 输出: true（类型不同）
console.log(0 !== false); // 输出: true（类型不同）
console.log(5 !== 5);     // 输出: false

5. 大于运算符 (>)

>运算符检查左侧的值是否大于右侧的值。

console.log(10 > 5);    // 输出: true
console.log(3 > 5);     // 输出: false

6. 小于运算符 (<)

<运算符检查左侧的值是否小于右侧的值。

console.log(10 < 5);    // 输出: false
console.log(3 < 5);     // 输出: true

7. 大于等于运算符 (>=)

>=运算符检查左侧的值是否大于或等于右侧的值。

console.log(10 >= 5);   // 输出: true
console.log(5 >= 5);    // 输出: true
console.log(3 >= 5);    // 输出: false

8. 小于等于运算符 (<=)

<=运算符检查左侧的值是否小于或等于右侧的值。

console.log(10 <= 5);   // 输出: false
console.log(5 <= 5);    // 输出: true
console.log(3 <= 5);    // 输出: true

9. 注意事项

类型转换：==和!=会进行隐式类型转换，可能导致意想不到的结果。建议使用===和!==以避免类型转换带来的影响。
字符串比较：字符串比较基于Unicode编码顺序。

3.7 逻辑运算符

在JavaScript中，逻辑运算符用于对布尔值进行组合或取反操作，常用于条件判断。常见的逻辑运算符有三个：逻辑与（&&）、逻辑或（||）和逻辑非（!）。

1. 逻辑与运算符（&&）

逻辑与运算符（&&）用于在两个条件都为true时返回true，否则返回false。

语法：expr1 && expr2
只有在expr1和expr2都为true时，结果为true。

let a = true;
let b = false;

console.log(a && b); // 输出: false
console.log(a && true); // 输出: true

短路求值

如果expr1为false，JavaScript不会再计算expr2，直接返回false。
如果expr1为true，则继续检查expr2。

let x = 0;
let result = (x > 0) && (x < 10); // x > 0 为 false，result 直接为 false
console.log(result); // 输出: false

2. 逻辑或运算符（||）

逻辑或运算符（||）用于在两个条件中至少有一个为true时返回true，只有当两个条件都为false时才返回false。

语法：expr1 || expr2
如果expr1或expr2有一个为true，结果为true。

let a = true;
let b = false;

console.log(a || b); // 输出: true
console.log(b || false); // 输出: false

短路求值

如果expr1为true，JavaScript不会再计算expr2，直接返回true。
如果expr1为false，则继续检查expr2。

let y = 5;
let result = (y > 0) || (y < 0); // y > 0 为 true，result 直接为 true
console.log(result); // 输出: true

逻辑非运算符（!）

逻辑非运算符（!）用于取反，将true变为false，将false变为true。

语法：!expr
如果expr为true，则结果为false；反之亦然。

let a = true;
let b = false;

console.log(!a); // 输出: false
console.log(!b); // 输出: true

将值转为布尔类型

let a = "hello";
console.log(!!a); // 输出: true

结合使用逻辑运算符

逻辑运算符可以结合使用来实现复杂的条件判断：

let age = 20;
let isStudent = true;

if (age >= 18 && age <= 25 && isStudent) {
    console.log("You are a student eligible for a discount.");
} else {
    console.log("No discount available.");
}
// 输出: "You are a student eligible for a discount."

真值和假值的运算

逻辑运算符会将操作数转换为布尔值进行判断。在JavaScript中，以下值会被视为false（即“假值”）：

false
0
""（空字符串）
null
undefined
NaN

其他所有值都被视为true（即“真值”）。

总结:逻辑运算符&&、||和!用于控制代码逻辑的执行，通过短路求值和布尔转换，实现条件判断的效率和灵活性

欲知后事如何,且听下回分解...