JavaScript操作符

操作符

一个变量在以下情况下为假，其他情况都为真
1.空字符串 ‘’
2.0
3.null
4.undefined
5.false

1.算数运算符

加 + ； 减 - ； 乘 * ； 除 / ； 取余 %

通常情况下，加减乘除取余需要number类型的值

  var n1 = 1;
  var n2 = 2;
  var n3 = 10;
  console.log(n1+n2);   //3
  console.log(n3%n2);  //0

递增递减操作符
++表示每次递增1，- -表示每次递减1。常用于遍历操作，比如要遍历某个数组，求所有值的和，需要将数组中的每个值逐个取出叠加，每次取值的时候都需要将索引递增1。

后置++，–，先使用a，后++，–
前置++，–，先++，–，再使用a

	//笔试题：请预测结果
	var a = 10;
	var b = a++;  //b10  a11
	var c = ++a;  //c12  a12
	var d = --a;  //d11  a11
	var e = a--;  //e11  a10
	console.log(a,b,c,d,e);  //10 10 12  11 11

允许非number类型的操作数进行运算，在运算之前，一般需要先将其他数据类型转换为数字类型再进行运算，当操作数中出现了字符串，则变成了字符串拼接操作。

若出现string类型做加法运算时，可以实现字符串拼接操作

  var s1='hello';
  var s2='xiaoming';
  var str = s1+s2;  // helloxiaoming
  console.log(str);

如果两边有一边为string类型时，会将另外一边变量转换为string类型，做拼接

  console.log('hello'+1);  //hello1
  console.log(1+'undefined');  //1undefined

如果两边为null，Boolen, undefined类型做运算，先将其他数据类型转换为数字类型再进行运算

true:1 ; false:0 ; null: 0; undefined: NaN

  var bool=true;  //true=1; 进行隐式转换
  var bool2=false;  //false=0;
  console.log(1+bool);   //2
  console.log(1+bool2);   //1

 var n=null;  //null = 0
  console.log(n+1);  //1
 
  var m= undefined;
  console.log(m+1); //NaN

加 + ：相当于调用Number()，将其他数据类型转换为number类型
减 - ：将一元减应用于数值时，数值会变成负数。
将一元减应用于非数值时，遵循与一元加操作符相同的规则，最后将得到的数值转化为负数。

var a = "123";
 console.log(+a);  //123
console.log(-a);  //-123

var b = 123;
console.log(+b); //123
console.log(-b);  //-123

console.log(+'123');  //123
console.log(+'null');  //NaN
console.log(+'hello');  //NaN
console.log(+'123a');  //NaN

console.log(+'12.3');   //12.3
console.log(+'12.3.4'); //NaN

console.log(+'016');  //16  不识别8进制，识别成10进制
console.log(+'0xaa'); //170  //识别16进制

console.log(+' 123');  //123
console.log(+'12 3');  //NaN
console.log(+' 123 ');  //123

console.log(+'');   //0
console.log(+' ');  //0

//将boolean使用+转换成number
console.log(+true); //1 
console.log(+false);  //0
console.log(+undefined);  //NaN
console.log(+null);   //0

var obj = {
  name:"briup",
  valueOf:function(){
  return "1";
  }
}
console.log(obj+1);//"11"

2.比较运算符

相等= = ; != ; 完全相等 = = = ; != =; >; >=; <; <=

优先级低于算术运算符，高于赋值运算符

var res = 1+1 >= 2;  //计算运算符优先级 大于 比较运算符优先级 大于 赋值运算符
console.log(res);  //true

运算结果一般都为boolean （true / false）

= =, !=只比较值，不比较类型
当比较基本数据类型的时候比较值，当值的类型不一致时候，先将其数据类型转换为一致再进行比较。
==: 只需要值相等，无需类型相等；null, undefined 在 == 下互相等且自身等
当比较引用数据类型的时候比较引用地址

var a = 3;
var b = "3";
a == b;     //基本数据类型，转换为数值类型进行比较  true

//比较两个字符串是否相等
 var str1='xiaoming';
 var str2='xiaoming';
 console.log(str1 === str2);  //true  基本数据类型内容相同则完全相同

var c = {};
var d = {};
c == d;    //引用数据类型 ，比较引用地址  false

** == = , != = **既比较值也比较类型

当比较基本数据类型的时候比较值，值的类型不一致时候返回false，值的类型相同再对比值

 console.log(1== '1');   //= =只比较值，不比较类型 true 
 console.log(1 === '1');  //===既比较值也比较类型  类型不同 false
 console.log(1 === 1); // 类型相同，比较值，值相同  true

当比较引用数据类型的时候比较引用地址

// 比较两个对象是否相等
 var obj1 ={
   name:'xiaoming'
 }
 var obj2 ={
   name:'xiaoming'
 }
 console.log(obj1===obj2); //引用数据类型尽管内容相同也为false

想要判断两个对象内容是否相同时：
JSON.stringify( ) 序列化：将对象转为JSON字符串
JSON.parse( ) 反序列化：将JSON字符串转为对象

  var obj1_str = JSON.stringify(obj1);  //序列化，将对象转为字符串
  console.log(obj1_str);
  var obj2_str = JSON.stringify(obj2);
  console.log(obj1_str===obj2_str); 
 
  var obj3 = JSON.parse(JSON.stringify(obj1));//将对象序列化再反序列化，得到的obj3与obj1地址不同，为深拷贝

