和数学中的运算符是一样的，JavaScript中的运算符是告诉程序执行特定的算式或逻辑操作的符号

第一优先级：()

第二优先级：【!】、【++】、【--】

第三优先级：乘【*】、 除【/】、 取余【%】

第四优先级： 加【+】、减【-】

第五优先级：【>】、【>=】、【<=】、【<】

第六优先级：【==】、【!=】、【===】、【 !==】

第七优先级：【&&】

第八优先级：【||】

第九优先级：【+=】、【 -=】、【 /=】、【 %=】

第十优先级：，

三目运算符

// 三目运算符又称条件运算符
// 条件表达式? 结果A : 结果B
// 当三目运算条件表达为真的时候，返回结果A
// 当三目运算条件表达为假的时候，返回结果B
let result1 = 10 > 5 ? "是的" : "不是";
console.log(result1);

let result2 = 2 > 5 ? "是的" : "不是";
console.log(result2);

逗号运算符

// 利用逗号运算符可以同时定义多个变量
let a, b;
a = 10, b = 5;

// 逗号运算符的优先级是所有运算符中最低的

// 逗号运算符也是运算符，所以也有运算结果，它的结果就是最后表达式的结果
let result = ((1 + 1), (2 + 2), (3 + 3));
console.log(result); // 运算结果为6

算术运算符

// 加法【+】
let num1 = 2;
let num2 = 4;
let result1 = num1 + num2;
console.log(result1); // 输出结果是6
// 算术运算符都是左结合性，从左至右的运行计算

// 备注：任何非数值类型(字符串类型除外)的数据参与加法运算之前，都会被转化成数值类型之后，再参与运算
let result1 = 1 + true;
let result2 = 1 + false;
let result3 = 1 + null;
console.log(result1); // 输出结果是2
console.log(result2); // 输出结果是1
console.log(result3); // 输出结果是1

// 备注：任何数据与NaN进行运算，结果都是NaN
let result1 = 1 + NaN;
console.log(result1); // 输出结果是NaN

// 备注：任何数据与字符串想加，都会先将非字符串类型的数据转化成字符串类型的数据之后在运算，相当于字符串拼接
let str1 = "78";
let str2 = "78px";
let result1 = 1 + str1;
let result2 = str2 + 1;
console.log(result1); // 输出结果是178
console.log(result2); // 输出结果是78px1

//减法【-】、乘法【*】、除法【/】
let num1 = 2;
let num2 = 4;
let num3 = 10;
let result2 = num1 * num2;
let result3 = num2 / num1;
let result4 = num1 / num2;
let result7 = num3 + num1 * num2;
console.log(result2); // 输出结果是8
console.log(result3); // 输出结果是2
console.log(result4); // 输出结果是0.5
console.log(result7); // 输出结果是18
// 备注：【*】【/】【%】的优先级高于【+】【-】

// 备注：任何非数值类型(字符串类型除外)的数据参与减法运算之前，都会被转化成数值类型之后，再参与运算
let result1 = 1 - true;
let result2 = 2 * 5 - false;
let result3 = 6 / 3 - null;
console.log(result1); // 输出结果是0
console.log(result2); // 输出结果是10
console.log(result3); // 输出结果是2

// 备注：任何数据与NaN进行运算，结果都是NaN
let result1 = 1 - NaN;
console.log(result1); // 输出结果是NaN

// 备注：任何数据与字符串想减，都会先将字符串类型的数据转化成数值类型的数据之后在运算
let str1 = "78";
let str2 = "78px";
let result1 = 1 - str1;
let result2 = str2 - 1;
console.log(result1); // 输出结果是178
console.log(result2); // 输出结果是NaN

// 取余【%】
let num1 = 2;
let num2 = 4;
let num3 = 10;
let result5 = num3 % num1;
let result6 = num3 % num2;
console.log(result5); // 输出结果是0
console.log(result6); // 输出结果是2

// 取余公式
// m % n;
let result1 = 10 % 3;
let result2 = 3 % 10;
let result3 = 10 % 0;
let result4 = -10 % 3;
console.log(result1); // 输出结果是1
console.log(result2); // 输出结果是3
console.log(result3); // 输出结果是NaN
console.log(result4); // 输出结果是-1

