运算符, 刚接触你可能会感觉 "它很小", 但真正接触下来才能体会它的 "多样" 与 "奇妙".
一元运算符
一元算术运算符用于一个单独的操作数, 并产生一个新值. 在 javascript 中, 一元运算符具有很高的优先级, 而且都是右结合(right-associative).
1, 一元加 与 一元减
(1), 一元加运算符以一个加号 (+) 表示, 放在数值前面, 对数值不会产生任何影响.
- var num = 25;
- num = +num; //25
在对非数值应用一元加运算符时, 会调用 Number()转型函数对这个值进行转换
- var s1 = '01';
- var s2 = '1.1';
- var s3 = 'z';
- var s4 = -1;
- var b = false;
- var f = 1.1;
- var o = {
- valueOf: function() {
- return - 1;
- }
- };
- s1 = +s1; //1
- s2 = +s2; //1.1
- s3 = +s3; //NaN
- s4 = +s4; //-1
- b = +b; //0
- f = +f; //1.1
- o = +o; //-1
- console.log(1 + +"2" + "3"); //33 第一个 +"2" 中的加号是一元操作符, 空格 +"2" 会变成数值 2, 因此 1+ +"2" 相当于 1+2 等于 3. 然后和后面的字符串 3 合并, 就变成了 "33"
注意: 在 new Date()前面使用一元加符号, 可以把日期字符串, 转换为日期毫秒数
- console.log(new Date());//on Jul 11 2016 20:25:54 GMT+0800 (中国标准时间)
- console.log(+new Date());//1468239954076
(2), 一元减运算符主要用于表示负数.
当一元减运算符用于非数值时, 会对该值使用 Number()转型函数进行转换, 再将得到的数值转换成负数
- var s1 = '01';
- var s2 = '1.1';
- var s3 = 'z';
- var b = false;
- var f = 1.1;
- var o = {
- valueOf: function() {
- return - 1;
- }
- };
- s1 = -s1; //-1
- s2 = -s2; //-1.1
- s3 = -s3; //NaN
- b = -b; //0
- f = -f; //-1.1
- o = -o; //1
一元加和一元减运算符主要用于基本的算术运算, 也可以用于转换数据类型.
2, 前增量 / 前减量 与 后增量 / 后减量 运算符
++ 运算符 使变量自增 1, 放在变量 a 前为前置增量运算符, 放在变量 a 后为后置增量运算符
-- 运算符使变量自减 1, 放在变量 a 前为前减量运算符, 放在变量 a 后为后置减量运算符.
- <script>
- var num=10;
- a=num++;
- console.log(num);// 输出 11
- console.log(a) ;// 输出 10
- console.log(num++); // 输出 11
- console.log(num); // 输出 12
- </script>
- <script>
- var bnum=10;
- b = ++bnum;
- console.log(bnum);// 输出 11
- console.log(b) ;// 输出 11
- console.log(++b); // 输出 12
- console.log(bnum); // 输出 11
- </script>
从以上对比可以看出来:
前增量 / 前减量运算符 会先运行增量 / 减量运算, 再进行赋值;
而后增量 / 前减量运算符会先进行赋值, 再进行增量 / 减量运算.
换句话说, 当 ++, 或者 -- 符号放在变量之前, 其优先级会高于赋值运算符, 反之 则低于赋值运算符.
一般来说:
- var x = 1;
- ++x;
- // 相当于
- var x = 1;
- x = x +1;
但是 ++x 并不总是和 x = x+1 完全一样,++ 运算符从不进行字符串连接操作, 它总是会将操作数转换为数字并增 1
- var x = '1';
- ++x;//2
- var x = '1';
- x = x + 1;//'11'
二元运算符
1, 加法运算符
Javascript 的加性运算符会在后台转换不同的数据类型.
(1), 如果两个操作数都是数值, 按照常规的加法计算:
某个运算数是 NaN, 那么结果为 NaN.
-Infinity 加 -Infinity, 结果为 -Infinity.
Infinity 加 -Infinity, 结果为 NaN.
+0 加 +0, 结果为 +0.
-0 加 +0, 结果为 +0.
-0 加 -0, 结果为 -0.
例:
- var a = 2;
- console.log(a+NaN); //NaN 如果有一个操作数是 NaN, 则返回 NaN
- (注意: 有时不是直接以 NaN 形态出现)
- console.log("A"+"B"+3); //NaN 先把 "A" 和 "B" 用 Number 函数转换为数值, 结果为 NaN, 任何数和 NaN 做加减法的结果都为 NaN
- console.log("A"+"B"+"3"); //NaN3 "A" 和 "B" 用 Number 函数转换为数值, 结果为 NaN, 然后和字符串 "3" 拼接
- console.log(Infinity+Infinity);//Infinity
- console.log(Infinity+(-Infinity));//NaN
- console.log((-Infinity)+(-Infinity));//Infinity
- console.log((+0)+(+0));//+0
- console.log((+0)+(-0));//+0
- console.log((-0)+(-0));//-0
(2), 如果有一个操作数是字符串
如果两个操作数都是字符串, 相当于字符串拼接
如果只有一个操作数是字符串, 则将另一个操作数转化为字符串, 然后再执行字符串拼接
如果有一个操作数是对象, 数值或者布尔值, 首先调用它们的 toString()方法取得对应的字符串, 然后执行拼接(包括 null,undefined)
部分案例:
- String + String
- var a = '10',
- b = '20';
- console.log(a + b); //1020
- String + Object
- var a = '10',
- b = {
- _key: 20
- };
- console.log(a + b); //10[object Object]
- //Object.prototype.toString()方法返回一个表示该对象的字符串.
- String + Number
- var a = '10',
- b = 20;
- console.log(a + b); //1020
- String + Boolean
- var a = true,
- b = '20';
- console.log(a + b); //true20
- String + null
- var a = null,
- b = '20';
- c = 3;
- console.log(a + b); //null20
- console.log(a + c); //3 null 数值转换为 0
- String + undefined
- var a = undefined,
- b = '20';
- console.log(a + b); //undefined20
- console.log(undefined + 3); //NaN
(3), 加法的独立操作
- var a = 10,
- b = 5;
- var result = 'hello world 10 + 5 =' + a + b;
- console.log(result); //'hello world 10 + 5 = 105'
- var a = 10,
- b = 5;
- var result = 'hello world 10 + 5 =' + (a + b);
- console.log(result); //'hello world 10 + 5 = 15'
- // 如果进行算术加法运算, undefined 转换为 NaN,null 转换为 0,false 转换为 0,true 转换为 1/
- console.log(undefined + undefined); //NaN
- console.log(null + null); //0
- console.log(false + false); //0
- console.log(true + true); //2
- // 如果进行字符串连接, undefined 转换为'undefined',null 转换为'null',false 转换为'false',true 转换为'true'
- console.log('' + undefined); //'undefined'console.log('' + null); //'null'
- console.log('' + false); //'false'console.log('' + true); //'true'
- // 单数值数组和 valueOf()返回值为数值的自定义对象会转换为数值
- console.log(1 + []); //1
- var o = {
- valueOf: function() {
- return - 1;
- }
- }
- console.log(1 + o); //0
- // 其他原生对象则转换为字符串
- console.log(1 + {}); //'1[object Object]'
- console.log(1 + [1, 2]); //'11,2'
- console.log(1 + new Date()); //'1Thu Jun 16 2016 10:27:13 GMT+0800 (中国标准时间)'
- console.log(1 + /0/); //'1/0/'
2, 减法运算符
(1), 如果两个操作数都是数值, 按照常规的减法计算:
某个运算数是 NaN, 那么结果为 NaN.
Infinity 减 Infinity, 结果为 NaN.
-Infinity 减 -Infinity, 结果为 NaN.
Infinity 减 -Infinity, 结果为 Infinity.
-Infinity 减 Infinity, 结果为 -Infinity.
+0 减 +0, 结果为 +0.
-0 减 -0, 结果为 -0.
+0 减 -0, 结果为 +0.
某个运算符不是数字, 那么结果为 NaN.
如果运算数都是数字, 那么执行常规的减法运算, 并返回结果.
- console.log(2-NaN); //NaN 如果有一个操作数是 NaN, 返回 NaN
- console.log(Infinity-Infinity); //NaN
- console.log(-Infinity-(-Infinity)); //NaN
- console.log(Infinity-(-Infinity)); //Infinity
- console.log(-Infinity-Infinity); //-Infinity
- console.log(+0 - (+0)); //+0
- console.log(-0 - (+0)); //-0
- console.log(-0 - (-0)); //+0
(2), 如果有一个操作数不是数值
如果有一个操作数是 ` 字符串 `,` 布尔值 `,`null`,`undefined`, 则在后台调用 `Number()` 将其转化为数值, 再进行减法运算.
如果有一个操作数是对象 , 则调用对象的 `valueOf()` 方法取得表示该对象的数值. 如果得到的值是 NaN, 减法结果是 NaN. 如果对象没有 valueOf()方法, 调用它的 toString()方法, 并将得到的字符串转化为数值.
- Number - String
- var a = 10,
- b = '10';
- console.log(a - b); //0
- var a = 10,
- b = '';
- console.log(a - b); //10
- var a = 10,
- b = 'true',
- c = 'false';
- console.log(a - b); //NaN
- console.log(a - c); //NaN
- //Number('true') => NaN 或者 Number('false') => NaN
- // 这里不能使用 Number('false') == NaN 或者 Number('false') === NaN
- // 因为 console.log(NaN == NaN) => false
当使用 Number()进行数值转化, 如果是一个字符串:
1. 如果字符串中只包含数字 (包括前面带正负号) 将其转化为十进制;
2. 如果字符串中包含有效的浮点格式, 将其转化为对应的浮点数值;
3. 如果字符串中包含有效的 16 进制, 将其转化为大小相同的十进制数值;
4. 如果字符串为空, 则转化为 0;
5. 如果字符串不符合以上条件, 则转化为 NaN
- Number - Boolean
- var a = 10,
- b = true,
- c = false;
- console.log(a-b); //9
- console.log(a-c); //10
- Number - null
- var a = 10,
- b = null;
- console.log(a-b); //10
- Number - undefined
- var a = 10,
- b = undefined;
- console.log(a-b); //NaN
- Number - Object
- var a = 10,
- b = {_key:1};
- console.log(a-b); //NaN
- console.log(1 - {});//NaN
- console.log(1 - [1,2]);//NaN
- console.log(1 - /0/);//NaN
- console.log(1 - []);//1
3, 乘法运算符
用于计算两个数值的乘积, 会通过 Number()转型函数将非数值类型转换为数值或 NaN
- + Infinity * 0; //NaN
- - Infinity * 0; //NaN
Infinity * 非 0 数值; //Infinity 或 - Infinity
Infinity * Infinity; //Infinity
4, 除法运算符
执行第一个操作数除以第二个操作数的运算, 也会通过 Number()转型函数将非数值类型转换为数值或 NaN
- Infinity / Infinity; //NaN
- 0 / 0; //NaN
非 0 数值 / 0; //Infinity 或 - Infinity
Infinity / 0; //Infinity
Infinity / 非 0 数值; //Infinity
5, 求模运算符
求模 (余数) 操作符是由一个百分号 (%) 表示, 是第一个操作数除以第二个操作数的余数
- //r 是余数, n 是被除数, d 是除数,
- //q 是整数, 在 n/d 为负时为负, 在 n/d 为正时为正, 它应该在不超过 n 和 d 的商的前提下尽可能大
- r = n - (d * q)
求模结果与第一个操作数的符号保持一致
- console.log(5 % 2);//1
- console.log(5 % -2);//1
- console.log(-5 % 2);//-1
- console.log(-5 % -2);//-1
被除数是 Infinity, 或除数是 0, 则求模结果是 NaN
- Infinity % 0 = NaN
- Infinity % Infinity = NaN
Infinity % 非 0 数值 = NaN
非 0 数值 % 0 = NaN
在多数编程语言中, 求模运算符只接受整数为操作数, 而在 ECMAScript 中, 还接受浮点操作数, 但由于浮点数不是精确的值, 无法得到完全准确的结果
console.log(6.5 % 2.1);//0.19999999999999973
来源: http://www.jianshu.com/p/65d2ef279c21