操作符
一个变量在以下情况下为假,其他情况都为真
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)