JavaScript的数据类型（类型检测及类型转换）

一、数据类型的分类

基本数据类型

包装对象：把一个基本类型尝试用对象的方式来使用时，JavaScript会把基本类型转化成对应的包装类型对象。而这个包装类型对象是临时的，当使用完后会销毁这个临时的包装类型对象。

var str = "string";
str.t = 1;
console.log(str.t); //undefined

1、数字（Number）

表示数值，包括整数、浮点数。可以使用二进制、八进制、十六进制表示。还包括一些特殊的值：+Infinity（正穷大）、-Infinity（负无穷大）和NaN（Not a Number）。

NaN： 不是一个数值。是表示在数字类型中非数字的数据类型。通俗说，用来表示在数字类型中产生的非数字部分（非数字类型的运算）。有点不精准，来举几个例子。

// 1、当两个非数字之间进行运算（不包括 +），结果为NaN 
	var str1 = "str1";
	var str2 = "str2";
	console.log(str1 - str2);	//NaN

// 2、当任何数值与NaN进行运算（不包括 +），结果都是NaN 
	var str1 = "str1";
	var NaNVar = NaN;
	console.log(str1 - NaNVar);		//NaN

// 3、当非字符串和NaN相加时，结果为NaN,当字符串和NaN相加，是拼接字符串
	var str1 = "hello",
		NaNVar = NaN,
		flag = true;
	console.log(str1 + NaNVar);//"helloNaN"
	console.log(flag + NaNVar);//NaN

值得注意是：

	NaN == NaN	 // false
	NaN === NaN	 // false

2、字符串（String）

表示一串文本数据，用单引号或双引号包裹，在字符串中可以使用转义字符。

要注意单引号和双引号之间的嵌套，更推荐ES6的模板字符串。

3、布尔值（Boolean）

表示一个逻辑值，共有两个值：true，false；

4、null

• 值 null 是一个字面量，不像 undefined，它不是全局对象的一个属性。
• null 是表示缺少的标识，指示变量未指向任何对象。把 null 作为尚未创建的对象，也许更好理解。

5、undefined

• undefined是全局对象的一个属性。也就是说，它是全局作用域的一个变量。
• 一个没有被赋值的变量的类型是undefined。如果方法或者是语句中操作的变量没有被赋值，则会返回undefined

6、Symbol

ES6新添加的数据类型，是唯一的数据结构，创建的每一个Symbol都是独一无二的。

更多的使用可能是用于对象属性的唯一key值，避免重复对象属性。

7、BigInt

表示任意精度的整数，Number类型的安全范围是 -(2^53-1) ~ (2^53-1)，超出范围可能会造成精度损失，而BigInt解决这个问题。

引用数据类型

引用数据类型就是各种对象，例如Function、Array、Date等，它们在内存的存储方式和基本类型是有所不同的。基本数据类型存储在内存栈中，而引用数据类型存储在内存堆中。

二、数据类型的检测

1、typeof

判断基本数据类型和是否是引用数据类型（不会检测引用数据类型中的各种对象）

	console.log(typeof 0);  // number
	console.log(typeof true);  // boolean
	console.log(typeof "string"); // string
	console.log(typeof null);  // object
	console.log(typeof undefined);   // undefined
	console.log(typeof new Array()); // object

值得注意是检测null时结果是object。

2、instanceof

object instanceof constructor

	function Person() {}
	function Student() {}
	Student.prototype = new Person();
	Student.prototype.constructor = Student;
	let bosn = new Student();
	let one = new Person();
	console.log(bosn instanceof Student); // true
	console.log(one instanceof Person); // true
	console.log(one instanceof Student); // false
	console.log(bosn instanceof Person); // true

左操作数是对象，不是返回false，右操作数必须是函数对象或函数构造器，不是返回typeError错误。

原理：判断左操作数的对象的原型链上是否有右边这个构造函数的prototype属性。

注意：在判断引用数据类型中的各种对象时，这很有效果。但是不同的window或iframe之间的引用类型检测不能使用instanceof。

3、Object.prototype.toString

每一个对象都有toString方法，如果此方法没有被自定义对象给覆盖，toString() 返回 “[object type]”，其中 type 是对象的类型。

可以通过 toString() 来获取每个对象的类型。为了每个对象都能通过 Object.prototype.toString() 来检测，需要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象作为第一个参数，称为 thisArg。

      console.log(
         Object.prototype.toString.call([]) // [object Array]
      );
      console.log(
         Object.prototype.toString.call(null) // [object Null]
      );
      console.log(
         Object.prototype.toString.call(undefined) // [object Undefined]
      );
      console.log(
         Object.prototype.toString.call(function () {}) // [object Function]
      );