// 以下判断不论正负性
// 备注:如果m>n正常取余
// 备注:如果m<n结果是m
// 备注:如果n=0,那么结果就是NaN
// 备注:结果正负性取决于m

// 自增【++】 自减【--】
let num1 = 2;
num1++;
console.log(num1); // 输出结果是3

let num2 = 4;
num2--;
console.log(num2); // 输出结果是3

let num3 = 10;
++num3;
console.log(num3); // 输出结果是11

let num4 = 10;
--num4;
console.log(num4); // 输出结果是9

// 备注:【++】【--】运算符写在变量后面，表示变量先参与其他运算，再自增或自减
let num1 = 1;
let result1 = num1++ + 2;
console.log(result1); // 输出结果是3
console.log(num1); // 输出结果是2
// 以上代码相当于以下代码
let num1 = 1;
let result1 = num1 + 2;
num1++;
console.log(result1);
console.log(num1);

// 备注:【++】【--】运算符写在变量前面，表示变量先自增或自减，在参与运算
let num1 = 1;
let result1 = --num1 + 2;
console.log(result1); // 输出结果是2
console.log(num1); // 输出结果是0
// 以上代码相当于以下代码
let num1 = 1;
--num1;
let result1 = num1 + 2;
console.log(result1);
console.log(num1);

// 备注：自增/自减运算符只能出现在变量的前面或者后面，不能出现在常量或者表达式的前面或后面
// 表达式就是用运算符连接在一起有意义有结果得到语句

赋值运算符

// 简单赋值运算符【=】 
let num1 = 1;
let num2 = num1 + 2;
console.log(num2); // 运算结果为3
// 备注：赋值运算符优先级低于算术运算符
// 备注：值运算是右结合性(把右边的值存储到左边)
// 备注：值运算符左边不能是常量

// 复杂赋值运算符
// 【+=】、【-=】、【/=】、【%=】
let num1 = 1;
num1 += 4
console.log(num1); //运算结果为5
// 以上代码相当于以下代码
let num1 = 1;
num1 = num1 + 4;
console.log(num1);

// 【-=】【/=】【%=】同理

关系运算符

// 优先级：【>】、【<】、【>=】、【<=】大于【!=】、【==】、【===】、 【!==】
let result1 = 10 > 5;
let result2 = 10 < 5;
let result3 = 10 >= 5;
let result4 = 10 <= 5;
let result5 = 10 != 5;
let result6 = 10 === 5;
let result7 = 10 !== 5;
let result24 = 10 != 5;
console.log(result24); //运算结果false
console.log(result1); //运算结果true
console.log(result2); //运算结果false
console.log(result3); //运算结果true
console.log(result4); //运算结果false
console.log(result5); //运算结果true
console.log(result6); //运算结果false
console.log(result7); //运算结果true

// 备注:关系运算的结果只有true和false，关系成立则true，关系不成立则false

// 对于非数值类型的数据，会先将数据转换成数值类型，在进行判断
let result8 = 1 > true;
let result9 = 1 > false;
let result10 = 1 > '0';
let result11 = 1 > '10';
console.log(result8); //运算结果false
console.log(result9); //运算结果true
console.log(result10); //运算结果true
console.log(result11); //运算结果false

// 对于关系运算符来说，任何数据与NaN比较，返回值都是false
let result12 = 1 > NaN;
console.log(result12); //运算结果false

// 如果参与比较的都是字符串类型，那么则不会转化数值类型，而是转化为对应的Unicode编码进行比较
let result13 = "a" > "b"
console.log(result13); //运算结果false

// 如果参与比较的都是字符串类型且不仅仅只有一个，它会一次从左至右进行相对于的Unicode编码比较，直到关系不成立为止
let result14 = "ac" > "bc"
console.log(result14); //运算结果false

// 特殊比较
let result15 = null == 0;
let result16 = undefined == 0;
let result17 = null == undefined;
let result18 = NaN == NaN; // 企业开发中不使用这方法判断数据是否是NaN，可以使用内部isNaN方法进行判断
console.log(result15); //运算结果false
console.log(result16); //运算结果false
console.log(result17); //运算结果true undefined是null衍生出来所以为true
console.log(result18); //运算结果false 这个永远为false

