JavaScript的运算符

JavaScript的运算符

运算符的分类：

1. 算术运算符
2. 逻辑运算符
3. 赋值运算符
4. 关系运算符
5. 条件运算符

算术运算符

二元算术运算符

+ 运算符

可以用于数字的加运算，也可以用于字符串的拼接。优先用于字符串的拼接。
使用规则：

1. 任何值与字符串作“+”运算，先转换为字符串，再拼接。结果类型为字符串。
2. 除字符串外的任何值作“+”运算，先转换为数字（通常转换为0或1或NaN），再相加。结果类型为数字。
3. NaN与任何数字相加，结果都为NaN。结果类型为数字。
4. 其他类型与空串作“+”运算，结果类型为字符串。利用这一特性，可作为隐性类型转换。如：

123 + ""         //“123”，数字123转换为字符串“123”
true + ""		 //"true",布尔 true 转换为字符串 "true"

-、*、/、% 运算符

-、*、/、%分别表示数学运算中的减、乘、除、模运算，主要用于数字的运算中。使用规则与 Java 中类似，主要区别：

1. JavaScript 中，所有的数字都是浮点型的，除法的结果也是浮点型的，如：

5 / 2 = 2.5		//并不同于Java中，5 / 2 = 2

2. 浮点数也可以取模，如：

6.5 % 2.1 = 0.2
-6.5 % 2.1 = -0.2		//结果的符号与第一个操作数的符号保持一致

3. 其他类型数据作 -、*、/、% 运算，先转换为数字类型，再进行运算。利用这一特性，可作为隐性类型转换。如：

"123" - 0 = 123;     //字符串"123"转换成数字123；
true * 1 = 1;        //布尔true,转换成数字1，再乘以1，结果为数字1；
"456" / 1 = 456;

一元算术运算符

+ 运算符

作用：把操作数转换成数字（或者NaN）。如果操作数本身为数字，返回这个数字。
隐性转换：

var x = 1 , y = true , z = "-123" , p = null , q；
+x = 1;
+y = 1;
+z = -123;
+p = 0 ;
+q = NaN;

- 运算符

作用：相当于 0 - 操作数 的值。
隐性转换：

var x = 1 , y = true , z = "-123" , p = null , q；
-x = -1;
-y = -1;
-z = +123;
-p = 0 ;
-q = NaN;

- 与 ~ 运算符的区别

~ 运算符叫按位非，相当于改变变量的符号并减一。如：

var x = 4;
console.log(-x);	//输出-4
console.log(~x);	//输出-5

++ 自增运算符

作用：原变量在自身的基础上立即增加1
分类：

1. 后++（a++）
2. 前++（++a）
   无论前++，还是后++，变量的值会立即加1。
   a++的值等于原来变量的值（这里把a++、++a当成了一个整体，更容易理解）
   ++a的值等于新变量的值

-- 自减运算符

作用：原变量在自身的基础上立即增减1
分类：

1. 后--（a--）
2. 前--（--a）
   无论前- -，还是后- -，变量的值会立即减1。
   a-- 的值等于原来变量的值（这里把 a--、--a 当成了一个整体，更容易理解）
   --a 的值等于新变量的值

例子：
var a = 10;
a1 = a++;		//a1等于原来的值为10,a=11
var a = 10;
a2 = ++a;		//a2等于新值为11,a=11
var a = 10;
a3 = a++ + ++a + a;		//过程：a++ = 10,a=11;++a=12,a=12;10+12+12=44

逻辑运算符

包括：

1. 逻辑与（&&）
2. 逻辑或（||）
3. 逻辑非（!）

逻辑与 &&

作用：只有当两端的操作数（包括表达式）均为 true，才返回 true，其余均返回 false。

逻辑与的短路效应：只有当第一个操作数为 true 时，才去计算第二个操作数，否则直接返回 false。

var x = 10 , y = 20 ;
true && x++;	//第一个操作数为 true，运行第二个表达式,x 加1
false && y++;	//第一个操作数为 false，直接返回第一个值，不运行第二个表达式,y 不变
console.log(x);		//输出 11
console.log(y);		//输出 20

如果操作数不是布尔类型，其他类型先自动转换成布尔类型，作逻辑与运算，并返回原类型的值。

var x = "123"
console.log( true && x );		//输出"123"

1. 如果第一个操作数的值为 true , 返回第二个操作数的值。

console.log( 2 && 1 );		//输出 1

2. 如果第一个操作数的值为 false , 返回第一个操作数的值。

console.log( NaN && "123" );	//输出 NaN

逻辑或 ||

作用：只用当两端的操作数均为 false，才返回 false，其余均返回 true。

逻辑或的短路效应：只有当第一个操作数为 false时，才去计算第二个操作数，否则直接返回 true。

