javascript —— 运算符

算术运算符

javascript中的算术操做主要经过算术运算符来实现，算术运算符包括一元算术运算符和二元算术运算符两种。

一元算术运算符

一元算术运算符用于一个单独的操做数，并产生一个新值。在javascript中，一元运算符具备很高的优先级，并且都是右结合(right-associative)

一元算术运算符包括一元加法(+)、一元减法(-)、递增(++)和递减(--)

一元加(+)

一元加运算符以一个加号(+)表示，放在数值前面，对数值不会产生任何影响

var num = 25;
num = +num; //25

在对非数值应用一元加运算符时，会调用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

在new Date()前面使用一元加符号，能够把日期字符串，转换为日期毫秒数

console.log(new Date());//on Jul 11 2016 20:25:54 GMT+0800 (中国标准时间)
console.log(+new Date());//1468239954076

一元减(-)

一元减运算符主要用于表示负数

var num = 25;
num = -num;//-25

当一元减运算符用于非数值时，会对该值使用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

一元加和一元减运算符主要用于基本的算术运算，也能够用于转换数据类型

递增(++)

递增++运算符对其操做数进行增量(加1)操做，操做数是一个左值(lvalue)(变量、数组元素或对象属性)。运算符经过Number()转型函数将操做数转换为数字，而后给数字加1，并将加1后的数值从新赋值给变量、数字元素或者对象属性

var age = 29;
++age;
//至关于
var age = 29;
age = age +1;

递增++运算符的返回值依赖于它相对于操做数的位置。当运算符在操做数以前，称为前增量(pre-increment)运算符，它对操做数进行增量计算，并返回计算后的值。当运算符在操做数以后，称为后增量(post-increment)运算符，它对操做数进行增量计算，但返回未作增量计算的(unincremented)值

var i = 1, j = ++i;
//i=2 j=2

var i = 1, j = i++;
//i=2 j=1

递减(--)

递减--运算符的操做数也是一个左值，它经过Number()转型函数把操做数转换为数字，而后减1，并将计算后的值从新赋值给操做数

和递增++运算符同样，递减--运算符的返回值依赖于它相对操做数的位置，当递减运算符在操做数以前，操做数减1并返回减1以后的值。当递减运算符在操做数以后，操做数减1并返回减1以前的值

var age = 29;
--age;
//至关于
var age = 29;
age = age - 1;

前增量操做符与执行语句优先级相同，整个语句会从左向右求值

var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2;//21
var num4 = num1 + num2;//21

后增量操做符在包含它们的语句被求值以后才执行

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2;//22
var num4 = num1 + num2;//21

二元算术运算符

二元算术运算符包括加法(+)、减法(-)、乘法(*)、除法(/)和求余(%)

加法(+)

在多数程序设计语言中，加法一般是简单的数字运算符，但在ECMAScript中，加法运算有大量的特殊行为，不只能够进行数值加法运算，也能够进行字符串链接

【1】若是其中一个操做数是对象，则对象会转换为原始值：日期对象经过toString()方法执行转换，其余对象经过valueOf()方法执行转换。因为多数对象valueOf()方法没法返回一个原始值，因而会经过toString()方法来执行转换

[注意]除了单数值数组会转换为数字外，其余原生对象都会经过toString()方法转换为字符串形式

【2】在进行了对象到原始值的转换后，若是其中一个操做数是字符串的话，另外一个操做数也会转换成字符串，进行字符串链接，不然，两个操做数都将转换成数字或NaN，进行加法操做

//单数值数组和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/'

若是进行算术加法运算，undefined转换为NaN，null转换为0，false转换为0，true转换为1

console.log('' + undefined);//'undefined'
console.log('' + null);//'null'
console.log('' + false);//'false'
console.log('' + true);//'true'

所以，利用加号运算符的特性，能够利用''+任意类型值转换为字符串

减法(-)

相对于加法，减法就简单的多，只涉及到数字的减法运算。使用Number()转型函数将非数值类型转换为数值或NaN

console.log(1 - {});//NaN
console.log(1 - [1,2]);//NaN
console.log(1 - /0/);//NaN
console.log(1 - []);//1

