ES5学习——操作符及类型转换

ES5的操作符和类型转换跟强数据类型语言有相同的地方也有不同的地方，在这里做一个简单的总结，也希望能有更好的理解。

操作符 

  1.算数运算符：

跟我们平时用的运算符一样

        + 加

        -  减

        *  乘

        /  除  （除会有小数）

        %取余

 2.一元运算符：

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

        a++ ：后加加，先将a的操作做完后，a再自增1

        ++a：先加加，先a自增1，再做后续关于a的操作

        a--：后减减，先将a的操作做完，再a自减1

        --a：先减减，先将a自减1，再做a的操作

var a=10,b=true;
console.log(a++,b++); //10 1  先console再自增.++在后 就是后加  先输出再加
console.log(a,b);     //11 2   先自增，再console。++在前，就是先加。先加再输出
var  c = 1-a--;       //先c=1-a =-10,再a--  a=11-1=10
console.log(a,c);     //10 -10

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

3.赋值运算符

单个=表示赋值，将右侧的值赋给左侧的变量。
可以和其他算术运算符连用，复合赋值，常用的有*=，/=，%=，+=，-=

4.比较运算符：

> < >=  <= === !==，比较的结果返回true或者false

需要注意的是：===  先比较数据类型，再比较值

5.逻辑运算符

逻辑与&&（同真才真，有假则假）

            true&&true=true;

            true&&false=false;

            false&&true=true;

            false&&false=false;

可应用于任意数值。如果有一个操作数不是布尔类型，逻辑与就不一定返回boolean类型；

如果第一个操作数是null,NaN,undefined,false,0,''可被转换为false的值的时候返回该值；
 

            console.log(null&&true);       //null
            console.log(NaN&&true);        //NaN
            console.log(undefined&&true);  //undefined
            console.log(0&&true);          //0
            console.log(''&&true);         //''
            console.log('false'&&true);      //false

              为什么会出现这种情况呢？这是因为&&在判断时会短路，如果第一个值可被转换为false，那么第二个值即使是true，也会判断为false，所以判断false时就原值输出了！
                    
 

 逻辑或||（有真则真，同假才假）

            true||true=true;

            true||false=true;

            false||true=true;

            false||false=false;

1.如果两个操作数都是null,NaN,undefined,0,'' ' '可被转换为false的值的时候返回该值

console.log(null||null);          //null
console.log(NaN||NaN);            //NaN
console.log(undefined||undefined);//undefined
console.log(0||0);               //0
console.log(''||'');             //''/<empty string>

 2.如果第一个操作数是null,NaN,undefined,false,0,"" 则返回第二个操作数

（第一个值已经逻辑false了，最终是false还是true取决于第二个值）

            console.log(null||true);          //true
            console.log(NaN||true);            //true
            console.log(undefined||true);     //true
            console.log(0||true);               //true
            console.log(''||true);             //true
            console.log(null||false);          //false
            console.log(NaN||false);            //false
            console.log(undefined||false);     //false
            console.log(0||false);               //false
            console.log(''||false);             //false

3.第一个操作数是逻辑有，就返回该值

 逻辑非
                    ！（表达式）
该操作符应用任何类型数值都返回一个【布尔值】。先将任意类型的数值转换为Boolean，然后取反
                    有值----逻辑有----返回值
                    !a = !Boolean(a)
                    !0 //true
                    !"" //true
                    !NaN //true
                    !false //true
                    连用两次逻辑非 ，就可以将任意数据类型转化为Boolean类型
                    !!a ==> Boolean(a)
                    !!"" //false

6.三目运算符

variable = boolean_expression ? true_value : false_value;
如果boolean_expression为true,将true_value赋给variable，否则将false_value赋给variable   
        例如：求任意两个数之间最大值
                   

function max(m,n){
return m>n?m:n; //如果m>n为true返回m,如果m>n为false,返回n
                    }

数据类型的转换   

1、转换为boolean类型  undefined，null，0，NaN，''，转换为false其他转换为ture
            1.转换方式    !!
            2.函数 Boolean（）

            console.log(!!null)       //false
            console.log(!!undefined)  //false
            console.log(Boolean(NaN)) //false
            console.log(Boolean(0))   //false
            console.log(Boolean(''))  //false
            console.log(Boolean(' ')) //true 空格字符

2、转换为string类型
            1.toString()  不建议用这种方法，因为不确定是否内置toString函数。
            如果变量是number类型，默认情况下toString()是以十进制格式返回字符串表示，通过传递参数，可以输入二进制八进制十六进制等格式字符串值；
                   

