运算符原来也可以有这么多内容

运算符

---

一、算术运算符

1.+ 加：
	（1）小数点运算时会产生误差
		var a=0.1;
		var b=0.2;
		var s=a+b;
		console.log(s);//0.3000000000000004
	（2）只要有一个是字符类型，另一个会被转换为字符类型，并且首尾相连
		var a="4";
		
		var b=1;
		var s=a+b;
		console.log(s); //41
		
		var b=true;//4true
		
		var b=null;//4null
		
		var b={a:1};//4[object object]
		
		var b=[];//4
		
		var b=[1];//41
	（3）一侧是布尔值，重要的是另一侧值，会根据另一侧转换
		var a=true;
		
		var b=1;
		var s=a+b;
		console.log(s);//2
		
		var b="1";//true1
		
		var b;//NaN
		
		var b=null;//1 （Number）
		
		var b={a:1};//true[object object]  一旦遇到对象都会隐式转换为字符相加
		
		var b=[];//true 转换为字符
2.-  减
3.*  乘
4./  除
5.%  取余数（保留整数）
	任何- * / %全部遵照数值运算规则，两侧都转换为数值运算

二、一元运算符

1.++  累加
	（1）a++:先执行表达式后再自增，执行表达式时使用的是a的原值
		var s=a;
		a=a+1;//a++
		
		var a=2;
		var y=a++;
		console.log(y,a);//2,3
	(2)++a:先自增再执行表达式，执行表达式时使用的是自增后的a
		a=a+1;//计算后返回值
		
		var a=2;
		var y=++a;
		console.log(y,a);//3,3
2.--  递减
	(1)a--:先执行表达式后再自减，执行表达式时使用的是a的原值
	(2)--a:先自减再执行表达式，执行表达式时使用的是自减后的a

三、关系运算符

1.<
2.>
3.<=
4.>=
5.==:弱比较，如果左右两边的比较类型不同，它们会转换成相同类型，再进行比较
	(1)"3"==3;//true
		左右两边一个是字符串，一个是数字，则会将字符串转换成数字进行比较；
	(2)2==true;//false
		左右两边一个是数字，一个是布尔值，则会把布尔值转成数字进行比较；
	(3)"3"==true;//false
		左右两边一个是字符串，一个是布尔值，则会都往数字进行转换；
	(4)" "==true;//false
		布尔值转换为字符串
	(5){a:1}==true;//false
		不能转换为对象，所以不相同
	(6)"[object object]"=={a:1};//true
		{a:1}转换为字符串"[object object]"
	(7)"a"==["a"];//true
		数组转换为字符串
	(8)[]==[];//false  
		左边有一个自己的地址，右边也有，两个地址不一样；
		对象和对象比较时，比较的是空间地址，不是相同的空间，结果就是false
	(9)[]==0;//true
		对象和数字比较会把对象转化为数字
	(10)0=="";//true
	(11)""==false;//true
	(12)0==false;//true
	(13)[]==' ';//true
		把两边都转化为数字0了，对象和字符串会把两边都转化为数字
	(14)![]==false;//true
		![]优先级高，优先将[]看作对象，所以[]就是true,取反后是false
	(15)[]==false;//true
		数组比较时，如果比较布尔值，优先将数组转换为字符串，再比较
	(16)![]==[];//true
		[] ->true,  ![] ->false , [] ->""->false
	(17)null==undefined;//true
		两边是null和undefined,它们都转换成布尔值（false），所以相等
		console.log(null=undefined);//true
	(18)undefined==false;//false
		null==false;//false
		"undefined"==undefined;//false
		"null"==null;//false
		""==undefined;//false
		""==null;//false
		null和undefined和其它任何值都不相等
	(19)NaN==NaN;//false
6.===:精确比较，即左右两边要求类型和数字都是相同的
7.!=
8.!==

四、逻辑运算符

1.!  逻辑非：
	遇到 ! ,优先将后面的内容先转换为布尔值，再取反
2.&&  逻辑与：
	true && true =true 返回最后一个值
	true && false = false 返回false对应的值
	false && true = false 返回false对应的值
	false && false = false 返回第一次遇见false对应的值

	var a="" && 10;
	console.log(a);//输出空字符串
3.||  逻辑或：
	true || true = true;返回第一个遇到true的对应值
	true || false = true; 返回true对应的值
	false || true = true; 返回true对应的值
	false || false = false; 返回最后一个false对应的值

	var a= 20 || 10;
	console.log(a);//20

	var obj;
	obj=obj || {a:1};
	console.log(obj);//{a:1}

五、赋值运算符

1.=  赋值
	看到一个=号时，就是表示将等号右侧的结果赋值给等号左侧，并且返回一个值
	var a=1;
	a=a+1;//2

	if(a=a-1){
		console.log(a);//除0之外都为true
	}
2.+= 加法赋值
	a+=5;
	a=a+5;//在原来的基础上增加5
	a+="";//转换为字符串
3.-= 减法赋值
	a-=5;  -->  a=a-5;
4.*= 乘法赋值
	a*=5;  -->  a=a*5;
5./= 除法赋值
	a/=5;  -->  a=a/5;
6.%= 取模赋值
	连续取模赋值是无意义的
	a%=3;
	a%=3;
7.<<= 左移赋值
8.>>= 有符号右移赋值
9.>>>= 无符号右移赋值

六、位运算符

1.~   位非运算符
	数值加一取负
	var a=5;
	a=~a;
	console.log(a);//-6
2.&   位与运算符
	console.log(56&35);//32
	111000
	100011
	100000
3.|  位或运算符
	console.log(35|34);//35
	100011
	100010
	100011
4.^  位异或运算符
	 相同为0，不同为1
	console.log(35^26);//57
	100011
	011010
	111001

	可用作加密解密：
	console.log(273621^1234);
	console.log(272391^1234);
5.<< 左移位运算符
	console.log(24<<2);//96
	1100000//左移后在后面补两个0
6.>> 右移位运算符
	console.log(96>>2);//24
	110000//删除最后两位

	console.log(1<<30);
	最大只能右移30

七、条件运算符(三目运算符)

variable = boolean_expression ? true_value : false_value;
前面的条件判断，如果返回true,就将第一个结果返回前面，否则将第二个结果返回前面。

当三元运算符遇到返回布尔值时，直接返回条件即可
ck2.checked=ck1.checked===true ? false : true;
ck2.checked=ck1.checked!==true;
ck2.checked=!ck1.checked;
	
var b=a>5 ? false : true;
var b=a<=5;

三目嵌套
var b=a>5 ? 0 : a<2 ? 1 : -1;

var a=1;
var b=a-- ? a++ : ++a;//b=0 a=1

var a=1;
var b=a-=    0 ? a+=1 : a+=2;//-2
三目优先级高于赋值运算符

八、运算符优先级

1.. [] ()	字段访问、数组下标、函数调用以及表达式分组
2.++ -- - ~ ! delete new typeof void	一元运算符、返回数据类型、对象创建、未定义值
3.* / %	乘法、除法、取模
4.+ - +	加法、减法、字符串连接
5.<< >> >>>	移位
6.< <= > >= instanceof	小于、小于等于、大于、大于等于、instanceof
7.== != === !==	等于、不等于、严格相等、非严格相等
8.&	按位与
9.^	按位异或
10.|	按位或
11.&&	逻辑与
12.||	逻辑或
13.?:	条件
14.= oP=	赋值、运算赋值
15.,	多重求值