JavaScript基本数据类型中的类型转换

js中基本数据类型的类型转换

首先我们要先了解一下js的数据类型有哪些：

js的数据类型分为 基本类型 和 引用类型

• 基本类型：String、Number、Boolean、undefined、null
• 引用类型：Array、Object、Function

而数据类型的转换又分为显式转换和隐式转换

显式转换

转换成number类型

• String-----Number
  1、字符串中是”整数或小数“或转化为相对应大小的数值
  2、字符串中是”字母或者中文“会转换为NaN(NaN为一个特殊数字，没有任何意义)
• Boolean------Number

 	var num=Number("1");//字符串》》number类型
    console.log(num);
    
    var num1=Number(true);//布尔类型》》number类型
    var num2=Number(false);
    console.log(num1.num2);
    num=NaN;
    console.log(typeof num);//typeof::判断数据类型

转换为String字符串类型

将数值转换为字符串，会将数值以字符串的形式输出；
布尔类型转换为字符串，会以字符串输出相对应的true和false

	var a=5.5;
    var str=a.toString();
    console.log(str);
    var isOK=true;
    console.log(isOK.toString());

转换为Boolean 布尔类型

除了数值0、null、undefined、NaN，空字符为假;;其余输出均为真

 	console.log(Boolean("你好"));  //true
    console.log(Boolean("abc"));    //true
    console.log(Boolean(1));        //true
    console.log(Boolean(1.1));      //true
    console.log(Boolean("false"));  //true   
    console.log(Boolean("true"));   //true
    console.log(Boolean(0));        //false
    console.log(Boolean(null));     //false
    console.log(Boolean(undefined));//false
    console.log(Boolean(NaN));      //false
    console.log(Boolean(""));      //false

隐式转换

js中的数据类型是非常弱的，在使用算数运算符时，运算符两边的数据类型可以是任意的。比如，一个字符串可以和一个数字相加。之所以不同的数据类型之间可以做运算，是因为js引擎在运算之前会悄悄地把他们进行隐式类型转换。

下面先举例几组比较典型的运算操作(可以自己敲一下试试看)

console.log([] == []) // false
console.log([] == ![]) // true
console.log([] !== [])  // true
console.log(NaN != NaN) // true
console.log(null == undefined) // true
console.log(null === undefined) // false
console.log(1 == true) // true
console.log(null > 0) // false
console.log(true + 1) // 2
console.log(undefined + 1) // NaN
console.log({} + 1) // [object Object]1
console.log([] + {}) // [object Object]
console.log([2,3] + [1,2])  // 2,31,2

原始值	转化为值类型	转化为字符串	转化为Boolean
false	0	“false”	false
true	1	“true”	true
0	0	“0”	false
1	1	“1”	true
“0”	0	“0”	true
NaN	NaN	“NaN”	false
Infinity	Infinity	“Infinity”	true
“”	0	“”	false
[ ]	0	“”	true
[20]	20	“20”	true
function(){}	NaN	“function(){}”	true
{ }	NaN	“[object Object]”	true
null	0	“null”	false
undefined	NaN	“undefined”	false

比较运算符:>,>=,<,<=,= =(中间无空格), = = =(中间无空格),!=,!==

js为我们提供了严格比较与类型转换比较两种模式，严格比较**===**只会在操作符两侧的操作对象类型一致，并且内容一致时才会返回 true ,否则返回 false 。而更为广泛使用的 ==,操作符则会首先将操作对象转化为相同类型，在进行比较。
逻辑操作符（!、&&、||）

逻辑运算符：&&，||，！

• &&(逻辑与 and）: 两边都为真，结果才为真
• || （逻辑或 or）： 只要一边为真，结果就为真
• ！（逻辑非 not）：右边为假，结果为真，右边为真，结果为假

还有其他的未补充，但是把隐式转换整理成了图，如下图可参考：

下面补充一些类型转换的题目

var res = ['23',23,true] - 1
	//res = "23,23,true" - 1
	//res = NaN
var res = ['23',23,true]  + 1
	//res = "23,23,true" + 1
	//res = "23,23,true1"
var res = ['23',23,true] + {name:'aaa'} + 1
	//res = "23,23,true" + [object Object] + 1
	//res = 23,23,true[object Object]1
var res = ['23',23,true] - true + false
	//res = "23,23,true" - 1 + 0
	//res = NaN
var res = ['23',23,true] - ''
	//res = "23,23,true" - 0
	//res = NaN
var res = ['23',23,true] - 'ddd'
	//res = "23,23,true" - "ddd"
	//res = NaN
var res = ['23'] - 1
	//res = "23" - 1
	//res = 23 - 1
	//res = 22
var res = ['23'] - {}
	//res = "23" - [object Object]
	//res = NaN
var res = 'aa'>[]
  //res = "aa".charCodeAt() > ""
  //res = "aa".charCodeAt() > 0
  //res = 97 > 0
  //res = true
var res = '-' == ['-']
  //res = "-".charCodeAt() == "-".charCodeAt()
  //res = true
var res = '' === []
  //类型不同，大小相同
  // res = false
var res = 11>10 && []>{} || 3>5
  //res = true && "">[object Object] || false
  //res = true && false || false
  //res = false

以上就可以总结成以下几句

1. 其他类型数据如何转化为number 类型数据?

• Number(),parseInt(),parseFloat() + 与算术运算符运算时 先进行隐式转换成number类型

2. 任何与字符串相结果是什么

• 字符串拼接 成新的字符串

3. 什么数据可以运算

• 基本类型的数据
• 引用类型 + 运算符 先转化成字符串 然后再转其他类型，最后运算

4. 引用类型数据如果想运算前提是什么？

• 转换成基本类型

如果有什么错误补充，欢迎留言，谢谢。