var num=10;
console.log(num.toString());          //10     10进制
console.log(num.toString(2));        //1010  2进制
console.log(num.toString(8));        //12      8进制
console.log(num.toString(10));      //10      10进制都是String类型

            2.String()
                    var a=998;
                    console.log(String(a));//字符串类型的998
     
            3.+''空字符串

                1）m+n，如果m，n都是基本数据类型，并且其中有一个是string类型，那么+进行字符串拼接操作；
                2）m+n，如果m，n都是基本数据类型，并且都不是字符串类型，那么+进行转number操作
 

                    var a = 123 ;
                    console.log(a+'1');           //1231 String类型
                    console.log(a+1);            //124 number类型
                    console.log(true+1);        //2 number类型
                    console.log(1+1+1+'1');   //31 String类型

            

3、转换为number类型
            1. +  强制转换，一元运算符，本质是使用了Number（）包装器
                    console.log(+true); //1
                    console.log(+false);//0
            2.Number()包装器函数
                    2.1 转换的值是其他数据类型
                       

                        console.log(Number(true));             //1
                        console.log(Number(false));            //0
                        console.log(Number(null));              //0
                        console.log(Number(undefined));     //NaN
                        console.log(Number(010));             //8
                        console.log(Number(0x10));           //16
                        console.log(Number(''));                //0
                        console.log(Number(' '));               //0

                    2.2 转换的值是string类型
                       

console.log(Number("123"));       //123 仅包含数值 转换为数值
console.log(Number("234.1"));    //234.1 解析为对应的小数
console.log(Number("+12.1"));    //12.1 首位为符号位，其余为为数值，转换为对应的数值
console.log(Number("0xa"));       //10 如果仅包含十六进制格式，转为为对应的十进制的值
console.log(Number("010"));      //10 【注意】不会当做八进制被解析，结果为10！！！！
console.log(Number(""));           //0 空字符串被转换为0
console.log(Number("1+2.3"));   //NaN  符号位出现在其他位置，解析为NaN
console.log(Number("123ac"));  //NaN  包含其他字符： NaN

            3.parseInt()函数
                1.如果转换的值是null，undefined，boolean直接转换为NaN

console.log(parseInt(null),parseInt(undefined),
parseInt(true),parseInt(''),parseInt(' '));//都是NaN；
console.log(parseInt(true));//NaN

                2.如果转换的是number，舍去小数点后的值原样输出
                3.如果转换的是string
                  

parseInt("123");     //123；如果仅包含数值，转换为对应的数值
parseInt("234.1");  //234；小数点后面的数值省略
parseInt("+12.1");  //12；首位为符号位，其余为为数值，转换为整数
parseInt("1+2.7");  //1；符号位出现在其他位置，保留符号位前面的数值
parseInt("0xa");     //10；如果仅包含十六进制格式，转为为对应的十进制的值
parseInt("010");     //10；【注意】不会当做八进制被解析，结果为10
parseInt("");          //NaN；空字符串被转换为NaN
parseInt("123ac"); //123;如果首位为数值，依次向后解析，找到连续的数值，
//直到遇到第一个非数值的，将之前获取的数值转换为Number返回  

            4.parseFloat()函数
                1.如果转换的值是null,undefined,boolean，均转换为NaN
                2.如果转换的值是Number 数值原样输出
                3.如果转换的值是string
                 

parseFloat("123"))      //123；如果仅包含数值，转换为对应的数值
parseFloat("234.1"));    //234.1；保留小数点后面的数值    
parseFloat("+12.1"));    //12.1； 首位为符号位，其余为为数值，转换为整数    
parseFloat("1+2.6"));    //1；符号位出现在其他位置，保留符号位前的数值    
parseFloat("0xa"));      //0； 【注意】不会当做十六进制来解析。
parseFloat("010"));        //10； 【注意】不会当做八进制被解析，结果为10
parseFloat(""));          //NaN；空字符串被转换为NaN
parseFloat("1+2.3"));  //1;
parseFloat("123.3ac"));//123.3;如果首位为数值，依次向后解析，找到连续的数值，
//直到遇到第一个非数值的，将之前获取的数值转换为Number返回

注意

默认情况下，ECMAScript会将小数点后带有6个零以上的浮点数转化为科学计数法。

0.0000003 => 3e-7

在进行算术计算时，所有以八进制十六进制表示的数值都会被转换成十进制数值。

保存浮点数需要的内存是整数的两倍，因此ECMAScript会不失时机将浮点转换为整数

例如： var a = 1; var b = 1.0; //都将解析为1

避免测试某个特点的浮点数值，是使用IEEE754数值的浮点计算的通病

例如： 0.1+0.2 //结果不是0.3，而是0.30000000000000004