• js的运算符包括赋值，比较，算数，位运算，逻辑，字符串，三元等等

js表达式

表达式 = 操作符 + 操作数

每个表达式都有一个运算结果，该结果叫做返回值，返回值的类型叫做返回类型

所有的表达式都可以当作数据使用。

目前运算符的返回值和类型

  1. =：该表达式，返回赋值的结果
  2. .：属性访问表达式，返回的是属性的值
  3. []：属性访问表达式，返回的是属性的值
  4. ()：函数调用表达式，返回的结果取决于函数的运行
  5. 如果是一个声明+赋值的表达式，返回结果为undefined。

console.log函数调用的返回结果为undefined

运算操作符

-. 加号运算符 +

  • 作用就是用于数字之间的加法运算和字符串拼接
  • 任何类型的值加上字符串都会变成字符串 
    1. //例：
    2. var a = 1 + "a" + true + 1; //打印出 1atrue1
    3. var b = 1 + "a" + 1 + 1; //打印出 1a11
    4. var c = 1 + 1 + "a"; //打印出 2a 运算是由左往右
    5. var d = 1 + 1 + "a" + ( 1 + 1); //打印出 2a2

二. + - * /

  1. //例 
  2. var a = 0 – 1； //等于-1
  3. var a = 2 * 1； //等于 2
  4. var a = 0 / 0； //答案是 NaN，应该得出一个数字类型的数，但是没法表达，
  5. //就用 NaN (NaN 是 Not a Number 非数，不是数，但是是数字类型
  6. var a = 1 / 0; //是 infinity
  7. var a = -1 / 0;//是-infinity

细节

数字运算是不精确的.
typeof函数返回类型为string.
isNaN函数，该函数用于判断一个数据是否是NaN，返回boolean.
isFinite函数，该函数用于判断一个数据是否是有限的，返回boolean.

三.% 读摩尔，意思是取余数

  1. 例 var a =5%2 //5%2 是五除二的余数，商二余一
  2. 例 var a =5%1 //是五除一的余数，结果是 0
  3. 例 var num = 1 % 5; //意思是 1 除以 5 的余数。商 0 余 1
  4. 例 var a =4%6 //是四除六的余数，结果是 4
  5. 例 var a = 4;a % = 5; console.log(a); // 4
  6. 例 var a = 0;a % = 5; console.log(a); //0
  7. 例 var a = 10;a %= 2; console.log(a); //0
  8. 例 var a = 3;a % = 4; //4
  9. “-”，“*”，“/“，“%”，”=“，“()”
  10. 优先级”=“最弱【赋值符号优先级最低】，”()”优先级较高

其他类型使用算术运算

  1. 除加号之外的算术运算符

将原始类型转换为数字类型（自动完成转换），然后进行运算。

  • boolean： true -> 1, false -> 0
  • string: 如果字符串内部是一个正确的数字，直接变为数字，如果是一个非数字，则得到NaN（能识别Infinity，不能把字符串内部的东西当作表达式），如果字符串是一个空字符串（没有任何内容），转换为0. 字符串转换时，会忽略前后空格。

NaN虽然是数字，但它和任何数字作任何运算，得到的结果都是NaN

  • null：null -> 0
  • undefined: undefined -> NaN

将对象类型先转换为字符串类型，然后再将该字符串转换为数字类型

对象类型 -> “[object Object]” -> NaN

  1. 加号运算符
  • 加号一边有字符串，含义变为字符串拼接

将另一边的其他类型，转换为字符串

数字 -> 数字字符串
boolean -> boolean字符串
null -> “null”
undefined -> “undefined”
对象 -> “[object Object]”

  • 加号两边都没有字符串，但一边有对象，将对象转换为字符串，然后按照上面的规则进行

四.“++”，“--”

  • ++ 这个符号就是 值自身+1,再赋值给自身
  • — 这个符号就是 值自身-1,再赋值给自身
  • 自增自减表达式
    1. x++: 将变量x自增1，得到的表达式的值是自增之前的值。
    2. ++x: 将变量x自增1，得到的表达式的值是自增之后的值。
    3. x—: 将变量x自减1，得到的表达式的值是自减之前的值。
    4. —x: 将变量x自减1，得到的表达式的值是自减之后的值。
  • 优先级
    从高到底依次是：
    1. ++ --
    2. * / %
    3. + -

