5.1 数学运算

运算符(operators , 也翻译为操作符 ), 是发起运算的最简单形式
分类:
数学运算符 (arithmetic operators)
比较运算符 (comparison operators )
逻辑运算符 (logical operators )
赋值运算符 (assignment operators )
按位运算符 (Bitwise operators)
条件 (三元) 运算符( conditional operators )

* / + - % ()
1.运算顺序: 先算乘除 ( 取余 ), 再算加减. 有小括号先算小括号中的

  1. console.log(1+2)

如果是纯数字字符串参与数学运算, 可以不用 praseint() prasefloat() 也可以进行隐式转换, 自动转为数字参与运算(+除外仍然是拼接作用 ) 

  1. console.log(typeof("10"+"12"));//输出 1012  string
  2. console.log(typeof("10"-"12"));//输出 -2    number
  3. console.log(typeof("10"*"12"));//输出 120   number
  4. console.log(typeof("10"/"12"));  /* 输出 0.833...    number */
  5. console.log(typeof("10"%"12"));//输出 10   number

布尔值 ,false(0) true(1) null(0) 也会进行隐式转换, + 表示加法
如果要进行布尔值计算 true默认是1 false默认是0 null默认是0

  1. console.log(true +1);//输出 2
  2. console.log(true -1);//输出 0
  3. console.log(false +5);//输出 5
  4. console.log(false -2);//输出 -2

infinity 就是非常大的数字参与任何运算都是infinity 无穷大的意思

  1. console.log(infinity -1);//输出 infinity
  2. console.log(infinity +1);//输出 infinity
  3. console.log(infinity *1);//输出 infinity
  4. console.log(infinity /1);//输出 infinity
  5. console.log(infinity %1);//输出 infinity

NaN 参与的结果都是NaN
undefined 参与任何运算的结果也都是NaN 非数字的意思

  1. console.log(NaN -1);//输出 NaN
  2. console.log(NaN +1);//输出 NaN
  3. console.log(undefined *1);//输出 NaN
  4. console.log(undefined /1);//输出 NaN

5.2 Math对象

Math是js 内置的数学对象
可以调用很多数学方法和属性

Math.random(): 随机数

  1. Math.random(): 随机数[0,1) , 不用书写参数
  2. var a =Math.random();//输出 随机数 __相当于随机数种子
  3. console.log(a);
  5. var b =Math.random()*1000;
  6. console.log(b);//随机输出 百位数字
  8. var c =Math.random()*10000;
  9. console.log(c);//随机输出 千位数字
  10. console.log(parseInt(c));//随机输出 千位数字  parseInt()取整数

Math.pow(); 计算幂

  1. Math.pow(); 计算幂的计算 , 第一个参数书写底数, 第二个参数书写指数.如: math.pow(2,4)表示2的四次方
  2. //表示2的4次方  :计算过程  2*2=4*2=8*2=16
  3. var a =Math.pow(2,4);
  4. console.log(a);//输出 16
  6. //表示4的5次方  :计算过程  4*4=16*4=64*4=256
  7. var b =Math.pow(4,4);
  8. console.log(b);//输出 256
  10. //表示6的6次方  :计算过程  6*6=36*6=216*6=1296*6=7776*6=46656
  11. var c =Math.pow(6,6);
  12. console.log(c );//输出 46656

Math.sqrt() : 计算开方数

  1. Math.sqrt() : 计算开方数 , 只需要书写一个要开方的数
  2. console.log(Math.sqrt(16));

Math.PI() : 表示圆周率

  1. Math.PI() : 表示圆周率的数值π 
  2. console.log(Math.PI);//结果 3.14225555

5.3比较运算符

大于
< 小于
>= 大于等于
<= 小于等于
= 等号 解析: 赋值
== 等于 解析: 等于比较 只判断 (1)数值相同
!= 不等于 解析: 真的为假 假的为真
=== 全等于 解析: 全部等于 判断 (1)数据类型相同 (2)数值相同
!== 不全等于 解析: 判断 (1)数据类型相同 (2)数值相同 (3)取反

比较运算符结果一定是布尔值 true false
1. 两侧都是纯数字比较结果也是布尔值
2. 纯数字字符串, 布尔值, null参与运算, 会进行隐式转换
true(1) false(0) null(0)
3. ==等于 , 在判断两边关系时, 尽可能让两侧相等, 只判断数值不判断类型 null比较特在参与== , === 时不隐式转换为0 结果都是false

  1. console.log(1 !== 1);
  2. /* 过程: 判断
  3. (1)两边的数据类型相同
  4. (2)两边的数值相同
  5. 结果 满足上面2个条件,为 true
  6. !== 取反
  7. 最后结果为 false 
  8. */

image.png

4 != 不等于, 在判断 !=关系时不要直接判断, 而是看对立面== , 如果 ==为真那么!= 一定加假 , 如果 == 为假 != 一定为真 . 同样!==

5 === 全等于 , 在判断两边关系时 尽可能让两侧关系不相等 , 不但判断数值还判断数据类型是否相同
(1)在判断时要判断数值
(2)还要判断数据类型
console.log(1 === “1”) ;//结果false 过程:先判断类型是否相等,再判断数值是否相等

判断3>2>1 ( 比较运算符顺序 , 从左到右)

  1. console.log(3 > 2 > 1);//结果为false
  2. // 运算过程: 3>2  = true   ,   true > 1  =false

