数据类型的转化

数据类型的转化,只存在于 弱类型语言中 例如 JavaScript php
强类型语言中,没有数据类型的转化 例如 java SQL语句
弱类型语言中,对于变量存储的数据类型,没有约束设定
一个变量中可以存储任意类型的数据
在强类型语言中,对于变量存储的数据类型,有严格的要求
设定变量时,先设定变量存储数据的数据类型,再给变量赋值
如果不符合数据类型的数据,不允许存储的
必须要非常清楚数据类型转化发生的具体情况
只有在执行特殊情况下,才会发生数据类型转化
其他情况下,变量存储的数据,不会改变
数据类型的转化,分为自动转化,和,强制转化
自动转化:是JavaScript程序,自动将变量的数据类型转化为需要的数据类型
强制转化:程序员自己操作的转化

自动转化

自动转化,不会改变,变量中存储的原始数据只是,把这个原始数据,转化为对应的数据类型,来执行程序不会改变存储的数据

if判断语句()中的表达式,会自动转化为布尔类型

自动转化为布尔类型的原则

有5种情况,会转化为 false ,其他情况都转化为true
false: 0 包括 0.0  0.000  0.000000
           ''  ""  ``  空字符串
          NaN
          undefined
          null

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

布尔类型的原则

true  : 转化为 字符串 true
false : 转化为 字符串 false
console.log( '北京' + true ); //北京true
console.log( '北京' + false ); //北京false

数值类型

自动转化为纯数字的字符串
console.log( '北京' + 100 ); //北京100
console.log( '北京' + 100.123 ); //北京100.123
console.log( '北京' + 2e3 ); //北京2000 将科学计数法,解析为数值,拼接数值
console.log( '北京' + NaN ); //北京NaN NaN直接拼接NaN

undefined,null

本身就直接 转化为 字符串 拼接
console.log( '北京' + undefined ); // 北京undefined
console.log( '北京' + null ); // 北京null

数组

形式结果是:将数组外的[]去掉,拼接在字符串后
本质原则是:将数组转化为字符串,再与字符串拼接

数组转化为字符串的默认原则

获取数组中每一个数据单元,以逗号间隔,拼接为字符串
    console.log( '北京' + [1,2,'北京',4,5] );  //北京1,2,北京,4,5

对象

在JavaScript中,对象转化为字符串,是固定的结果 [object Object]
不管是什么样子的对象,转化的结果都是 [object Object]
[] 必须有,大小写要区别
不管写什么,都拼 [object Object]
    console.log( '北京' + {} );  //北京[object Object] 

函数

将 整个函数程序 所有的代码 转化为字符串,进行拼接
写什么,拼什么
    console.log( '北京' + function(){} );  //北京function(){}

其他数据类型自动转化为数值类型执行算术运算时,其他数据类型会自动转化为数值类型

布尔类型:

true  : 数值1
false : 数值0
console.log( 100 - true ); // 99
console.log( 100 - false ); // 100

null : 0

    console.log( 100 - null );    // 100

undefined : NaN

    console.log( 100 - undefined );   // NaN

数组: NaN

    console.log( 100 - [1,2,3,4,5] );  // NaN

对象: NaN

    console.log( 100 - {name:'张三'} );  // NaN

函数: NaN

    console.log( 100 - function(){} );  // NaN

字符串:

如果有字符串参与加法运算,执行的是字符串拼接运算,不是加法运算 从左起,转化符合数字规范的内容
    console.log( 100 - '100.123' );  //-0.12300000000000466
如果左侧第一个字符,就不符合数字规范,转化为 NaN 如果之后有不符合数字规范的部分,也转化为NaN
    console.log( 100 - 'a100' );   //NaN
特殊情况是 字符串起始有空格,不考虑空格,看去除空格之后的内容,是否符合数值规范
    console.log( 100 - '           100' );   //0

注意:所有,有 NaN 参与的运算,运算结果,也是NaN

特别注意:

input 输入框,获取的输入的数据,不管输入的是个啥,获取到的都是字符串类型
如果是 数值 必须要转化为 数值类型,才能进行正确的计算
简便转化方式 -0   *1   /1

强制转化

使用 Boolean() 强制将 int 存储的数据,转化为布尔类型

var int = 100;
int = Boolean(int);
console.log( int ); // ture

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

String(变量/数据)

转化原则与自动转化原则完全相同不会改变,变量中存储的原始数值
var arr = [1,2,3,4,5];
console.log( String(arr) ); //1,2,3,4,5

变量.toString(可以写进制)

默认的转化原则与自动转化原则完全相同  .toString() 之前,必须是一个变量,不能直接写数值数据
var arr = [1,2,3,4,5];
console.log( arr.toString(2) ); //1,2,3,4,5
纯数字字符串时,可以写进制,按照进制转化
var int = 100;
console.log( int.toString(2) ); // 1100100

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

Number(变量/数据)parseInt(变量/数据)parseFloat(变量/数据)

转化原则与自动转化原则完全相同不会改变,变量中存储的原始数据

布尔类型

console.log( Number(true) ); // 1
console.log( Number(false) ); // 0

null

    console.log( Number(null) );   // 0

数组,对象,函数,undefined

console.log( Number([1,2,3,4,5]) ); // NaN
console.log( Number({name:'张三'}) ); // NaN
console.log( Number(function(){console.log(123)}) ); // NaN
console.log( Number(undefined) ); // NaN

字符串: 只转化符合数字规范的字符串,其他都是NaN

console.log( Number( '100.123' ) ) // 100.123
console.log( Number( ' 2e3' ) ) // 2000
console.log( Number( '100abc' ) ) // NaN
console.log( Number( '2e3abc' ) ) // NaN

获取表达式的整数部分

布尔类型

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

null

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

对象,函数,undefined

console.log( parseInt({name:'张三'}) ); // NaN
console.log( parseInt(function(){console.log(123)}) ); // NaN
console.log( parseInt(undefined) ); // NaN

数组 : 获取第一个单元存储数据的整数部分 二维数组,也看第一个单元

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

字符串 : 从左起,获取整数部分

console.log( parseInt( '100.123' ) ); // 100
console.log( parseInt( '2e3' ) ); // 2
console.log( parseInt( '100.123.456.789' ) ); // 100

获取表达式的小数部分

布尔类型

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

null

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

对象,函数,undefined

console.log( parseFloat({name:'张三'}) ); // NaN
console.log( parseFloat(function(){console.log(123)}) ); // NaN
console.log( parseFloat(undefined) ); // NaN

数组 获取第一个单元,获取浮点数的结果

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

字符串

console.log( parseFloat( '100' ) ); // 100
console.log( parseFloat( '100.123' ) ); // 100.123
console.log( parseFloat( '2e3' ) ); // 2000
console.log( parseFloat( '100.123.456.789' ) ); // 100.123

总结:

Number()      与自动转化原则完全相同
parseInt()    获取整数部分
parserFloat() 获取浮点数部分

区别:

布尔类型:

Number() 和 自动转化
true --- 1         false --- 0
parseInt()  parserFloat()
NaN            NaN

null

Number() 和 自动转化
null ---            0
parseInt()  parserFloat()
NaN             NaN

数组:

Number() 和 自动转化
NaN                NaN
parseInt()  parserFloat()
获取第一个单元的数据

字符串:

Number() 和 自动转化
100.123.456.789 --- NaN
100abc --- NaN
parseInt()  parserFloat()
100.123.456.789 --- 100 / 100.123
100abc --- 100
2e3  parseInt() 是  2
2e3  parserFloat()  自动转化 是  2000

一沙一世界,一花一天堂。君掌盛无边,刹那成永恒。