强制转化类型

 自动转化和强制转化

        自动转化实际上是JavaScript程序执行中,遇到最多的转化方式

        必须非常非常非常清楚,自动转化的原则

        强制转化,是程序员人为的将数值或者变量存储的数据数值,转化为指定的数据类型

        所有的强制转化,都不会改变变量中存储的原始数据内容

        强制转化为布尔类型

            Boolean( 数值 / 变量 ) 

                转化原则与自动转化原则相同

            var int = 100;

            // 将变量int中存储的数据,强行转化为布尔类型

            console.log( Boolean(int) );

            // int中存储的原始数据不会受影响,还是100

            console.log( int );

            // 如果需要将int中存储的数据,就强行更改为布尔类型

            // 需要将 Boolean() 方法 执行结果赋值给 变量本身

            // 通过 Boolean() 方法,获取int中存储的数据100,转化为布尔类型true

            // 再将这个结果,赋值给int本身存储,

            // 此时 int 中存储的就是数值 true

            int = Boolean(int);

            console.log(int);

        强制转化为字符串类型

            String( 数值 / 变量 ) 

                转化原则与自动转化原则相同

                // 方法2 String( 变量 / 数据 )

                // 将变量中存储的数据 或者 输入的数据转化为字符串类型

                // 不会影响改变,变量中存储的原始数据内容

                // 将布尔类型false 转化为 字符串类型,结果也是false

                console.log( String(false) );

            变量.toString()

                将变量中存储的数据,强制转化为字符串类型

                转化原则,默认与自动转化原则相同

                如果是数值类型,转化为字符串类型,可以在()中设定转化进制

                ()中一般不写内容,只有数值转化需要设定特殊类型时,才定义()中的进制

                // 方法1: 变量.toString()

                // 将数值类型强行转化为字符串类型,并且可以设定转化的进制

                // 进制的范围是 2 - 36

                // 其他数据类型,也可以转化为字符串类型,只是没有进制效果了

                // 不会影响变量存储的原始数据

                // 数值类型可以设定进制

                var int1 = 100;

                console.log( int1.toString(8) );

                console.log( int1);

                // 其他类型转化为字符串,设定进制无效

                var bool1 = true;

                console.log( bool1.toString(8) );

                console.log( bool1 );

        其他类型转化为数值类型

            Number( 数值 / 变量 )

                转化原则与自动转化原则相同

            parseInt( 数值 / 变量  )    

                从数据的左侧起,获取整数部分

                如果起始部分不是整数语法规范,结果就是NaN

                    // 获取变量或者数值的整数部分

                    // 从数据的 左侧起 解析获取 符合整数的内容部分

                    // 与自动转化原则完全没有关系,是全新的转化原则

                    // 没有整数部分,执行结果是NaN

                    // console.log( parseInt( true ) );

                    // console.log( parseInt( false ) );

                    // console.log( parseInt( null ) );

                    // console.log( parseInt( undefined ) );

                    // console.log( parseInt( {name:'张三'} ) );

                    // console.log( parseInt( function fun(){console.log(123)} ) );

                    // 字符串,从字符串的左侧起,获取字符串的整数部分

                    // 整数字符串,没有任何影响,就是获取整数部分

                    // console.log( parseInt( '1000' ) );  

                    // 浮点数字符串,就是单纯的获取整数部分

                    // 直接获取,不是四舍五入

                    // console.log( parseInt( '1000.923456' ) );  

                    // 科学计数法,只会获取e之前的整数部分,不会获取其他内容

                    // console.log( parseInt( '2e3' ) ) ; 

                    // console.log( parseInt( '2.123e3' ) ) ; 

                    

                    // 如果是不符合数字规范的字符串

                    // 从左起获取整数部分

                    // 从左侧起,获取整数部分 结果 123

                    // console.log( parseInt( '123abc' ) );

                    // 从左侧起,获取整数部分 没有整数内容,结果是NaN

                    // console.log( parseInt( 'abc123' ) );

                    // 数组 获取 [ ] 内的数据内容,从左侧起,获取整数部分,如果不符合整数规范,结果就是NaN

                    // console.log( parseInt( [1,2,3,4,5] ) );

                    // console.log( parseInt( ['a',2,3,4,5] ) );

                    // console.log( parseInt( ['123a',2,3,4,5] ) );

                    // console.log( parseInt( [ {name:'张三'},2,3,4,5] ) );

            parseFloat( 数值 / 变量  )    

                从数据的左侧起,获取浮点数部分

                如果起始部分不是浮点数语法规范,结果就是NaN    

                // 获取浮点数部分,如果是整数,就获取整数部分

                // 从左侧起,获取符合浮点数语法规范内容部分

                // 如果左侧第一个内容,就不符合浮点数规范,结果就是NaN

                // 左侧第一个内容,就不符合,浮点数语法规范,结果都是NaN

                // console.log( parseFloat( true ) );

                // console.log( parseFloat( false ) );

                // console.log( parseFloat( null ) );

                // console.log( parseFloat( undefined ) );

                // console.log( parseFloat( {name:'张三'} ) );

                // console.log( parseFloat( function fun(){console.log(123)} ) );

                

                // 纯数值字符串

                // 可以正确获取数值部分,科学计数法,也可以正确解析为数值

                // console.log( parseFloat( '100' ) );

                // console.log( parseFloat( '100.123456' ) );

                // console.log( parseFloat( '2e3' ) );

                // 有符合数字规范的字符串

                // console.log( parseFloat( '100abc' ) );

                // console.log( parseFloat( '100.123abc' ) );

                // console.log( parseFloat( '2e3abc' ) );

                // console.log( parseFloat( 'abc123' ) );

                // 数组

                // console.log( parseFloat( [1,2,3,4,5] ) );

                // console.log( parseFloat( [100.123,2,3,4,5] ) );

                // console.log( parseFloat( ['abc',2,3,4,5] ) );       

                // 总结

                // 获取原则与 parseInt() 相似 

                // 只是 parseInt()   是从左起,获取符合整数规范的内容

                //      parseFloat() 是从左起,获取符合浮点数规范的内容

                // parseInt() 和 parseFloat() 都不会改变变量中存储的原始数据内容

                // 关键区别,就是对于 浮点数的获取和科学计数法的获取