6 NaN infinity 不会发生隐式转换
7 如果两侧都是字符串参与 , 不是比较字符长短而是比较每一个字符
Unicode 编码 , 编码顺序越靠后越大
比较顺序排序:
(1) 小写字母(a-z) 解析: 老大
(1) 大写字母(A-Z) 解析: 老二
(2) 数字(0-9) 解析: 最小 数字大才大,2比1大

5.4 逻辑运算符

逻辑与运算符 && 解析: 满足所有的条件 都真才真,有一个是假 结果都是false假
逻辑或运算符 || 解析: 只要满足一个条件, 就是真 全假才假false
逻辑非运算符 ! 解析: 假的为真 真的为假 !true //结果是假false !!true//结果为真true

不都是布尔值参与逻辑运算, 结果不一定是布尔值 , 需要进行隐式转换
隐式转为 true : 非0数字( infinity ) , 非空字符串
隐式转为 false : 0 , ”” , NaN , undefined , null 

  1. console.log(Infinity && false);//结果 false
  2. console.log(NaN || "你好");//结果 你好

5.5 短语语法(逻辑或)

逻辑或 ||
将逻辑或比喻成并联电路 , 判断过程 , 想象成电流通过的过程

  1. console.log("隐式转换true: 非0数字 , 非空字符串");
  2. console.log(Infinity || "你好");//结果 是参数一(Infinity)
  3. console.log(10 || "你好");//..结果 是参数一(10)
  4. console.log("你好" || "你好");//结果 是参数一(你好)
  6. console.log('隐式转换false: 0 ,"",NaN,undefined,null');
  7. console.log(0 || "你好");//结果 你好
  8. console.log("" || "你好");//结果 你好
  9. console.log(NaN || "你好");//结果 你好
  10. console.log(null || "你好");//结果 你好
  11. console.log(undefined || "你好");//结果 你好

逻辑运算顺序: 先算非 ! , 再算与 && , 最后算或 ||
(1) 非
(2) 与
(3) 或
短路运算

  1. var num = 4 && "hello" || !false || !true && null;
  2. console.log(num);
  3. /* 运算过程
  4. 隐式转换 true: 非0数字 (infinity) ,非空字符串
  5. false: 0 ,"",NaN,undefined,null
  7. num = 4 && "hello" || !false || !true && null;
  8. = 4 && "hello" || !false || false && null;
  9. = "hello" || !false || false && null;
  10. = "hello" || !false || false
  11. ="hello"
  12. */

5.6 赋值运算符

在变量的原基础上 进行右侧运算 , 将运算后的值 直接赋值给左边的变量
+= -= *= /= %= ++

  1. var a = 10;
  2. console.log(a += 5);
  3. //简化写法   a = a + 5;      结果相同 15
  5. console.log(a -= 5);
  6. //简化写法   a = a - 5;      结果相同 5
  8. console.log(a *= 5);
  9. //简化写法   a = a * 5;      结果相同 50
  11. console.log(a /= 5);
  12. //简化写法   a = a / 5;      结果相同 2 
  14. console.log(a %= 5);
  15. //简化写法   a = a / 5;      结果相同 0

++ 在变量之前或者之后参与计算时有区别
不管++在前在后, 只要再次使用都是自加 1 的结果
++ a : 先变量自加1 , 自加 1 之后的结果参与计算

  1. console.log(++a);//结果11  先自增 1  再加 a 
  2. console.log(a);//11
  3. console.log(a);//11

a ++ : 直接使用变量当前的值参与计算, 计算之后变量再自加1

  1. var a = 10;
  2. console.log(a++);//结果10  再++   只要再次调用b 就会产生1次运算
  3. console.log(a);//11
  4. console.log(a);//11

案列1:

  1. var a = 10; b = 20; c = 30;
  2. var sum = a++ + ++b + c++ + ++a;
  3. /* 计算过程
  4. 10+21+30+12
  5. 31+42
  6. 73
  7. */
  8. console.log(sum);//结果 73

综合运算顺序: 先贴身++ , 数学 , 比较 , 逻辑

案列2:

  1. var a = 4;
  2. var son = 1 * (2 + 3) && a++ || 5 > 6 && 7 < 8 || 9;
  3. /* 综合运算顺序: 先贴身++ , 数学 , 比较 , 逻辑赋值 (与, 或 )
  4. 1 * (2 + 3) && 4 || 5 > 6 && 7 < 8 || 9;
  5. 5 && 4 || 5 > 6 && 7 < 8 || 9;
  6. 5 && 4 || false && true || 9;
  7. 4 || false && true || 9;
  8. 4 || false || 9;
  9. 4||9
  10. 4
  11. */
  12. console.log(son);//结果 4

案列3:

  1. var b = 4;
  2. var son = 1 + 2 && 3 * b++ % 5 || 6 < 7 == 8 / !false;
  3. /* 综合运算顺序: 先贴身++ , 数学 , 比较 , 逻辑赋值 (与, 或 )
  4. 贴身++
  5. 1 + 2 && 3 * 4 % 5 || 6 < 7 == 8 / true;
  6. 数学  true 1   false 0   null 0
  7. 3 && 2 || 6 < 7 == 8 / 1;
  8. 比较
  9. 3 && 2 || 6 < 7 == 8;
  10. true == 8;
  11. 3 && 2 ||false
  12. 逻辑
  13. 2 || false
  14. 2
  15. */
  16. console.log(son);//结果4