优先级的运算细节：

  1. 从左到右依次查看
  2. 如果遇到操作数，将数据的值直接取出
  3. 如果遇到相邻的两个运算符，并且左边的运算符优先级大于等于右边的运算符，则直接运行左边的运算符。
  1. 例: var a = 1; a = a + 1;
  2. 简化为var a = 1;  a ++;
  3. var a = 1; a = a - 1;
  4. 简化为var a = 1;  a--;
  5. 这两个符号值得注意的就是 它不仅可以后置（a ++ / a --), 还可以前置(++ a / -- a)
  6. 区别在于 前置是先运算再赋值 后置是先赋值再运算
  7. 例：var a = 1; a ++； 打印出的a 是1，需要再次打印的时候才会是2; 
  8. 而 ++ a的时候打印的a就直接是2了
  10. 例题：var a = 10; var b = ++ a - 1 + a ++; 
  11. console.log(a,b); // 12 21
  12. 解释 先是计算b的值,先是 ++ a;a为11;再减-1;后面 a++是先赋值为11还没到计算++的时候,b的值就是11-1+11为21; 而当打印a的值的时候a ++已经计算了所以为12;
  13. //console.log 就是打印到控制台

五. ”+=“，“-=”

  1.  +=  a+= 1 就是 a = a + 1
  2.  -=  a-= 1 就是 a = a - 1
  3.  例 var a =10;a += 10 + 1; //答案 21
  4.  例 var a = 1;a = a + 10;等于 a+=10;
  5.     var b = 10; b -= 2; //答案 8;
  6.  注意 a+= 1 + 1;是先算=后的运算 为 a+=2

六. /= *= %=

  1. 例 var a=10;a/=2; //答案 5，是除二赋给自身的意思
  2. 例 var a =10;a *=2; //答案：20，是乘二赋给自身的意思
  3. 例 var a=10;a%=2; //答案：0， 10 能整除 2,余数是 0,取余，余数赋给自身。
  4. 例 var a=3;a%=4; //答案：3，3 除以 4，余数为 3，余数赋给自身。
  5. 例 var a=0;a%=4; //答案：0，0 除以 4，余数为 0，余数赋给自身。
  6. 例 var a = 1;a% =10; //答案：1，1 除以 10，余数为 1，余数赋给自身。
  8. 例子
  9.  var a =(10 * 3 – 4 / 2 + 1)%2,b=3;b %= a + 3;
  10.  console.log(a++); // 1
  11.  console.log(--b); /  3

比较运算符

  • 大小比较： > < >= <=
  • 相等比较： == != === !==

比较运算符的返回类型：boolean;并且算术运算符的优先级是要高于比较运算符的
字符串的比较，比的是 ASCII 码(七位二进制 0000000)

细节

  • 如果一个不是字符串，并且两个都是原始类型，将它们都转换为数字进行比较 

    1. '1' -> 1
    2. ''  -> 0
    3. '  '-> 0
    4. ' a'-> NaN
    5. '3.14' -> 3.14

  • NaN与任何数字比较，得到的结果都是flase

  • Infinuty比任何数字都大，-Infinity比任何数字都小
  • 如果其中一个是对象，将对象转换成原始类型，然后按照字符串的规则或者是上面的规则进行比较，
    注意的是对象转换为原始类型后是字符串 “[object Object]”;

== 和 != (相等比较 和 不相等比较)

==: 比较两个数据是否相等
!=: 比较两个数据是否不相等

细节

  1. 两端的类型相同，直接比较两个数据本身是否相同（两个对象比较的地址）
  2. 两端的类型不同

1). null 和 undefined， 它们之间相等， 和其他原始类型比较， 则不相等。
2). 其他原始类型，比较时先转换为数字，再进行比较
3). NaN与任何数字比较，都是false，包括自身
4). Infinity和-Infinity，自能和自身相等
5). 对象比较时，要先转换为原始类型后，再进行比较

由于相等和不相等比较，对于不同类型的数据比较违反直觉，因此，通常我们不适用这种比较方式，而是使用更加接近直觉的严格相等和严格不相等比较

=== 和 !== （严格相等 和 严格不相等）

=== ： 两端的数据和类型必须相同
!== ： 两端的数据或类型不相同

  1. 两端类型相同，规则和相等比较一致。
  2. 两端类型不同，为false。

数字规则：

