JavaScript的运算符

JavaScript中的运算符是用于执行各种操作（比如算术、比较、逻辑等）的符号。

下面说明一下不同类型的JavaScript运算符：

算术运算符

用来进行数学运算，如加减乘除。

+ 运算符（加法运算符）

var x = 1;
var y = 1;
console.log(x + y); // 输出: 2

+运算符也可以将字符串拼接起来，如果字符串(string)中含有空格，也会把空格拼接在一起。

var x = "Hello";
var y = " World!";
var z = txt1 + txt2;
console.log(z); // 输出: Hello World!

也可以把空格添加到表达式中

var x = "Hello";
var y = "World!";
var z = txt1 + " " + txt2;
console.log(z); // 输出: Hello World!

如果字符串与数字使用+来进行相加，那得到的结果是字符串(string)加数字(number)的一个新字符串

var x = "1";
var y = 1;
var z = txt1 + txt2;
console.log(z); // 输出: 11
console.log(typeof z); // 输出: "string"

-运算符（减法运算符）

主要用于减法运算

var x = 1;
var y = 1;
console.log(x - y); // 输出: 0

如果是字符串(string)的数字使用-运算符相减，得到的就是一个数字(number)

var x = "1";
var y = 1;
var z = x - y;
console.log(typeof x ); // 输出: "string"
console.log(typeof y); // 输出: "number"
console.log(typeof z); // 输出: "number"

var x = "1";
var y = "1";
var z = x - y;
console.log(z); // 输出: 0
console.log(typeof x ); // 输出: "string"
console.log(typeof y); // 输出: "string"
console.log(typeof z); // 输出: "number"

如果其中一个为非数字的字符串，相减之后会得到NaN

var x = "Hello";
var y = 1;
var z = x - y;
console.log(z); // 输出: NaN

*运算符（乘法运算符）

*运算符可以将两个数字(number)相乘

var x = 2;
var y = 3;
var z = x * y;
console.log(z); // 输出: 6

/运算符（除法运算符）

/运算符可以将两个数字(number)相除

var x = 6;
var y = 2;
var z = x / y;
console.log(z); // 输出: 3

var x = 1;
var y = 2;
var z = x / y;
console.log(z); // 输出: 0.5

%运算符（取模运算符或者取余运算符）

会将两个数字(number)相除，取结果的余数

var x = 1;
var y = 2;
var z = x % y;
console.log(z); // 输出: 1

++运算符（递增运算符）

以自身为基准自加1

var x = 1;
x++ ;
console.log(x); // 输出: 2

++x和x++都是递增运算符，用于将变量的值增加1。它们的区别在于它们的返回值和执行顺序。
x++是后置递增运算符，它首先返回变量的值，然后才将变量的值增加1。换句话说，它会先使用变量再递增。

let x = 5;
let y = ++x;
console.log(x); // 输出：6
console.log(y); // 输出：6

let a = 5;
let b = a++;
console.log(a); // 输出：6
console.log(b); // 输出：5

- -运算符（递减运算符）

var x = 1;
x-- ;
console.log(x); // 输出: 0

同理，--x和x--都是递减运算符，用于将变量的值减少1。它们的区别在于它们的返回值和执行顺序。
x--是后置递减运算符，它首先返回变量的值，然后才将变量的值减少1。换句话说，它会先使用变量再递减。

let x = 5;
let y = --x;
console.log(x); // 输出：4
console.log(y); // 输出：4

let a = 5;
let b = a--;
console.log(a); // 输出：4
console.log(b); // 输出：5

赋值运算符

赋值运算符用于给变量赋值。它的作用是将右侧的值赋给左侧的变量或表达式。

等于赋值（=）

用来给变量赋值。

let x = 10; // 将10赋给变量x

加等于赋值（+=）

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

let a = 5;
a += 3; // 相当于 a = a + 3，最终a的值为8

减等于赋值（-=）

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

let b = 10;
b -= 4; // 相当于 b = b - 4，最终b的值为6

乘等于赋值（*=）

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

let c = 2;
c *= 3; // 相当于 c = c * 3，最终c的值为6

除等于赋值（/=）

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

let d = 15;
d /= 5; // 相当于 d = d / 5，最终d的值为3

模等于赋值（%=）

将左侧的变量对右侧的值取模，并将结果赋给左侧的变量。

let e = 17;
e %= 6; // 相当于 e = e % 6，最终e的值为5

比较运算符

比较运算符用于比较两个值之间的关系，并返回一个布尔值（true或false）表示比较的结果。

等于（==）

比较两个值是否相等，如果相等则返回true，否则返回false。在进行相等比较时，会自动进行类型转换。

let x = 5;
console.log(x == 5); // true
console.log(x == '5'); // true，进行了类型转换
console.log(x == 6); // false

不等于（!=）

比较两个值是否不相等，如果不相等则返回true，否则返回false。也会进行自动类型转换。

let y = 7;
console.log(y != 7); // false
console.log(y != '7'); // false，进行了类型转换
console.log(y != 8); // true

全等于（===）

