JavaScript中数据类型的检测与转化

1.数据类型的检测

在JavaScript中,数据类型的检测,使用 typeof() 方法 / 函数
typeof(变量/数据) , 执行结果是变量中存储数据的数据类型
typeof还有一种语法形式 typeof 空格 变量 但是这种语法形式不推荐使用,容易程序执行错误
typeof 并不能非常准确的表示每一种数据类型，一般是使用判断 布尔类型 数值类型 字符串类
型 undefined类型
其他数据类型,我们之后有更加准确,但是复杂的判断方式
所谓的 方法 / 函数 , 现在指的是,JavaScript给我们定义好的功能

   整数,浮点数,NaN 执行结果都是 number
 		var int1 = 100;
        var float1 = 100.123;
        console.log( typeof(int1) );
        console.log( typeof(float1) );
        console.log( typeof(NaN) );

   布尔类型的执行结果是 boolean
        var bool1 = true;    
        console.log( typeof(bool1) );

   字符串类型的执行结果是  string
        var str1 = '北京';
        console.log( typeof(str1) );


        undefined 执行结果 undefined
        	console.log( typeof(undefined) );

        null 执行结果 object 
       		console.log( typeof(null) );

2.数据类型的转化

什么是数据类型的转化,为什么要有数据类型的转化
在 JavaScript 程序中 , 变量中存储的数据类型没有限制，也就是在变量中可以存储任何符合
JavaScript语法规范的数据类型
但是 在 JavaScript 程序的执行过程中,往往需要变量中存储的数值是某种特定的数据类型,别的数据类型不行，此时就需要进行数据类型的转化
所谓的数据类型转化,就是将当前数据类型转化为其他数据类型
JavaScript中数据类型的转化,分为自动转化和强制转化
自动转化是计算机程序,自动完成的转化 – 自动转化原则至关重要,必须通过多练习,掌握
强制转化是程序员,强行完成的转化

数据类型是将 当前类型的当前数值 转化为 对应类型的对应数值
在计算机程序中,是数据数值的变化转化,而不能理解为相等的关系

3.布尔类型的自动转化

其他数据类型,自动转化为布尔类型
在 执行 if 判断时 ,其他数据类型会自动转化为布尔类型
其他类型转化为布尔类型的原则
转化为 false : 0 ‘’ undefined null NaN 这五种情况转化为false
特别提醒 0.0 0.00000 都算是0
其他的所有 都会转化为 true
这里不是表示对错,是如果 0 要是 按照 布尔类型类执行转化 ,转化的结果是 false
if判断的基本语法

         if(表达式){
            执行程序
        }else{
            执行程序
        }
        if( false ){
            console.log('真');
        }else{
            console.log('假');
        }

4.字符串的自动转化

其他类型自动转化为字符串
在 执行 字符串拼接 时, 会将其他数据类型转化为字符串类型
执行字符串拼接, 拼接符号 +号 两侧 应该都是 字符串类型
如果是其他类型 JavaScript程序,会自动转化为 字符串类型,再执行拼接
转化原则
布尔值 true —> 字符串 ‘true’
布尔值 false —> 字符串 ‘fasle’
undefined —> 字符串 ‘undefined’
unll —> 字符串 ‘null’
数值 —> 将数值解析转化为 对应的 纯数字的字符串

这里有三个特殊的转化
数组 —> 将 [ ] 中的内容,转化为字符串的形式,进行拼接
对象 —> 任何对象,任何内容,都会转化为 [object Object] 固定的内容形式
函数 —> 将所有的程序代码,转化为字符串

5.数值的自动转化

其他类型自动转化为数值
在执行数学运算时 会触发数据类型的自动转化
转化原则
布尔类型 : true —> 1
false —> 0
undefined : 转化为 NaN
null : 转化为 0

字符串 :
如果整个字符串,是纯数字字符串,或者符合科学计数法 —> 转化为对应的数值
如果字符串内有不符合数字规范的内容 —> 转化为 NaN

数组,对象,函数
如果是 + 加号 执行的是字符串拼接效果
按照这些数据类型转化为字符串的原则来转化
如果是 其他形式的运算 执行结果都是 NaN

6.布尔类型的强制转化

其他数据类型,强制转化为布尔类型，就是使用JavaScript中定义好的 方法/函数
Boolean( 数据/变量 )
转化原则与自动转化原则相同
false : 0 ‘’ undefined null NaN
true : 其他数据,都转化为true
Boolean() 这个方法 不会改变 变量中存储的原始数值

var int = 100;
console.log( Boolean(int) );
将 int 中存储的数值100 ,转化为布尔值输出,转化结果是 true
使用 Boolean() 方法 转化 变量中存储的数值,但是不会改变变量中存储的数值
只是将变量中的数值,解析获取,再转化输出,不会改变变量中存储的内容

