算术运算符-JavaScript

算术运算符

运算符：也是操作符，通过运算符可以对一个或多个值进行运算操作,并获取运算结果

使用算术运算符操作字面量±*/%，例如：

var res = 10 + 20;
console.log(res);//输出结果为30

typeof

typeof也是一个运算符，获取变量的类型，返回字符串。返回的值有：number，string，object，underfined，boolean。

var temp = true;//这里面可以放各种类型的值
console.log(typeof temp);//输出为boolean，放其他值也可输出，number，string，object，undefined
var type = typeof temp;
console.log(typeof type);//输出为string

+加法

对两个值或变量进行加法操作，并返回计算结果

任何值（变量）和字符串相加会变成连接操作（拼串）

对于非nulber类型进行运算，会先转换为number类型，再相加（字符串除外）

任何值和NaN运算，都会转换为NaN

任意类型 + 空字符串，可以转换为字符串类型（隐式转换，本质上调用String()）

//1. 值和值相加
var res = 10 + 20;
console.log(res);//输出结果为30
//2. 值和字面量相加
var temp = 30；
res = temp + 20；
console.log(res);//输出结果为50
//3. 变量+boolean
var flag=true;
res = temp + flag;
console.log(res);//输出结果为31
//4. 变量+字符串，加号转化为拼串操作,字符串+字符串也是拼接
var str = "20";
res = temp + str;
console.log(res);//输出结果为3020
//5. boolean+boolean
res = true + false;
console.log(res);//输出结果为1
//6. 空字符串+boolean
res = true+"";
console.log(res);//输出结果为true
console.log(typeof res)//输出结果为string
//任意类型+空字符串可以转化为字符串
//7. 先加再拼接
console.log(1+2+3+"4");//输出结果为64
//8. 先转化为字符串再拼接
console.log("4"+1+2+3);//输出结果为4123

-减法

对两个值或变量进行减法操作，并返回计算结果

非number类型都会转换为number类型，再操作

任何值和NaN运算，都会转换为NaN

*乘法

对两个值或变量进行乘法操作，并返回计算结果

非number类型都会转换为number类型，再操作

非number类型都会转换为number类型，再操作

res = temp2 * "30";
console.log(res); //900

res = temp2 * "a";
console.log(res); //NaN

除法/

对两个值或变量进行除法操作，并返回计算结果

非number类型都会转换为number类型，再操作

任何值和NaN运算，都会转换为NaN

//对两个值或者变量进行相除，返回结果
var res = 20 / 20;
console.log(res);//结果为1

res = 5 / 2;
console.log(res);//结果为2.5

也可以同 - 0、 * 1 、 / 1、操作将其转化为number类型

任何值做： -、*、/操作都会自动转化为number类型

取余操作%

对两个值或变量进行取余操作，并返回计算结果。

非number类型都会转换为number类型，再操作。

var res = 8 % 2;
console.log(res);//结果为0

res = 9 % 2;
console.log(res);//结果为1

res = 8 % 0;
console.log(res); //NaN

res = 8 % null;
console.log(res); //NaN  

res = 8 % true;
console.log(res); //0

一元运算符

自增运算符

++（一元运算符），变量在自身的基础上增加一；变量使用自增运算符后，原变量的值会被改变；

var a = 10;
console.log("a++ = " + a); //10
a++;
console.log("a++ = " + a); //11

a = 10;
console.log("a++ = " + a); //10
a--;
console.log("a-- = " + a);//9

自增分为两种方式：前置递增，后置递增。前++： 比如：++i;后++： 比如：i++;无论前++，后++ ， 原变量的值都会自增1。

a = 10; //初始值
//使用自增操作运算符 --- ++在后
a++;
console.log("a = " + a); //11

a = 10; //初始值
//使用自增操作运算符 --- ++在前
++a;
console.log("a = " + a); //11

++i和i++的相同点：都会立刻使原来变量的值自增1

不同点：i++表达式的值为变量自增前，++i表达式的值为变量自增后

a = 10;
console.log("前: a = " + a); //10
console.log("中: a = " + a++); //10  
console.log("后: a = " + a); //11

a = 10;
console.log("前: a = " + a); //10
console.log("中: a = " + ++a); //11
console.log("后: a = " + a); //11

d = 20;
var res = d++ * ++d;
/*
    分析：
     步骤1：d++表达式的值为：20
     步骤2：执行++操作： d = 21
     步骤3：++d表达式的值为：22
     步骤4：20 * 22
 */
console.log("res = " + res); //440
console.log("d = " + d); //22

自减运算符

自减运算符和自增运算符相似

逻辑运算符

js提供来的三种逻辑运算符：

• && 与逻辑
• || 或逻辑
• ! 非逻辑

非逻辑运算符：！

• 将布尔类型的值进行取反操作：！true = false， !false = true;