// 【==】、【!=】只会判断取值是否相等，【===】、【!==】不仅会判断取值是否相等，还会判断数据类型是否相等
let result19 = 123 == "123";
console.log(result19); // 输出结果为true

let result20 = 123 === "123";
console.log(result20); // 输出结果为false

let result21 = 123 != "123";
console.log(result21); // 输出结果为false

let result22 = 123 !== "123";
console.log(result22); // 输出结果为true

// 关系运算符是左结合性，所以不能利用关系运算符来判断区间
let result23 = 10>5>3;
console.log(result23); // 输出结果为false
// 以上代码运算过程为
let result23 = 10>5>3;
// 下一步
let result23 = true>3;
// 下一步
let result23 = 1>3;
console.log(result23);
// 所以不能进行区间判断

逻辑运算符

// 与【&&】(逻辑)
// 格式: 条件A(条件表达式或数值) && 条件B(条件表达式或数值)
// 条件表达式：通过关系运算符连接的判断语句
// 特点:一假则假
let result1 = 10 > 5 && 8 > 5; // true && true
let result2 = 10 > 5 && 8 < 5; // true && false
let result3 = 8 < 5 && 8 < 5; // false && false
console.log(result1); // 输出结果是true
console.log(result2); // 输出结果是false
console.log(result3); // 输出结果是false

// 在逻辑与运算中，条件不是条件表达式，如果条件A不成立，那么就会返回条件A，如果条件A成立，那么条件B是否成立，都会返回条件B
let result4 = null && 5;
let result5 = 25 && 5;
console.log(result4); // 输出结果是null
console.log(result5); // 输出结果是5

// 逻辑与短路现象，只要条件A为假，那么条件B就不会参与运算，直接输出条件A，如果条件A为真，则条件B参与运算
let num1 = 5;
let result6 = 0 && num1++;
console.log(result6); // 输出结果是0
console.log(num1); // 输出结果是5

let num2 = 5;
let result7 = 2 && num2++;
console.log(result7); // 输出结果是5
console.log(num2); // 输出结果是6

// 或【||】(逻辑)
// 格式: 条件表达式A || 条件表达式B
// 条件表达式：通过关系运算符连接的判断语句
// 特点:一真则真
let result8 = 10 > 5 || 8 > 5; // true || true
let result9 = 10 > 5 || 8 < 5; // true || false
let result10 = 8 < 5 || 8 < 5; // false || false
console.log(result8); // 输出结果是true
console.log(result9); // 输出结果是true
console.log(result10); // 输出结果是false

// 在逻辑或运算中,条件不是条件表达式,如果条件A成立,那么就会返回条件A,如果条件A不成立,那么条件B是否成立,都会返回条件B
let result11 = null || 5;
let result12 = 25 || null;
console.log(result11); // 输出结果是5
console.log(result12); // 输出结果是25

// 逻辑或短路现象,只要条件A为真,那么条件B就不会参与运算,如果条件A为假,那么条件B就会参与运算
let num3 = 6;
let result13 = 126 || num3++;
console.log(result13); // 输出结果是126
console.log(num3); // 输出结果是6

let num4 = 6;
let result14 = 0 || num4++;
console.log(result14); // 输出结果是6
console.log(num4); // 输出结果是7

// 非!(逻辑)
// 格式: !条件表达式
// 特点:真变假,假变真
let result15 = !10 > 5
let result16 = !8 < 5;
console.log(result15); // 输出结果是false
console.log(result16); // 输出结果是true

// 逻辑运算符是左结合性
// 逻辑运算符中优先级 【&&】 高于 【||】
let result17 = 10 > 5 || 8 < 5 && 8 < 5 // true || false && false
console.log(result17); // 输出结果是true

// 如果逻辑运算中如果数据是数值类型,那么会先转化为布尔类型,再参与运算
let result18 = !1 // →!true
let result19 = !0 // →!false
console.log(result18); // 输出结果是false
console.log(result19); // 输出结果是true