加法有一个特殊之处，在于时间Date对象进行加法运算时使用toString()转换为字符串，而在其余数学运算，包括减法、乘法、除法、求余等运算中，都是使用Number()转换函数将时间Date对象使用valueOf()转换为数字

console.log(new Date() + 1);//'Thu Jun 16 2016 11:11:49 GMT+0800 (中国标准时间)1'
console.log(new Date() - 1);//1466046941641

undefined转换为NaN，null转换为0，false转换为0，true转换为1

console.log(1 - undefined);//NaN
console.log(1 - null);//1
console.log(1 - false);//1
console.log(1 - true);//0

乘法(*)

乘法操做符由一个星号(*)表示，用于计算两个数值的乘积，会经过Number()转型函数将非数值类型转换为数值或NaN

+ Infinity * 0;//NaN
- Infinity * 0;//NaN
Infinity * 非0数值;//Infinity或-Infinity
Infinity * Infinity;//Infinity

除法(/)

除法操做符由一个斜线(/)表示，执行第一个操做数除以第二个操做数的运算，也会经过Number()转型函数将非数值类型转换为数值或NaN

Infinity / Infinity;//NaN
0 / 0;//NaN
非0数值 / 0;//Infinity或-Infinity
Infinity / 0;//Infinity
Infinity / 非0数值;//Infinity

求模(%)

求模(余数)操做符是由一个百分号(%)表示，是第一个操做数除以第二个操做数的余数

//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

关系运算符

关系运算符用于测试两个值之间的关系，根据关系是否存在而返回true或false，关系表达式老是返回一个布尔值，一般在if、while或for语句中使用关系表达式，用以控制程序的执行流程

javascript提供了===、!==、==、!=、<、<=、>、>=8个关系运算符，分为4类介绍关系运算符

恒等运算符

恒等运算符'==='，也叫严格相等运算符，首先计算其操做数的值，而后比较这两个值，比较过程没有任何类型转换，比较过程以下：

【1】若是两个值的类型不相同，则返回false

console.log(1 === '1');//false
console.log(1 === [1]);//false

【2】若是两个值都是Undefined、Null、Boolean、Number、String相同原始类型的值，值相同，就返回true，不然，返回false

console.log(undefined === undefined);//true
console.log(null === null);//true
console.log(true === true);//true
console.log(false === false);//true
console.log(1 === 1);//true
console.log(2.5 === 2.5);//true

[注意]不论什么进制的数字，在进行关系比较时，最终都转换为十进制进行运算

console.log(10 === 0xa);//true

在数字Number类型中，有一个值比较特殊，是NaN(not a number)，它与任何值都不相等；此外，数字Number类型中存在着+0和-0，虽然其符号不一样，但值相等

console.log(NaN === NaN);//false
console.log(+0 === -0);//true

两个相同字符串值表现为：相同的长度和相同的字符对应相同的位置

console.log('abc' === 'abc');//true
console.log('abc' === 'acb');//false

【3】若是两个值引用同一个对象，则返回true，不然，返回false

[注意]更详细的解释是，javascript对象的比较是引用的比较，而不是值的比较。对象和其自己是相等的，但和其余任何对象都不相等。若是两个不一样的对象具备相同数量的属性，相同的属性名和值，它们依然是不相等的

console.log([] === []);//false
console.log({} === {});//false    
console.log(function(){} === function(){});//false
var a = {};
b = a;
console.log(a === b);//true

恒不等运算符(!==)又叫严格不等于运算符，操做数的比较过程与恒等运算符相同，结果取反。若是'==='的比较结果是true，则'!=='的比较结果是false；若是'==='的比较结果是false，则'!=='的比较结果是true

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

相等运算符

相等运算符'=='和恒等运算符类似，但相等运算符的比较并不严格，若是两个操做数不是同一类型，相等运算符会尝试进行一些类型转换，而后再进行比较

当两个操做数类型相同时，比较规则和恒等运算符规则相同

console.log(undefined == undefined);//true
console.log(10 == 0xa);//true
console.log(NaN == NaN);//false
console.log([] == []);//false