7.字符串类型的强制转化

其他类型强制转化为字符串类型

方法1 变量.toString(进制类型)
将数值强制转化为字符串,并且可以设定转化的进制
.toString() 之前,不能直接写数值,必须是写成变量的形式
进制常用的数值是 2 8 16
可以设定的范围是 2 - 36 进制 10个数值+26个英文字母
最少是2进制,最多是36进制

var int = 100;   
     	
console.log(int.toString(2));  
将int 中存储的 100 数值,按照二进制转化,并且以字符串的形式来输出
  				 	 如果输出时, 第一个数值1 之前的 0 , 会不输出 , 对数值大小没有影响

console.log(int.toString(8)); 	八进制

console.log(int.toString(16));	十六进制
 
console.log(int.toString( ));	( )中没有输入,默认执行十进制

console.log(int.toString(9));	进制范围是2-36

方法2, String( 变量 / 数据 )
将变量或者数据,转化为字符串
原则按照自动转化的原则来执行
不会改变变量中存储的原始数值

var int = 2e5;
console.log( String(int) );

字符串拼接时,会将其他数据类型自动转化为字符串

8.数值的强制转化

将其他数据类型强制转化为 数值类型

方法1 , Number(变量/数值)
将其他类型强制转化为数值类型,转化原则与自动转化选择相同

        console.log( Number(true) );   // 1
        console.log( Number(false) );  // 0
        console.log( Number(null) );   // 0
        console.log( Number(undefined) );   // NaN
        console.log( Number('100') );       // 对应的数值
        console.log( Number('100.123') );   // 对应的数值
        console.log( Number('2e4') );       // 对应的数值
        console.log( Number('123abc') );    // NaN
        console.log( Number( [1,2,3,4,5] ) );                           // NaN
        console.log( Number( {name:'zhangsan'} ) );                     // NaN
        console.log( Number( function fun(){console.log('abc')} ) );    // NaN

方法2, parseInt(变量 / 数据)
是获取变量或者数据的整数部分
从数据的 左侧起 解析获取 整数内容

		console.log( parseInt(true) );                                    // 都是 NaN            
		console.log( parseInt(false) );                                   
		console.log( parseInt(null) );                                    
		console.log( parseInt(undefined) );                               
		console.log( parseInt( {name:'zhangsan'} ) );                     
		console.log( parseInt( function fun(){console.log('abc')} ) ); 

数组执行,是获取 数值部分 也就是 没有 []的部分
1,2,3,4,5 整数部分是 1 1之后是逗号 逗号不是整数,之后的部分也就不算整数
获取第一个数值的整数部分,如果有就获取,如果没有,结果是NaN

		console.log( parseInt( [1,2,3,4,5] ) );        // 结果是 1                      
		console.log( parseInt( [null,2,3,4,5] ) );     // 结果是 NaN 

如果是整数就直接获取,如果是浮点数,或者科学计数法,就获取整数部分

		console.log( parseInt( 100 ) );          // 整数是直接获取
		console.log( parseInt( 0.0123 ) );       // 浮点数是获取整数部分
		console.log( parseInt( 3.123456e3 ) );   // 科学计数法是解析之后,获取整数部分

字符串不同了
如果是纯数字的字符串

		console.log( parseInt( '100' ) );         // 与数字的结果相同 
		console.log( parseInt( '0.0123' ) );      // 与数字的结果相同 
		console.log( parseInt( '3.123456e3' ) );   //3
		console.log( parseInt( '3abc' ) ); 		 //3
		console.log( parseInt( '3.123' ) );  		//现在是一个字符串,从左侧开始,找整数部分,第一个是3,
													第二个是点,点不是整数,因此整数部分就是3
        

方法3 , parseFloat( 变量 / 数值 )
获取浮点数部分

		console.log( parseFloat(true) );                                    // 都是 NaN            
		console.log( parseFloat(false) );                                   
		console.log( parseFloat(null) );                                    
		console.log( parseFloat(undefined) );                               
		console.log( parseFloat( {name:'zhangsan'} ) );                     
		console.log( parseFloat( function fun(){console.log('abc')} ) );         

数值
整数,浮点数,都会完整获取

		console.log( parseFloat(100) );
        console.log( parseFloat(100.1234) );
        console.log( parseFloat(1.234567e3) );

关键是字符串
从字符串的左侧起 解析 符合浮点数的部分

		console.log( parseFloat( '100' ) );         // 与数字的结果相同 
        console.log( parseFloat( '0.0123' ) );      // 与数字的结果相同 
        
        console.log( parseFloat( '3.123456e3' ) );  // 科学技术法会解析
        console.log( parseFloat( '3.1223abc' ) );        
        console.log( parseFloat( '3.123' ) );