1). NaN与任何数字比较，都是false，包括自身
2). Infinity和-Infinity，自能和自身相等

  1.  例 var a = "a">"b";console.log(a); //答案是 false
  2.  例 var a = 1 > 2;console.log(a); //答案是 false
  3.  例 var a = "10">"8";console.log(a); //答案 false，不是十和八比，是字符串一零和八比，先用开头的一和八比，比不过就不看第二位了；一样的就拿零和八比;
  4.  例 var a = 1 == 2; //答案是说 1 等不等于 2，因为 1 肯定不等于 2，所以值为 false
  5.  例 var a = NaN == NaN; //答案是 false，NaN 不等于任何东西，包括它自己。
  6.  例 var a = undefined == underfined; //答案是 true
  7.  例 var a = infinity == infinity; //答案是 true
  8.  例 var a = NaN == NaN; //答案是 false。非数 NaN 是不等于自己的  得不出数，又是数字类型，就是 NaN;
  9.  例 1 <= "2" //true
  10.  例 3 >=  "3" //true
  11.  例 "30" != 30 //fale
  12.  例 "5"  === 5 //false

逻辑运算符

“&&” 与运算符

  • 两个表达式：先看第一个表达式转换成布尔值的结果是否为真，如果结果为真，那么它会看第二个表达式转换为布尔值的结果，然后如果只有两个表达式的话，只看看第二个表达式，就可以返回该表达式的值了，如果第一位布尔值为 false，不看后面的，返回第一个表达式的值就可以了。
  • 如果是三个或多个表达式，会先看第一个表达式是否为真，如果为真，就看第二个表达式，如果第二个也为真，就看第三个表达式（如果为真就往后看，一旦遇到假就返回到假的值），如果第三个是最后一个表达式，那就直接返回第三个的结果
  1. //例：
  2. var a = 1 && 2; //答案 2，如果第一位 1 为真，结果就为第二位的值 2
  3. var a = 1 && 2 + 2; //答案 4，如果 1 为真，结果就为 4
  4. var a = 1 && 1 && 8; //答案 8，先看第一个是否为真，为真再看第二个，
  5.                                 中途如果遇到 false，那就返回 false 的值
  6. var b = 1 + 1 && 1 - 1 && 2;console.log(b) //b 为 0

“||”或运算符

  • 看第一个表达式是否为真，如果为真，则返回第一个值，碰到真就返回如果第一个表达式是假，就看第二个表达式，如果第二个是最后一个，就返回第二个的值
  1. //例 
  2. var num = 1 || 3; //答案 1
  3. var num = 0 || 3; //答案 3
  4. var num = 0 || false; //答案是 false

“!”非运算符

  • 先转成布尔值，再取反
  1.   //例
  2.   var a = ! 123;document.write(a); //答案 false。123 的布尔值是 true，取反是 false
  3.   var a = ! “”;document.write(a); //答案 true。空串””布尔值是 false，取反是 true
  4.   var a = ! !“”;document.write(a); //答案 false，取反后，再反过来，结果不变
  5.   var a = true;a =!a;document.write(a) //答案 false，自身取反，再赋值给自身
  6.   //！=非等于是表达他们到底等不等的
  • 注意：被认定为 false 的值：转换为布尔值会被认定为 false 的值 undefined，null，NaN，“”（空串）， 0， false.

三目运算符

  • 书写方式： 表达式1 ? 表达式2 : 表达式3
  1. 对表达式1进行boolean判定
  2. 如果判定结果为真，返回表达式2；否则，返回表达式3。
  1. var year = 2000;
  2. //是否是闰年
  3. var isLeap = year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
  4. //得到该年份二月的天数
  5. var days = isLeap ? 29 : 28;
  6. console.log("二月的天数为：" + days);

逗号运算符

  • 写法：表达式1, 表达式2
  • 依次运行两个表达式，返回表达式2
  • 逗号运算符的优先级比赋值更低
  1. var x = 1;
  2. x = (x++ * 2, x++ * 2, x++ * 2);
  3. console.log(x);

复合的赋值运算符

  • += -= /= = %= *=
  1. // var x = 2;
  3. // x += 3; // 等同于 x = x + 3;
  5. // x *= 1 + 2; // 等同于 x = x * (1 + 2);
  7. // x *= x++ + 2; // 等同于 x = x * (x++ + 2);
  8. var user = {
  9. age: 18,
  10. name: "小松鼠",
  11. gender: "男"
  12. };
  14. // 输出： 我叫xxx，今年xxx岁了，性别是xxx，目前已成年（未成年）
  15. var result = "我叫";
  16. result += user.name;
  17. result += "，今年";
  18. result += user.age;
  20. console.log(result);