当两个操做数类型不一样时，相等运算符'=='会遵照以下规则：

【1】若是一个值是对象类型，另外一值是原始类型，则对象类型会先使用valueOf()转换成原始值，若是结果还不是原始值，则再使用toString()方法转换，再进行比较

[注意]日期类只容许使用toString()方法转换为字符串。相似地，时间Date对象进行加法运算时使用toString()转换为字符串，而在其余数学运算，包括减法、乘法、除法、求余等运算中，都是使用Number()转换函数将时间Date对象使用valueOf()转换为数字

【2】在对象转换为原始值以后，若是两个操做数都是字符串，则进行字符串的比较

console.log(new Date() == 'Sat Jun 25 2016 11:07:20 GMT+0800 (中国标准时间)');//true

【3】在对象转换为原始值以后，若是至少有一个操做数不是字符串，则两个操做数都将经过Number()转型函数转换成数字进行数值比较

console.log(true == 1);//true
console.log(true == 0);//false
console.log(false == '1');//false
console.log(false == '0');//true
console.log(true == 'true');//false，至关于1 == NaN

console.log([1] == 1);//true，至关于1 == 1
console.log([1] == '1');//true，至关于'1' == '1'
console.log([] == 0);//true，至关于0 == 0
console.log([] == '0');//false，至关于'' == '0'

console.log([] == true);//false，至关于0 == 1
console.log([1] == true);//true，至关于1 == 1

var a = {
    valueOf:function(){
        return 1;
    },
    toString:function(){
        return '2';
    }
} 
console.log( a == '1');//true，至关于1 == 1

var a = {
    valueOf:function(){
        return {};
    },
    toString:function(){
        return '1';
    }
} 
console.log( a == 1);//true，至关于1 == 1

[注意]若是一个值是null，另外一个值是undefined，则返回true。虽然Number(null)是0，但null和0并不相等

console.log(null == undefined);//true
console.log(null == 0);//false

[注意]空字符串或空格字符串会转成0

console.log(null == []);//false
console.log(null == '');//false
console.log([] == ' ');//false，至关于'' == ' '
console.log([] == '');//true，至关于'' == ''
console.log(0 == '');//true

不相等运算符(!=)的操做数比较过程与相等运算符相同，结果取反。若是'=='的比较结果是true，则'!='的比较结果是false；若是'=='的比较结果是false，则'!='的比较结果是true

console.log(1 != '1');//false，至关于1 != 1
console.log(true != '1');//false，至关于1 != 1
console.log('true' != 1);//true，至关于NaN != 1
console.log([1] != '1');//false，至关于'1' != '1'
console.log([1] != true);//false，至关于1 != 1

大于运算符

大于运算符(>)用于比较两个操做数，若是第一个操做数大于第二个操做数，则大于运算符的计算结果为true，不然为false

大于运算符的操做数多是任意类型，然而，只有数字和字符串才能真正执行比较操做，所以那些不是数字和字符串的操做数都将进行类型转换，类型转换规则以下：

【1】若是操做数是对象，则这个对象将先使用valueOf()转换成原始值，若是结果还不是原始值，则再使用toString()方法转换

[注意]实际上，在原生对象中，使用valueOf()方法转换为原始值的，只有转换为数字Number类型的时间Date对象，其余对象都经过toString()方法转换为字符串

【2】在对象转换为原始值以后，若是两个操做数都是字符串，则按照字母表的顺序对两个字符串进行比较，这里提到的字母表顺序是指组成这个字符串的16位unicode字符的索引顺序

console.log('b' > 'a');//true
console.log('B' > 'a');//false

console.log({} > '[a]');//true，至关于'[object Object]' > '[a]'
console.log({} > '[p]');//false，至关于'[object Object]' > '[p]'

console.log(['a'] > ['b']);//false，至关于'a' > 'b'
console.log([2] > [11]);//true，至关于'2' > '11'

【3】在对象转换为原始值以后，若是至少有一个操做数不是字符串，则两个操做数都转换成数字进行比较

[注意]在等于操做符中，时间Date()对象只容许经过toString()方法转换为字符串，而不容许经过valueOf()方法转换为数字；而在大于操做符中，时间Date()对象容许优先使用valueOf()方法转换为数字

