如果一个表达式拥有超过一个运算符，执行的顺序则由优先级决定

JavaScript 中每个运算符都有对应的优先级数字，数字越大越先执行，如果优先级相同，则按照由左至右的顺序执行。

JavaScript 控制台支持计算数字公式，常用的算术运算符

• 加法 +
• 减法 -
• 乘法 * ⚠️ 不是 x
• 除法 /（在 Java 中是整除）
• 乘方 ** 即幂运算，对于运算元是非整数的情况依然适用，如 a ** (1/2) 相当于开方。 ⚠️ 日常数学公式中的乘方符号 ^ 在是指按位 XOR
• 取模 % modulo 即求余

比较数值的比较运算符

数字之间的比较结果是布尔值 true 或 false，比较的结果可以被赋值给任意变量

• 比较字符的大小时，JavaScript 会使用 Unicode 编码顺序进行判定，而对于字符串时是按从左往右依次比较字符（母）。
  字符串的比较算法步骤：
  1. 首先比较两个字符串的首位字符大小。
  2. 如果一方字符较大（或较小），则该字符串大于（或小于）另一个字符串。算法结束。
  3. 否则，如果两个字符串的首位字符相等，则继续取出两个字符串各自的后一位字符进行比较。
  4. 重复上述步骤进行比较，直到比较完成某字符串的所有字符为止。
  5. 如果两个字符串的字符同时用完，那么则判定它们相等，否则未结束（还有未比较的字符）的字符串更大。
  js

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

• null 和 undefined 比较行为很特别。
  当使用非严格相等 == 比较 null 空值和 undefined 未定义时，JavaScript 存在一个特殊的规则，会判定它们相等。
  js

  alert( null == undefined ); // true
  

  
  当使用数学式或其他比较方法 < > <= >=时（不包括 == 与 !=，由于相等性检测比较特殊，与其他比较运算符行为不一样）null 和 undefined 会被分别转化为数字 0 和 NaN
  js

  // null 转换为 0
  alert( null > 0 );   // false
  alert( null >= 0 );   // true
  
  // null 不转换为 0
  alert( null == 0 );   // false
  
  alert( undefined > 0 ); // false
  alert( undefined < 0 ); // false
  alert( undefined == 0 ); // false
  

  Tip

  undefined 和 null 在相等性检测 == 或 != 中不会进行任何的类型转换，且undefined 只与 null 相等，不会与其他值相等。

二元运算符加号 + 被应用于字符串，将合并（连接）各个字符串。只要其中一个运算元是字符串，那么另一个运算元也将被转化（数据隐式类型转换）为字符串。

alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"

"Hello" + 5*10   // "Hello50"
alert(2 + 2 + '1' );   // "41" 而不是 "221"

赋值运算符将右侧的值「写入」左侧的变量，对于链式赋值也是由右向左执行。

一元运算符加号，即加号 + 应用于单个值，会将其转化为数字（对数字没有任何作用），相当于 Number() 函数。

逗号运算符能让我们处理多个语句，使用 , 将它们分开，每个语句都运行了，但是只有最后的语句的结果会被返回。

// 在 for 循环的条件判断中，一行上用逗号分隔了三个算式
for (a = 1, b = 3, c = a * b; a < 10; a++) {
 ...
}

• 自增：x++ or ++x 等同于 x = x + 1
• 自减：x-- or --x 等同于 x = x - 1

一般它们只有在使用自增式子的返回值作为表达式一部分时才有区别，若只是需要自增 x 值则两种方式均可。因此如果我们想要对变量进行自增操作，并且需要立刻使用自增后的值，那么我们需要使用前置形式；如果我们想要将一个数加一，但是我们想使用其自增之前的值，那么我们需要使用后置形式。自减也是类似。

// 前置自增
let counter = 1;
let a = ++counter;
alert(a);   // 2
alert(counter);   // 2

// 后置自增
let counter = 1;
let a = counter++;
alert(a);   // 1
alert(counter);   // 2

对一个变量进行操作，并把计算得到的新结果存储在原来的这个变量中，可以使用简写形式：

常用的简写形式

• 增加简写：x += 3 等同于 x = x + 3
• 减少简写 x -= 6 等同于 x = x - 6
• 相乘简写：x *= 2 等同于 x = x * 2
• 相除简写：x /= 5 等同于 x = x / 5

JavaScript 里有三个逻辑运算符：

• || 或，优先级别最低
• &&与，优先级别为中
• ! 非，优先级别最高

这些运算符操作布尔值组合并返回相应的布尔值作为结果。

let value = 80 && 55;   // 赋值为 55，而不是 true
let value2 = 0 && 55;   // 赋值为 0，而不是 false
let str = "hello" && 65 && "abc"   // 赋值为字符串 abc

如果存在特殊的值，有 null、NaN、undefined 之一，对于多个操作数执行 && 运算，当前面的操作数隐式类型转换后都为 true，其后的值遵循特定规则（基于短路规则）

• 如果有一个操作数是 null，则返回 null
• 如果有一个操作数是 NaN，则返回 NaN
• 如果有一个操作数是 undefined，则返回 undefined

// 或运算真值表，四种可能的逻辑组合
true || true;   // true
false || true;  // true
true || false;  // true
false || false; // false

if (1 || 0) { // 工作原理相当于 if( true || false )
  alert( 'truthy!' );   // 弹出一个模态窗口显示 truthy！
}

// 与运算真值表，四种可能的逻辑组合
true && true;   // true
false && true;  // false
true && false;  // false
false && false; // false

短路

使用 && 或 || 逻辑运算符时，出现的逻辑表达式的后续参数不用考虑的行为就叫做最少运算或短路，因为前面的参数已经满足条件了。

在特定的情况下，后一个条件 B 的布尔值不重要：

• 当第一个条件 A 布尔值为 false 时，那么无论第二个条件 B 的值是多少，A && B 整个表达式始终为 false，则在该情况下不须考虑条件 B 的情况。
• 当第一个条件 A 布尔值为 true 时，那么无论第二个条件 B 的值是多少，A || B 整个表达式始终为 true，则在该情况下不须考虑条件 B 的情况。

利用短路特性，可以实现短路取值，即通过一个逻辑链为变量赋予特定的值：

• 一个或运算 || 链，将返回第一个真值，如果没有真值就返回最后一个值。
• 一个与运算 && 链，将返回第一个假值，如果没有假值就返回最后一个值。

js

let currentUser = null;
let defaultUser = "John";

let name = currentUser || defaultUser || "unnamed";   // 返回第一个真值或最后一个值

alert( name );   // John