• 对于非布尔类型进行取反操作：先转换为布尔类型，再进行取反操作

• 使用!!对非布尔类型转换为Boolean类型，原理和Boolean()函数一样

//对布尔类型进行操作
var x = true;
//x进行非运算
x = !x;
console.log(x); //false

//也可以多次取反
x = !!x;
console.log(x); //fasle

//对非boolean类型进行操作
x = 10;
x = !!10;
console.log(x); //true

var temp = 10;
console.log(typeof temp); //number
console.log(temp); //10

temp = !temp;
console.log(typeof temp);//boolean
console.log(temp); //false

//将任意类型转换为Boolean类型
temp = "10";
console.log(typeof temp); //string
temp = !!temp;
console.log(typeof temp);//boolean
console.log(temp); //true

与逻辑运算符&&

运算规则：

• true && true true
• true && false false
• false && true false
• false && false false

js中的与操作都是"短路"操作，如果一个值为false，则第二个值不进行操作

或逻辑运算符||

运算规则：

• true || true true

• true || true true

• false || true true

• false || false false

见真就真，js中的或操作也是"短路"操作，如果第一个值为true，则第二个值不执行操作

逻辑运算符（非布尔类型）

对于非布尔值进行逻辑运算，会先转化为布尔类型，再进行运算，最后按照规则返回原始值。

与运算：（非布尔）

​ 遇见true返回下一个值
​ 遇见false返回当前值

或运算：（非布尔）

​ 遇见true返回当前值

​ 遇见false返回下一个值

在js中可以对布尔值和非布尔值进行逻辑运算，其它语言则不行。

赋值运算符

​ 赋值运算符：将等号右边的值赋值给等号左边
​ 符合赋值运算符： +=、-=、*=、/=、%=

var res = 10;
console.log(res);//10

//使用+=赋值运算符
res += 10; //等价于：res = res + 10;
console.log(res);//20

//使用-=赋值运算符
res -= 10; //等价于：res = res - 10;
console.log(res);//10

//使用%=赋值运算符
res %= 3; //等价于：res = res % 3;
console.log(res);//1

关系运算符

关系运算符：
>:大于 <:小于 >=:大于等于 <=:小于等于 ！= 不等于

​ 作用：用来比较两个值直接的大小关系，关系成立返回true， 不成立返回false

var res = 10 > 20;
console.log(res); //false

var res = 10 <= 20;
console.log(res); //true

关系运算符：非数值情况

• 非数值情况，会先转换为数值再进行比较
• 任何值和NaN比较返回false
• 两侧都是字符串，则按位比较Unicode编码

res = 1 >= true;
console.log(res); //true

//任何值和NaN比较返回false
res = 1 >= NaN;
console.log(res); //false

//abc转换为NaN，
res = 1 < "abc";
console.log(res); //false

//true转化为1 ，false转化为0
res = true > false;
console.log(res);//true

//字符串 --- 比较的不是数值，是unicode编码
res = "1" < "5";
console.log(res);//true
//1的unicode编码和5的unicode编码进行比较
res = "11" < "5";
console.log(res);//true

字符串比较方式：

• 按位置进行比较
• 位数相同，下一位，没有返回大

//首位进行比较，直接返回结果
res = "abc" < "b";
console.log(res); //a(65)bc < b(66) 返回true

//第一b和b进行比较，相同，第二个b没有对应位数进行比较，则当前数大
res = "bbb" < "b";
console.log(res); //false

相等运算符

1、== ：表示是否相等运算

如果==两边类型不相同，则会进行类型转换，再比较

用来比较两个数是否相等，相同返回true， 不相同返回false

//使用==判断
console.log(1 == 1); //true

var i = 20;
console.log(i == 20); // true

//发生自动类型转换
//字符串转化为number
console.log("1" == 1); //true

//将字符串和布尔都转换为number
console.log(true == "1"); //true
console.log(true == "abc"); //false

特殊值：

undefined衍生自null，所以这两个值判断返回true

NaN不和任何值相等，包括它自身

通过isNaN()函数来进行判断变量是否为NaN，是NaN返回true，否则返回false。

2、 != : 不等运算符

用来比较两个数是不相等，不相同返回true， 相同返回false

如果!=两边类型不相同，则会进行类型转换，再比较

3、 ===：全等判断

也进行两个值是否先等的判断，但类型不同，则不进行类型转换，直接返回false

 console.log("123" === 123); //false

4、 !==：不全等判断

console.log(1 != "1"); //false
console.log(1 !== "1"); //true

三元运算符（条件运算符）

使用三个操作数： 条件表达式 ？ 语句一 ： 语句二;

执行逻辑：

• 如果条件表达式为true，则整个语句返回语句一；
• 如果条件表达式为false，则整个语句返回语句二：

条件表达式如果为非Boolean类型则默认转换后再执行