console.log(new Date() > 100);//true，至关于1466826928667 > 100
console.log(true > [0]);//true，至关于 1 > 0

console.log(2 > 1);//true
console.log(11 > '2');//true，至关于11 > 2

console.log(NaN > 1);//false
console.log(1 > NaN);//false
console.log({} > true);//false，至关于 NaN > 1

对于数字和字符串来讲，加号运算符和比较运算符的行为有所不一样，加号运算符更偏心字符串，若是它的一个操做数是字符串，就进行字符串链接。而比较运算符则更偏心数字，只有在两个操做数都是字符串时，才进行字符串的比较

console.log(1 + 2);//3
console.log('1' + '2');//'12'
console.log('1' + 2);//'12'，至关于 '1' + '2'

console.log(2 > 1);//true
console.log('2' > '1');//true
console.log('2' > 1);//true，至关于 2 > 1

小于等于运算符(<=)并不依赖于小于或等于运算符的比较规则，而是遵循大于运算符的比较规则，结果取反。若是'>'的比较结果是true，则'<='的比较结果是false；若是'>'的比较结果是false，则'<='的比较结果是true

console.log(1 <= '0');//false，至关于1 <= 0
console.log(true <= '0');//false，至关于1 <= 0
console.log('true' <= 0);//false，至关于NaN <= 0
console.log([1] <= '0');//false，至关于'1' <= '0'
console.log([0] <= true);//true，至关于0 <= 1
console.log(1 <= 1);//true

小于运算符

小于运算符(<)用于比较两个操做数，若是第一个操做数小于第二个操做数，则小于运算符的计算结果为true，不然为false

小于运算符与大于运算符的类型转换规则相似，就再也不赘述

一样地，大于等于运算符(>=)并不依赖于大于或等于运算符的比较规则，而是遵循小于运算符的比较规则，结果取反。若是'<'的比较结果是true，则'>='的结果是false；若是'<'的比较结果是false，则'>='的结果是true

逻辑运算符

逻辑运算符对操做数进行布尔运算，常常和关系运算符同样配合使用。逻辑运算符将多个关系表达式组合起来组成一个更复杂的表达式。逻辑运算符分为逻辑非'!'、逻辑与'&&'、逻辑或'||'3种。

逻辑非

逻辑非操做符由一个叹号(!)表示，能够应用于ECMAScript中的任何值。不管这个值是什么数据类型，这个操做符都会返回一个布尔值。逻辑非操做符首先会将它的操做数转换成一个布尔值，而后再对其求反

逻辑非对操做数转为布尔类型的转换类型与Boolean()转型函数相同，只不过最后再将其结果取反。而若是同时使用两个逻辑非操做符，实际上就会模拟Boolean()转型函数的行为

console.log(!!undefined);//false
console.log(!!null);//false
console.log(!!0);//false
console.log(!!-0);//false
console.log(!!NaN);//false
console.log(!!'');//false
console.log(!!false);//false

console.log(!!{});//true
console.log(!![]);//true

console.log(!!new Boolean(false));//true
console.log(!!false);//false
console.log(!!new Boolean(null));//true
console.log(!!null);//false

逻辑与

逻辑与运算符由两个和号(&&)表示，有两个操做数，只有在两个操做数都为true时，结果才返回true，不然返回false

//逻辑与(&&)的真值表
第一个操做数        第二个操做数        结果
true              true               true
true              false              false
false             true               false
false             false              false

逻辑与操做能够应用于任何类型的操做数，而不只仅是布尔值。若是其中一个操做数不是布尔值，则逻辑与操做不必定返回布尔值

逻辑与操做属于短路操做，若是第一个操做数可以决定结果，那么就不会再对第二个操做数求值

对于逻辑与而言:
若是第一个操做数是false，则不管第二个操做数是什么值，结果都是false，则返回第一个操做数；
若是第一个操做数为true，则结果的真假和第二个操做数的真假相同，则返回第二个操做数

//除了false、undefined、null、+0、-0、NaN、''这7个假值，其他都是真值

