JavaScript之运算符(一)

运算符,刚接触你可能会感觉“它很小”,但真正接触下来才能体会它的“多样”与“奇妙”。

一元运算符

一元算术运算符用于一个单独的操作数,并产生一个新值。在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
    原文作者:张chuner
    原文地址: https://www.jianshu.com/p/65d2ef279c21
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