javascript常用的运算符

算术运算符

+ - * / % ++ --

基础

console.log(10 + 20); // 30
console.log(10 - 20); // -10
console.log(10 * 20); // 200
console.log(20 / 10); // 2
// %: 取余  模 
console.log(20 % 3); // 2
console.log(20 % 2); // 0

++

++: 在自身基础上加1 可以放在变量的前面 也可以放在后面

++和其他运算放在一起的时候, ++在前, 先自加, 在执行其他运算, ++在后, 先运行其他运算, 在自加

var a = 10;
a++; // 10 + 1 = 11 --> a
console.log(a); // 11
++a; // 11 + 1 --> 12 --> a
console.log(a); // 12

// ++和其他运算放在一起的时候, ++在前, 先自加, 在执行其他运算, ++在后, 先运行其他运算, 在自加
var b = 10;
console.log(b++); // 输出和++放在一起 先输出b=10 在自加10+1=11
console.log(b); // 11
​
var c = 10;
console.log(++c); // 输出和++放在一起, 先自加10+1=11 在输出c=11
console.log(c); // 11

--

--: 自减 可以放在前面可以放在后面

--和其他运算在一起的时候, --在前, 先自减, 在执行其他运算; --在后, 先执行其他运算, 在自减

// --: 自减 可以放在前面可以放在后面
var d = 10;
d--;
console.log(d); // 9
--d;
console.log(d); // 8
​
// --和其他运算在一起的时候, --在前, 先自减, 在执行其他运算; --在后, 先执行其他运算, 在自减
var m = 10;
console.log(m--); // 输出和-- 先输出m=10 再自减m=9
console.log(m); // 9
​
​
var n = 10;
console.log(--n); // 先自减 m = 9  再输出m=9

隐式转换规则

隐式转换的规则主要发生在算术运算符之间:

\1. 有字符串的加法就是拼接

\2. 没有字符串的加法的其他运算, 尽可能的将数据都转成数值类型后在计算 隐式调用Number方法

\3. 数值之间正常计算

\4. 遇到复杂数据类型, 会先调用数据的toString方法转换成字符串之后, 在参考上述规则

console.log(1 + 'a'); // 1a
console.log('a' + true); // atrue
console.log('a' + null); // anull
​
​
console.log('a' - 10); // NaN - 10 = NaN
console.log(true * 100); // 1 * 100 = 100
console.log(100 / null); // 100 / 0 = Infinity
​
​
console.log('a' + {}); // a[object Object]
console.log('a' + [1,2]); // a1,2
​
var a = '10';
a++;
console.log(a); // 11

赋值运算符

赋值: = += -= *= /= %=

将等号右边的赋值给左边

var a = 10; // 将10给了a
// a+=b: a = a + b;
a += 100;
console.log(a); // 110
​
a -= 20;
console.log(a);
​
a*=2; // a = a * 2;
console.log(a);
​
a /= 3;
console.log(a); // 60
​
a %= 50; // a = a % 50; 
console.log(a); // 10

比较运算符

> >= < <= 用左右两边的数据进行比较判断 如等式成立 返回true 否则返回false

console.log(1 > 2); // false
console.log(2 >= 1); // true
console.log(1 < 2); // true
console.log(1 <= 2); // true

== ===用于数据的比较判断

== 只比较值是否相等

=== 比较值是否相等 比较数据类型是否一致

// == ===用于数据的比较判断
// == 只比较值是否相等
console.log(1 == 1); // true
console.log(1 == '1'); // true
// === 比较值是否相等 比较数据类型是否一致
console.log(1 === '1'); // 值相等 数据类型不等 false

!=: 只比较值是否不相等

!==: 比较值是否不相等 比较数据类型是否不一致

// !=: 只比较值是否不相等 
console.log(1 != '1'); // false
console.log(1 != 2); // true
// !==: 比较值是否不相等 比较数据类型是否不一致
console.log(1 !== 1); // false
console.log(1 !== '1'); // 数值1 !== 字符串1 值相等 数据类型不等 true
字符串的比较: 从左往右依次比较每一个字符的ASCII码

''空字符串--0 '0'--48 '9'--57 'A'--65 'Z'--90 'a'--97 'z'--122

console.log('10000' < '2' ); // true 49 < 50 ? true
console.log('1000' < '1'); // 48 < 0 ? false

逻辑运算符

逻辑: && || !

&&

&&: 左右两边各自有一个判断条件, 如果两个条件都为真, 整个返回true, 如果有一个条件为假, 整个返回false

全真为真 一假为假

console.log(true && false); // false
console.log(1 < 2 && 2 < 3); // true && true true
console.log(1 > 2 && 2 < 3); // false && true false

||

||: 左右两边各自有一个判断条件, 如果两个条件都为假, 整个返回false, 如果有一个条件为真, 整个返回true

全假为假 一真为真

console.log(true || false); // true
console.log(1 < 2 || 2 > 3); // true || false true
console.log(1 > 2 || 2 > 3); // false || false false

!

!: 取反 返回的结果是true false

如果原来的是true 取反返回false 如果原来是false 取反就是true

js中为假: false 0 NaN '' null undefined

console.log(!''); // true
console.log(!1); // false
console.log(!{}); // false

短路运算

短路运算: 取值(两个值选择一个) 判断运算

逻辑与短路

逻辑与短路: 如果&&左边第一个条件为假, 第二个条件不执行 如果第一个为真 执行第二个条件

var a = 1, b = 1;
var c = --a && --b; // --a a = 0 0是假
console.log(c, a, b);
​
​
var m = 1, n = 1;
var d = m-- && n--; // 1 1是真 (m--: m =0)  1 && n-- n = 1 d = 1 n-1 = 0
console.log(d, m, n); // 1 0 0

逻辑或短路

逻辑或短路: 如果第一个条件为真, 第二个条件不执行 如果第第一个条件为假 执行第二个条件

var o = 1, p = 1;
var mn = o-- || p--; // o-- --在后 1 || p-- o=0  1 || p-- 1为真 p--不执行
console.log(mn, o, p); // 1 0 1

三目运算符

三目: 条件 ? 条件为真的时候执行的代码 : 条件为假的时候执行的代码;

代码只能有一句代码

1 > 2 ? alert('哇、1你牛了啊') : alert('还是2厉害');

运算符优先级