var x = 10 , y = 20 ;
true || x++;	//第一个操作数为 true，直接返回 true，不运行第二个表达式,x 不变
false || y++;	//第一个操作数为 false，运行第二个表达式,y 加1
console.log(x);		//输出 10
console.log(y);		//输出 21

如果操作数不是布尔类型，其它类型先自动转换成布尔类型，作逻辑或运算，并返回原类型的值。

var x = "123"
console.log( false || x );		//输出"123"

1. 如果第一个操作数的值为 true , 返回第一个操作数的值。

console.log( 2 && 1 );		//输出 2

2. 如果第一个操作数的值为 false , 返回第二个操作数的值。

console.log( NaN && "123" );	//输出 "123"

逻辑非 ！

作用：对一个布尔值进行取反操作。true 变 false，false 变 true。
如果操作数不是布尔类型的，先自动转换成布尔类型，再进行取反。可以利用这一特性，将其他类型的数据进行两次非运算，实现隐性类型转换成布尔类型，如：

var x = "123";
console.log(!!x); 	//输出true，字符串"123"转换成布尔true

逻辑运算符的优先级

逻辑非 > 逻辑与 > 逻辑或

赋值运算符

= 赋值运算

作用：将右值赋以左变量。从右往左运算。
除此之外，还有以下常见的带操作的赋值运算：

+=	a+=5	等价于	a=a+5
-=	a-=5	等价于	a=a-5
*=	a*=5	等价于	a=a*5
/=	a/=5	等价于	a=a/5
%=	a%=5	等价于	a=a%5

关系运算符

意义：比较两个操作数的大小。如果关系成立，返回 true ；如果关系不成立，返回 false。
关系运算符有：==、===、!=、!==、<、<=、<==、>、>=、>==;
规则：

1. 如果两个操作数都是数字，会按照数学上的大小，进行比较，返回相应的关系。
2. 如果两个操作数都是字符串，会根据字符的 Unicode 编码的字典序进行比较。

console.log( "123" < "4");	//输出 true，字符"1"与字符"4"比较，"1"小，所以:"123"小于"4"
console.log( "abc" < "ab");	//输出 false，一个字符一个字符比较，a==a,b==b,第二个字符串已经没有了，所以第二个字符串小

3. 只要两个操作数不全是字符串，先自动转换成数字，再进行比较。

console.log( false > true);	//输出 false，false 自动转换为数字0，true 自动转换为数字1，0<1

4. NaN 与任何值比较，都返回 false 。

console.log( 5 <= undefined);
console.log( 5 >= undefined);
//两个输出都是 false ，因为undefined 转换成数字类型的NaN

5. 尽量不要使用中文字符串进行关系运算，容易出现错误。

等于（==）与恒等（===）的区别

1. 等于（==）与不等于（!=）运算符作关系运算时，如果两个值的类型不同，会自动转换成相同的数据类型（通常转换成数字）。只要数据相等，则相等。
2. 恒等（===）与不恒等（!==）运算符作关系运算时，不会作自动类型转换。只有类型相等，数据也相等，才会恒等。

console.log("123" == 123);	//true ，"123"自动转成123
console.log("123" === 123);	//false ， 数据类型不等

//特殊情况
//尽管 null 自动类型转换为0，但 null 与 0 不等于
console.log( null == 0 );	//false 
//null 与 undefined 相等不恒等
console.log( null == undefined );	//true
console.log( null == undefined );	//false
//NaN 与 任何值不相等，包括它本身，可以使用isNaN()函数来判断是否是NaN
var x = NaN ;
console.log( x==x );		//false
//以下是判断 x 是否是 NaN 的两种常见的方式
console.log( x != x );		//true
console.log( isNaN(x) );	//true

条件运算符

唯一一个三元运算符 ？：
语法：条件语句？语句1：语句2
执行流程：先判断条件语句，为 true，执行语句1，为 false，执行语句2。
如果条件语句不是布尔类型，先转换为布尔类型，再判断 true 或 false。

运算符的优先级

1. JavaScript 的运算符的优先级按照下表的顺序，越在上边，优先级越高。
   

2. 如果优先级相同的，从左往右算。

3. 添加圆括号可以改变优先级。

注意点

++、==、<=等由多个符号组成的运算符是一个整体，不可分开来写（中间添加空格等都是不可以的）。

拓展：如何使用 Unicode 编码

1. JavaScript中使用，格式：\u四位十六进制编码，如：

console.log("\u2634");		//输出 ☴

2. 网页中使用，格式：&#十进制编码，这里的十进制是，Unicode 编码表中的四位十六进制转换成的十进制。大小可通过font-size属性来控制，如：

<h1> &#4568</h1>

显示结果，如下：