js中的操作符和数据类型转换

操作符

一、算数运算符
①+ /+= a+=1 —>a=a+1
②- / -=
③* / *=
④/ / /=
⑤% / %=
计算方法
1.a，b均为number类型，直接计算
2.a，b不是number类型，并且不是string和object类型，将当前变量转换为number类型计算
3.如果其中一个变量是string类型，将另一个转换为string类型进行字符串拼接（如果另一个是object类型默认调用toString）

var a=12;
var b="hello";
console.log(a+b);// 12hello
 var c={
       name:"lasa",
       age:20
       }
console.log(b+c); //hello[object,Object]

4.如果其中一个变量为object类型，另一个变量不为string，将另一个数据类型转换为number，然后调用object中的valueOf和toString进行计算
a.默认调用toString();
b.当只重写toString(),调用toString;
c.当只重写valueOf(),调用valueOf;
d.当都重写的时候，调用valueOf;

var a=10;
var o={
       name:"lisa",
       age:20
       valueOf:function(){
         return 60
         }
       }
console.log(a+o); //70

二、比较运算符 （返回值为boolean类型）
①>
②<
③>=
④<=
⑤==
不是number转化为number
null==undefined：//true
a,b为对象时，比较引用地址 同一个堆返回true

var a=10;
var b="10"
console.log(a==b); //true
console.log(a===b); //false

⑥===

全等比较不用转化，如果数据类型不一样就是false
null===undefined //false

计算方法
如果a,b不为number,将a,b转换为number类型之后再进行比较
如果两个变量均为string类型：直接比较字符编码
三、逻辑运算符
1.逻辑与&& (同真为真，有假则假）
①如果第一个操作数为null,undefined,"",0,false,NaN,直接返回第一个操作数
②如果第一个操作数为其他，返回第二个操作数。
2.逻辑或||（有真则真，同假才假）
①如果第一个操作数为null,undefined,"",0,false,NaN,返回第二个操作数
②如果第一个操作数为其他返回第一个操作数。
3.逻辑非！（直接取反）
先将a变量转换为boolean类型，然后取反
!!(a):判断a的布尔类型 （相当于将a变量转换为布尔类型）
四、三木运算符 （分支语句的简化）

表达式？value1：value2

if(today==1){
 console.log("hello")
       }
 else{
        console.log("error")
         }
today==1?console.log("hello"):console.log("error")

五、一元操作符
1.+ (相当于调用number）
+a:
如果a不是number类型，将a转化为number类型

var a=10.2;
var b=null;
var c="hello";
var d=NaN;
var o=undefined;
var m="";
console.log(+a);//10.2
console.log(+b);//0
console.log(+c);//NaN
console.log(+d);//NaN
console.log(+e);//NaN
console.log(+m); //0
console.log(typeof a);//number  所有的数据类型都是number

2.- （与+操作一样，之不过将值变成负的）

var a=10.2;
var b=null;
var c="hello";
var d=NaN;
var o=undefined;
var m="";
console.log(-a);//-10.2
console.log(-b);//-0
console.log(-c);//NaN
console.log(-d);//NaN
console.log(-o);//NaN
console.log(-m);//-0

3.++
①a++：先操作变量，然后进行++操作
②++a：先进行++操作，然后操作变量
4.–
六、位运算
负数的符号位为1，正数的符号位0
正数：原码=反码=补码
负数：反码=原码的符号位不变，其他位取反
     补码=反码+1
eg：
-3：原码:1000 0011
  反码:1111 1100
  补码:1111 1101
4:原码=反码=补码：0000 0100
-3+4=1111 1101 + 0000 0100=0000 0001（超出八位舍去）

数据类型转换

一、null和undefined没有转换函数 （他俩可以向其他类型转换，其他类型不能向他俩转换）
二、Number：将其他数据类型转换为number
1.Number()函数

 var a=true;
      var b=false;
      var c=null;
      var d=undefined;
      var e="";
      var f=010;
      var g="hello"
      var h="12.3"
      var i="+2.3"
      var j="010"
      var k="0xa"
      var l="1+1.2"
      var m="12a"
      var n="a12"
      console.log(Number(a)); //1
      console.log(Number(b));//0
      console.log(Number(c));//0
      console.log(Number(d));//NaN
      console.log(Number(e));//0
      console.log(Number(f));//8
      console.log(Number(g));//NaN
      console.log(Number(h));//12.3
      console.log(Number(i));//2.3 当第一位是+/-时，当作符号位
      console.log(Number(j));//10 字符串中的八进制不能转换
      console.log(Number(k));//10 字符串中的十六进制可以转换
      console.log(Number(l));//NaN 在字符串中只要不是数字就是NaN
      console.log(Number(m));//NaN
      console.log(Number(n));//NaN

2.parseInt()函数 将其他数据类型转化为number整型

     var a=true;
      var b=false;
      var c=null;
      var d=undefined;
      var e="";
      var f=010;
      var g="hello"
      var h="12.3"
      var i="+2.3"
      var j="010"
      var k="0xa"
      var l="1+1.2"
      var m="12a"
      var n="a12"
      
      console.log(parseInt(a));//NaN
      console.log(parseInt(b));//NaN
      console.log(parseInt(c));//NaN
      console.log(parseInt(d));//NaN
      console.log(parseInt(e));//NaN
      console.log(parseInt(f));//8
      console.log(parseInt(g));//NaN
      console.log(parseInt(h));//12
      console.log(parseInt(i));//2
      console.log(parseInt(j));//10 没有八进制
      console.log(parseInt(k));//10 有十六进制
      console.log(parseInt(l));//1  只解析能解析的
      console.log(parseInt(m));//12
      console.log(parseInt(n));//NaN  遇到不能解析就不解析了

3.parseFloat()函数 将数据类型转换为浮点数

      var a=true;
      var b=false;
      var c=null;
      var d=undefined;
      var e="";
      var f=010;
      var g="hello"
      var h="12.3"
      var i="+2.3"
      var j="010"
      var k="0xa"
      var l="1+1.2"
      var m="12a"
      var n="a12"
      
      console.log(parseFloat(a));//NaN
      console.log(parseFloat(b));//NaN
      console.log(parseFloat(c));//NaN
      console.log(parseFloat(d));//NaN
      console.log(parseFloat(e));//NaN
      console.log(parseFloat(f));//8
      console.log(parseFloat(g));//NaN
      console.log(parseFloat(h));//12.3
      console.log(parseFloat(i));//2.3
      console.log(parseFloat(j));//10 不解析八进制
      console.log(parseFloat(k));// 0 不解析十六进制
      console.log(parseFloat(l));//1 遇到不能解析就不解析了
      console.log(parseFloat(m));//12
      console.log(parseFloat(n));//NaN

三、boolean类型 将其他类型转换为布尔类型
1.!!a:将a转换为布尔类型
2.Boolean()函数
null/undefined/""/0/NaN/false 都是false
number：非0都是true
string：非空都是true
四、将其他数据类型转换为string类型
1.String()—>直接在变量值外添加引号 (包括null和undefined）
2.toString() （null和undefined没有toString()）
3.一元操作符 +
a+"": 字符串拼接