1.运算符总结
• 一元运算符
• 算数运算符
• 位操作符
• 关系操作符
• 相等运算符
• 逻辑运算符
• 位操作符*
2.乘法运算符
乘法运算符规则及案例.png
乘法案例.png
3.除法运算符
除法运算符及案例.png
// 1、 如果是两个正常的数字运算，那就按照数学的除法运算得到结果。
var t0 = 9 / 3; // 3
var n1 = -999999e4000;
var n2 =0.00000000000000000000000000000000000000000000000000000000000001;
var t = n1 / n2;
console.log(t); // => -Infinity
// n1 / n2 的结果超出了 es 的数值的表示范围，那么结果就是Infinity
// 2、 如果一个操作数是 NaN 那么结果一定是 NaN
var n3 = NaN;
var t2 = n1 / n3; // => NaN
var t3 = n3 / n2; // => NaN
// 3、 如果是 Infinity 和 Infinity 进行相除结果是 NaN
console.log(Infinity / Infinity); // => NaN
// 4、 0 / 0 ,0 被除，如果是 0 那么结果是 NaN，如果不是 0 那么结果我就是 Infinity
console.log( 0 / 0 ); // => NaN
console.log( '9/0=' + (-9 / 0 )); // => -Infinity
// 5、 如果 Infinity 除以任何数，结果都是 [-]Infinity
console.log('Infinity / 8 = ' + (Infinity / 8)); //=>Infinity
4.求余运算符
求余运算符规则及案例.png
5.自增自减运算符
自增运算符，用两个连续的+号。比如： ++i t++. 如果两个加号在变量前面，先进行自增运算再进行表达
式运算。不然，先进行表达式运算，后进行自增运算。
var i = 9;
i++; // 自增运算符， 自己增加 1
// i = i + 1;
console.log( i ); // =>10
// 自加运算符在前面的时候，先进行自加运算，再参与表达式的运算。
++i; // i = i + 1;
console.log( i ); // =>11
// var i2 = ++i + 3; // i = 11, ++i > 12 12+3=>15
// console.log(i2)
var i2 = (i++) + 3; // i = 11, i + 3 > 14 ,最后在让 i= i+1;
console.log(i2); // => 14
var t = 11;
t--;
// t = t -1; // 自减运算符 ，自己减 1
console.log(t)
自减同自加，不再赘述。
6.加法运算符
加法的二义性：
加法运算分为： 字符串连接运算和算数加法运算。当运算的变量中有字符串的时候优先字符串连接，
后考虑算法运算。
var a = 1 + 2; // a =>３ 算数运算加法
var a = "我是" + "老马"; // a = "我是老马" 字符串连接
一元加法运算：
当操作数只有一个的时候，+法运算符，就是把操作数使用 Number 函数进行转成数值类型。
比如：
var a = 1 + "22"; //=> a="122",字符串连接操作
var t = ‘23’;
var m = +t; // m => 23 数字
// 等价于： m = Number(t);
7.减法运算符
减法运算符：只有数学减法运算。不具备字符串链接功能。
比如： var t = 3 - '2'; // => 1
减法运算符也具备将变量转换为数值类型的作用
减法运算符规则.png
减法案例.png
8.布尔相关的运算符
关系运算符
关系运算符返回的都是 boolean 类型结果。
大于 >
2 > 3 //false
"32" > "223" // true,字符串比较的是字符串的编码大小。
小于 <
2 < 3 //true
小于等于 <= var a = 22, b = 22; a<=b//true
大于等于 >= 22 >22 //true 33>=22 //true
逻辑运算符的规则
如果两个数都是数值,则执行数值比较
如果两个数都是字符串,则比较两个字符串对应的字符编码值
如果一个操作数是数值,则将另一个操作数作为一个数值,然后执行数值比较
如果一个操作数是对象,则调用这个对象的valueOf()方法,用得到的结果按照前面的规则执行比较。如果对
象没有valueOf()方法,则调用toString()方法,并用得到的结果根据前面的规则进行比较.
如果操作数是布尔值,则先将其转换为数值,然后再执行比较
逻辑运算符案例.png
Ascii 码表地址：
9.逻辑操作符
逻辑非
逻辑非的符号用“！”取相反的意思。 比如： var a = true; a = !a; //a = false;
逻辑与
逻辑与是用两个“&&”符号运算
var a = true, b = true; a&&b;//true
同时为真时才返回 true，其他 false
逻辑或
用两个竖线连接两个变量运算（||）
var a = true, b = true; a||b //true
两个变量只要有一个为真，那么就返回 true。
&&短路表达式 *** 由于进行逻辑运算的变量不一定都是 Boolean 类型
非 Boolean 类型的&&逻辑运算返回第一个为假值或者最后一个真值的操作数（直接量、表达式）的值，可
以不是 Boolean 类型。
比如：
89 && (9 < 3) // => true
0 && 98 // => 0, 注意不是 false
null && 1 // => null
类似短路表达式，||运算符可以返回第一个真值或者最后一个假值。
|| 类型安全返回处理
有的时候为了防止变量为空，可以设置一个保底的结果。
t = max || max-width || 500;
逻辑案例.png
10.相等运算符
数值相等 == 类型可以不相同，值相等就可以。
var a = 3, b = "3"; a==b;//true
不等于 != 值不等就返回 true，值相等就直接返回 false
3!=4 //true
3 != "3" //false
特殊情况：
NaN 跟任何其他变量都不等，甚至不等于自己。
NaN != NaN//true
null == undefined 都是空的意思。
全等运算符 === 全等就是数值相等而且类型相同。
55 =="55" //true
55 === "55" //false,值转换后相等，但是类型不同。
不全等运算符 !== 只要类型不同或者值不等那么就返回 true
11. 条件运算符
条件运算符： 判断值表达式 ？true 返回值 1 ：false 返回值 2。
var b = a > 3 ? 2 : 1; //语义：a 大于 3 吗？如果大于返回 2，如果不大于返回 1；
var b = 判断表达式 ？ 值 1 ： 值 2；
当判断表达式为 true 的时候，返回值 1。
12.赋值运算符
等号，就是最常用的赋值运算符。
var a = 9;
var a = 9, b = 3, c =4;
赋值和算数运算符结合简写
a = a + 10;//当+-*/运算符跟自己进行运算时可用简写成
a += 10;// 跟 a = a + 10 效果一样。
a *= 2; a -= 3; a/= 3; 4%=2;
13.逗号运算符
逗号运算符，可用让 js 在一条语句中执行多次操作。
比如：
var a = 2, b = 3, c =4;//一次性定义 3 个变量，并分别给变量赋值。 逗号运算符在用于赋值操作的
时候，永远只返回最后一个值
比如：
a = (2,3,4);//a=4
14.运算符的优先级
• 结合性：
• 一元+，一元减，后置++，后置--，！求反，typeof，=赋值，+=，*=，/=,%= 是从右向左结合，
其他都是从左向右结合。
• +a; -c; a++; c--; !true; typeof a; a=b=c=9;
• 其他的都是：从左向右结合。比如： c = a+b;
• 优先级
• 第一级：（） 圆括号 =>(a+b)*c 先运算a+b
• 第二级：后置递增和递减 a++ b--
• 第三级：逻辑！，一元+-，前置递增和递减，typeof
• 第四级：* / %
• 第五级：二元+ -
• 第六级：< > >= <= =>a+b > c*d
• 第七级： && || => a>b || c<d
• 第八级： ？ ： 条件运算符 => c= a && b ? 1: 2
• 第九级： 赋值运算符 = += *= -= /= %=
• 第十级：逗号 a = 1, b = 2;
15.综合练习
题目：
var a = '1', b = 3, c = true;
求下面的值：
a > b => false 转数字比较
a >= c => false 转成字符比较
!（b） => false
!!a => true
a+b => '13'
b + c => 4
b - a => 3-1 =>2
b && a => true
!(a || b) => false
a > b && c < a =>false
+c =>1
++a+c => 3
++b + 'ssss' =>'4ssss'
6 / 0 => Infinity
NaN * 0 =>NaN
b > c ? ++a: c; =>3