注意：在IE低版本中，Null返回Object类型

4、constructor

	Date.prototype.constructor === Date // True

返回创建实例对象的 Object 构造函数的引用。

原理：判断对象的constructor是否指向这个对象的构造函数或构造器

注意：对象的constructor很容易发生改写。

5、duck type

在判断引用数据类型中的各种对象时，我们可以通过该对象所拥有的一些特征来判断对象类型。例如：通过判断对象是否有join，push等方法，来鉴别数组对象类型。

6、判断变量是否是字符串

      let str = "hello";
      let temp = str + '';
      console.log(str === temp);

将变量和空串进行拼接后和原变量做全等运算。

三、数据类型的转换

数据类型的转换分为两种：隐式类型转换、强制类型转换。

1. 隐式类型转换：在我们使用某些方法时，会自动发生类型转换。这是由js解释器来转换的，不需要人工干预。
2. 强制类型转换：我们使用转换方法手动的让数据类型发生转换。

1、转换为Number

使用 Number() 方法将其他类型的数据转换成 Number 类型。

// 将数字类型的字符串，最后的结果保留原数据。

console.log(Number('789')); // 789

// 如果是非数字类型的字符串的话，直接转换成 NaN。

console.log(Number('abc')); // NaN

console.log(Number('123abc')); // NaN

console.log(Number('abc123')); // NaN

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

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

console.log(Number(undefined)); // NaN

console.log(Number({myName: '李四'})); // NaN

使用 parseInt() 方法将其他类型的数据转换成 Number 类型。

//将数字类型的字符串通过该方法转换后，只保留数字的整数部分，不会进行四舍五入运算。

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

// 非数字类型的字符串转换后的结果为NaN。

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

// 以数字开始的字符串，保留数字部分忽略其他内容

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

// 以数字结尾的字符串，转换成 NaN

console.log(parseInt('abc789')); // NaN

// 将布尔值转换成 Number 类型

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

// undefined

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

// null

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

console.log(parseInt({name: '李四'})); // NaN

使用 parseFloat() 方法将其他类型的数据转换成 Number 类型。

// 结果保留原数据，不会对数字进行四舍五入运算。

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

// 如果在数字后加上非数字的字符，也可以转换成功

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

console.log(parseFloat('abc789')); // NaN

// 其他同上

利用隐式转换将字符串类型的数据转换成 Number 类型

// 当非数字类型的字符串相减时，结果都等于NaN

console.log('abc' - '18'); // NaN

// 当数字类型的字符串进行
// 乘、除、取余运算时（加号除外），首先会将字符串转换成数字，然后再进行减运算，最终的结果返回的是数值型。

console.log('28' - '18'); // 10 

console.log('32' / '4'); // 8 

console.log('3' * '4'); // 12 

console.log('12' % '5'); // 2 

用于检查其参数是否是非数字值（isNaN() 函数）

console.log(isNaN(123)); //false
console.log(isNaN(null)); //false
console.log(isNaN(undefined)); //true
console.log(isNaN(true)); //false
console.log(isNaN("Hello")); //true
console.log(isNaN("2005")); //false

在使用isNaN进行判断时，它会隐式的使用转换数字类型相应的方法，然后根据转换方法的返回值判断结果是否是NaN。

2、转换为String

String()函数可以将任意类型转换为字符型；

console.log(String(123.456)); // '123.456'

console.log(String(null)); // 'null'

console.log(String(true)); // 'true'

console.log(String({myName: '李四'})); // '[object Object]'

toString()也可以完成字符的转换，但是null和undefined没有toString()方法

var num = 10;
console.log(num.toString());	//'10'
console.log(num.toString(2));	//'1010'
console.log(num.toString(8));	//'12'
console.log(num.toString(16));	//'a'

还可以将变量和一个空字符串相加，结果将变量转为字符串类型

3、转换为Boolean

Boolean( ) 方法将其他类型的数据转换成 Boolean 类型。

false、undefined、null、0、NaN、''这些值会被转换成false，其他数值都换转为true。

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

console.log(Boolean(undefined)); // false

console.log(Boolean(null)); // false

console.log(Boolean(0)); // false

console.log(Boolean(-0)); // false

console.log(Boolean(NaN)); // false

console.log(Boolean('')); // false

如有错误，请在底部留言。