console.log('t' && ''); //由于't'是真值，因此返回''
console.log('t' && 'f'); //由于't'是真值，因此返回'f'
console.log('t' && 1 + 2); //由于't'是真值，因此返回3
console.log('' && 'f'); //由于''是假值，因此返回''
console.log('' && ''); //由于''是假值，因此返回''

var i = 1;
var result = (true && i++);
console.log(result,i);//由于true是真值，因此执行i++，i是2，result是1

var i = 1;
var result = (false && i++);
console.log(result,i);//由于false是假值，因此不执行i++，i是1，result是false

逻辑与运算符能够多个连用，返回第一个布尔值为false的表达式的值

console.log(true && 'foo' && '' && 4 && 'foo' && true);// ''

逻辑或

逻辑或运算符由两个竖线(||)表示，有两个操做数，只有在两个操做数都是false时，结果才返回false，不然返回true

//逻辑或(||)的真值表
第一个操做数        第二个操做数        结果
true              true              true
true              false             true
false             true              true
false             false             false

一样地，逻辑或操做也能够应用于任何类型的操做数，而不只仅是布尔值。若是其中一个操做数不是布尔值，则逻辑或操做不必定返回布尔值

逻辑或操做也属于短路操做，若是第一个操做数可以决定结果，那么就不会再对第二个操做数求值

对于逻辑或而言：
若是第一个操做数是true，则不管第二个操做数是什么值，结果都是true，则返回第一个操做数；
若是第一个操做数是false，则结果的真假和第二个操做数的真假相同，则返回第二个操做数

console.log('t' || '');//由于't'是真值，因此返回"t"
console.log('t' || 'f');//由于't'是真值，因此返回"t"
console.log('' || 'f');//由于''是假值，因此返回"f"
console.log('' || '');//由于''是假值，因此返回""

var i = 1;
var result = (true || i++);
console.log(result,i);//由于true是真值，因此不执行i++，result是true，i是1

var i = 1;
var result = (false || i++);
console.log(result,i);//由于false是假值，因此执行i++，i是2，result是1

一样地，逻辑或运算符也能够多个连用，返回第一个布尔值为true的表达式的值

console.log(false || 0 || '' || 4 || 'foo' || true);// 4

条件运算符

条件运算符是javascript中惟一的一个三元运算符(三个操做数)，有时直接称作三元运算符。一般这个运算符写成?:，固然在代码中每每不会这么简写，由于这个运算符拥有三个操做数，第一个操做数在?以前，第二个操做数在?和:之间，第三个操做数在:以后

variable = boolean_expression ? true_value : false_value;

本质上，这就是基于对boolean_expression求值的结果，决定给变量variable赋什么值。若是求值结果是true，则给变量variable赋值true_value；若是求值结果是false，则给变量variable赋值false_value

条件运算符的操做数能够是任意类型，第一个操做数当成布尔值，若是它是真值，那么将计算第二个操做数，并返回其计算结果。不然，若是第一个操做数是假值，那么将计算第三个操做数，并返回其计算结果。第二个和第三个操做数老是会计算其中之一，不可能二者同时执行

其实使用if语句也会带来一样的效果，'?:'运算符只是提供了一种简写形式。下面是一个'?:'的典型应用场景，判断一个变量是否有定义(并拥有一个有意义的真值)，若是有定义则使用它，若是无定义则使用一个默认值:

greeting = 'hello ' + (username ? username : 'there');

圆括号运算符

圆括号运算符也叫分组运算符，它有两种用法：若是表达式放在圆括号中，做用是求值；若是跟在函数后面，做用是调用函数

把表达式放在圆括号之中，将返回表达式的值

console.log((1));  //1
console.log(('a')); //'a'
console.log((1+2)); // 3

把对象放在圆括号之中，则会返回对象的值，即对象自己

var o = {p:1};
console.log((o));// Object {p: 1}

将函数放在圆括号中，会返回函数自己。若是圆括号紧跟在函数的后面，就表示调用函数，即对函数求值

function f(){return 1;}
console.log((f));// function f(){return 1;}
console.log(f()); // 1

[注意]圆括号运算符不能为空，不然会报错