3.逻辑运算符

与 && ；或 || ；非 ！

&&两边都为真才为真
||只要一边为真就为真
! 取反

  var a=1;
  var b=-1;
  var c=0;
  if(a>0 && b>0 && c >0){
    console.log('yes')
  }else{
    console.log('no')
  }
  
  if( !(a>0 || b>0)){
    console.log('yes')
  }else{
    console.log('no')
  }

逻辑与&&(同真才真，有假则假)

同时为true结果才为true
当第一个表达式为真，整个表达式的结果取决于第二个表达式，返回第二个表达式
当第一个表达式为假，整个表达式的结果就可以确定，返回第一个表达式

短路操作： false && 表达式 = false
第一个操作数不是Boolean类型(第一个操作数不为false），直接返回第二个操作数
第一个操作数是[null,NaN,undefined,false,0,""] （第一个操作数值为false），直接返回该操作数

var a = "hello" && "world"    // "world"  第一个操作数不是boolean类型，返回第二个数
var a = null && "world"        // null  第一个操作数为null，直接返回
console.log(''&&123);  //''  空字符串 
console.log(0&&null);  //0
console.log(123&&345); //345
console.log(123&&undefined); //undefined
console.log(!!(123&&undefined));  //false   即 !!undefined
console.log(!!123&&undefined);  //undefined

逻辑或 ||(有真则真，同假才假)

当第一个表达式为真，整个表达式的结果就可以确定，返回第一个表达式
当第一个表达式为假，整个表达式的结果取决于第二个表达式，返回第二个表达式

有一个为true结果就为true
同时为false结果才为false

短路操作： true || 表达式 = true
第一个操作数是[null,NaN,undefined,false,0,""]->false,然后和第二个操作数进行运算获得结果 （第一个操作数不能确定结果，第二个操作数确定结果）
第一个操作数不是Boolean类型不是上面特殊的，直接返回第一个操作数 （第一个操作数可以直接确定最终结果）

var a = "hello" || "world"    // "hello"  第一个操作数不是布尔类型和特殊类型，直接返回
var a = null || "world"        // "world"   第一个操作数为特殊值，返回第二个操作数
console.log(0||123);  //123
console.log(NaN||undefined); //undefined 
console.log(123||345);   //123
console.log(123||undefined); //123
console.log(''||123);  //123

非（NOT）

该操作符应用任何类型数值都返回一个布尔值。先将任意类型的数值转换为Boolean，然后取反
!a ==> !Boolean(a)

[null,NaN,undefined,false,0,""]->false
!false=true
true,’字符串’,100,obj ->true
!true=false

!0  //true
!""  //true    
!NaN    //true    
!false    //true

连用两次逻辑非 ，就可以将任意数据类型转化为Boolean类型
!!a ==> Boolean(a)
!!false=false
!!true=true
!!"" //false

4. 三目运算符

exp1 ? exp2 : exp3
当exp1为真的时候，返回exp1，否则返回exp3

//求任意两个数之间最大值
function max(m,n){
  return m>n?m:n;    //如果m>n为true返回m,如果m>n为false,返回n
}

  console.log(a>0 ? 'yes' : 'no');
  var res = b<=0 ? 'yes' : 'no';
  console.log(res);

 var res1 = 1 ? 'yes' : 'no'; //数值隐式转换为布尔类型， 1转换为true

  var res2 = -1 ? 'yes' : 'no'; // -1隐式转换为true

   var res3 = 0 ? 'yes' : 'no'; // 0转换为false

 var str = 'xiaoming';
 var res4 = str ? 'yes' : 'no'; //字符串类型隐式转换为true

 var str1 = ' ';
 var res5 =str1 ? 'yes' : 'no'; //空字符串隐式转换为false

 var n = null;
 var res6 = n ? 'yes' : 'no'; //null类型默认转换为false

注意：由于JS是弱类型，在进行运算的时候非常灵活。比如算术运算符不限于数字的运算、逻辑运算符不限于布尔类型的运算。

5.逗号运算符

可以在一条语句中执行多个操作

 var a=1, b=2, c=3; //一次可以声明多个变量，变量直接用逗号隔开
 console.log(a,b,c);

6.位运算符

按位与&，按位或|，按位异或 ^
原码、反码、补码
先将数值类型的值转换为二进制，

按位与运算：全为1时才为1，不全为1时为0
按位或运算：有一个为1时就为1，没有1时就为0
按位异或运算：相同时（都为1或都为0）则为0，不相同则为1

 console.log(a&c); //0000 0001 & 0000 0011  =0001   为1
 console.log(a|c); // = 0011  为3
 console.log(a^c); // = 0010  为2

问题：&& 与 &区别，|| 与|区别？
&&为逻辑与（两边都为真时才为真），&为按位与（每一位都为1时才为1）
||为逻辑或（两边有一个为真时就为真），|为按位或（有一位为1时就为1）