比较两个值的类型和值是否都相等，如果相等则返回true，否则返回false。不进行类型转换。

let a = 10;
console.log(a === 10); // true
console.log(a === '10'); // false，类型不同

不全等于（!==）

比较两个值的类型和值是否有任意不相等的情况，如果有则返回true，否则返回false。也不进行类型转换。

let b = 12;
console.log(b !== 12); // false
console.log(b !== '12'); // true，类型不同

大于（>）

比较一个值是否大于另一个值，如果第一个值大于第二个值，则返回true，否则返回false。

console.log(5 > 3); // true
console.log(5 > 7); // false

小于（<）

比较一个值是否小于另一个值，如果第一个值小于第二个值，则返回true，否则返回false。

console.log(10 < 15); // true
console.log(10 < 8); // false

大于等于（>=）

比较一个值是否大于或等于另一个值，如果第一个值大于或等于第二个值，则返回true，否则返回false。

console.log(5 >= 3); // true
console.log(5 >= 7); // false
console.log(5 >= 5); // true

小于等于（<=）

比较一个值是否小于或等于另一个值，如果第一个值小于或等于第二个值，则返回true，否则返回false。

console.log(10 <= 15); // true
console.log(10 <= 8); // false
console.log(10 <= 10); // true

逻辑运算符

逻辑运算符用于在逻辑表达式中连接或改变操作数的值，并返回一个布尔值（true或false）。JavaScript中常见的逻辑运算符有三种：与（&&）、或（||）和非（!）。

与运算符（&&）

• 语法：表达式1 && 表达式2
• 如果两个表达式都为真，则返回true；否则返回false。
• 如果表达式1的结果为false，则不会执行表达式2，提高了程序效率。

let x = 5;
let y = 10;
console.log(x > 0 && y < 15); // true，因为x大于0且y小于15
console.log(x > 0 && y > 15); // false，因为y不小于15

或运算符（||）

• 语法：表达式1 || 表达式2
• 如果两个表达式至少有一个为真，则返回true；否则返回false。
• 如果表达式1的结果为true，则不会执行表达式2，提高了程序效率。

let a = 3;
let b = 8;
console.log(a > 0 || b < 5); // true，因为a大于0
console.log(a < 0 || b < 5); // false，因为a不小于0且b也不小于5

非运算符（!）

• 语法：!表达式
• 用于取反，如果表达式为真（true），则返回false；如果表达式为假（false），则返回true。

let isOpen = true;
console.log(!isOpen); // false，isOpen为true，取反为false

let isLoggedOut = false;
console.log(!isLoggedOut); // true，isLoggedOut为false，取反为true

位运算符

位运算符是对操作数的二进制位进行操作的运算符。主要用于进行底层位操作，例如优化算法、处理位掩码、加密算法等场景。需要注意的是，在使用位运算符时，操作的是整数的二进制表示，并且可能会改变数据类型和导致不可预期的结果。因此，在使用位运算符时，要确保理解运算规则以及应用场景，避免出现错误。

按位与（&）

将两个操作数的每一个对应位进行与操作，如果两个操作数的对应位都为1，则结果为1，否则为0。

let num1 = 5; // 二进制表示为：101
let num2 = 3; // 二进制表示为：011

let result = num1 & num2;
console.log(result); // 输出结果为1，对应位上都为1，其他位为0

按位或（|）

将两个操作数的每一个对应位进行或操作，如果其中一个操作数的对应位为1，则结果为1，否则为0。

let num1 = 5; // 二进制表示为：101
let num2 = 3; // 二进制表示为：011

let result = num1 | num2;
console.log(result); // 输出结果为7，有任意一个对应位为1即为1

按位异或（^）

将两个操作数的每一个对应位进行异或操作，如果两个操作数的对应位不同则结果为1，相同则为0。

let num1 = 5; // 二进制表示为：101
let num2 = 3; // 二进制表示为：011

let result = num1 ^ num2;
console.log(result); // 输出结果为6，相同位上为0，不同位上为1

按位非（~）

对操作数的每一个二进制位取反，即将0变为1，1变为0。

let num = 5; // 二进制表示为：00000000000000000000000000000101

let result = ~num;
console.log(result); // 输出结果为-6，所有位取反，正数变成负数，负数变成正数，加1

左移（<<）

将操作数的所有二进制位向左移动指定的位数，低位补0。

let num = 5; // 二进制表示为：00000000000000000000000000000101

let result = num << 2;
console.log(result); // 输出结果为20，将5向左移动2位，低位补0

有符号右移（>>）

将操作数的所有二进制位向右移动指定的位数，高位使用符号位填充（保持正负不变）。

let num = -5; // 二进制表示为：11111111111111111111111111111011

let result = num >> 2;
console.log(result); // 输出结果为-2，将-5向右移动2位，符号位填充

无符号右移（>>>）

将操作数的所有二进制位向右移动指定的位数，高位使用0填充。

let num = -5; // 二进制表示为：11111111111111111111111111111011

let result = num >>> 2;
console.log(result); // 输出结果为1073741822，将-5向右移动2位，高位补0