Javascript 运算符

Javascript运算符包含算术运算符、赋值运算符、一元运算符、关系运算符、逻辑运算符、位运算符、条件运算符。

算术运算符

算术运算符包含：加（+）、减（-）、乘（*）、除（/）、取模（%）。
字符串相加时，另一种数据隐式转换为字符型.String()，字符相加时，首尾相连。

var a = 3;
var b = "4";
console.log(a+b);//34

//等号是赋值，因此先运算等号右边的结果，然后赋值给等号左边
var s=10;
s=s+"";
console.log(s);//10

布尔值相加，不包含加字符，布尔值转换为数值，除字符外所有内容都是隐式转换为数值运算 Number()。

var a=true;
var b=3;
var c=true;
var d;
var e=null;

console.log(a+b);//4
console.log(a+c);//2
// 任何数值加NaN都为NaN
console.log(a+d);//NaN
console.log(a+e);//1

• 数组转换为字符串时是将数组的元素转换为字符串相连。
• Object 对象相加时都会转换为字符串相加。

var a={a:1};
var b={b:1};
console.log(a+b);//[object Object][object Object]

var arr=[1,2,3];//数组转换为字符串时是将数组的元素转换为字符串相连
var a={a:1};
console.log(arr+a);//1,2,3[object Object]
console.log([]+[]);//

减法 乘法 除法 取模都遵循转换为数值运算。

var a=true;
var b=false;
var c="5";
var d;
var e=null;
var f={a:1};
var g = 2;
console.log(a*b);//0
console.log(a*c);//5
console.log(a*d);//NaN
console.log(a*e);//0
console.log(a*f);//NaN
console.log(c*g);//1

赋值运算符

赋值运算符包含：乘法/赋值（*=）、除法/赋值（/=）、取模/赋值（%=）、加法/赋值（+=）、减法/赋值（-=）、左移/赋值（<<=）、有符号右移/赋值（>>=）、无符号右移/赋值（>>>=）。

var a = 3;
//a += 5;//a = a+5;
//a += "";//快速将a转换为字符串
//a *= 5;//a = a*5;
var s =a+=2;
console.log(s,a);//5 5
//赋值运算符是有结果的
if(a-=2){
	console.log(a);//3
}

一元运算符

一元运算符包含：累加（++）、累减（–）。
一元运算符强制将值转换为数值+1。

var a="3";
a++;//4 一元运算符强制将值转换为数值+1
a+=1;//31

要注意a++ 和 ++a 的结果相同，但返回结果不同。

• a++ 先返回a，再执行a=a+1;
• ++a 先执行a=a+1，再返回a;

var a=3;
console.log(a+=1);//4 a=a+1   a->返回结果
console.log(a++);//3 a->返回出来  a=a+1;
console.log(++a);//4 a=a+1  a->返回结果
// a++和++a a的结果相同 返回结果不同

var x=1;
if(x--){
    console.log("aa");//会打印一次
}

var x=1;
if(--x){
    console.log("aa");//不会打印
}

var x=1;
var y=x++ + x + x++ + x++ + x++;
console.log(x,y);//5 12

关系运算符

关系运算符包含：大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（= =）、绝对相等（= = =）、不等（!=）、绝对不等于（!===）。
字符串判断大小时，先判断字符串首字符的ascii 或者 Unicode码值，如果相同判断后面字符的比较结果。

var a = "aa";
var b = "ab";
console.log(b>a);//true

除字符串外，变量进行比较时，先隐式转换为数值，再进行比较。
字符串与数值比较时，字符串转换为数值再比较。

console.log(true>false);//true 隐式转换为数值
console.log(true>"");//true
console.log("a">1);//false 字符串与数值比较时，字符串转换为数值再比较
console.log(undefined>null);//false

= = 比较值 ，= == 比较值和类型。

console.log("1"==1);//true
console.log(""==0);//true
console.log(0==false);//true
console.log(""==false);//true
console.log("1"==1);//true
console.log("1"===1);//false

• 特殊情况，null 只跟 undefined 相等。
• 特殊情况，NaN永远不和任何内容相等，包括NaN。

console.log(null=="");//false
console.log(null==0);//false
console.log(null==false);//false

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

• isNaN ( ) 里面的内容会自动隐式转换为数值

var a="a";
if(a==NaN){
   // 判断a是否是NaN
   // isNaN()里面的内容会自动隐式转换为数值
   console.log("a==NaN");
}
if(isNaN(a)){
   console.log("非数值");
}

对象中，变量的值为对象的引用地址

var obj={a:1};
var obj1={a:1};
console.log(obj==obj1);//false 引用地址不同

关系运算符：将其他数据类型转成数字进行比较。
逻辑运算符：将其他数据类型使用 Boolean ( ) 转成布尔类型进行比较。

console.log([]==0);//true
//[].valueOf().toString() 得到空字符串
//Number("")==0成立

逻辑运算符

逻辑运算符包含：逻辑非（ ! ）、逻辑与（ && ）、逻辑或（ | | ）。
逻辑与（ && ）：如果有一端转换为boolean值是false，就把这个值返回出去；如果两端转换为boolean都是true，返回&&运算符右侧的值，先运行左侧，再运行右侧，（遇到假的就返回假，都是真的就返回最后一个真的，从左往右运算最终结果）。

var a = 1;
a = a-- && ++a;//1
a = a++ && --a;//1
a = --a && ++a;//0
console.log(a);

逻辑或（ | | ）：如果 | | 的左侧的结果是ture，就直接返回左侧，不运算右侧，熔断，（遇到真的就返回真，都是假的就返回最后一个假的）。

var a=1;
a=--a || a++;//0
a=a-- || a++;//1
console.log(a);

逻辑非（ ! ）：先将内容转换为布尔值，然后取反值，所有！运算符得到的结果都是布尔值。

var obj;
obj = obj || {};
var obj1 = {};
//obj1 转成Number 是true，取反就是 false
console.log(!obj1);//false
//obj 转成Number 是true，!obj1 是false
console.log(obj==!obj1);//false
//引用类型数据存在堆中，栈中存储的是地址，地址是唯一的，所以不相等
console.log(obj==obj1);//false

关系运算符：将其他数据类型转成数字进行比较。
逻辑运算符：将其他数据类型使用 Boolean ( ) 转成布尔类型进行比较。
逻辑非的优先级高于关系运算符

//![]=false（空数组转成布尔得到true,然后取反是false
//[]转成字符串是空字符串，空字符串转成boolean是false
console.log([]==![]);//true
//引用类型数据存在堆中，引用地址不一样
console.log([]==[]);//false
console.log([]!=[]);//true
//!{}是false
//{}不能直接转Number，先转成字符串是"[object object]",Number([object object])是true
console.log({}==!{});//false
//引用类型数据存在堆中，栈中存储的是地址
console.log({}={});//false