数据类型

---

8种数据类型：

Undefined、Null、Boolean、Number、String、Object、Symbol、BigInt

Symbol和BigInt是ES6新增的：

• Symbol代表独一无二且不可变，主要用来解决可能出现的全局变量冲突的问题
• BigInt表示容易精度的整数，主要用来解决超出Number能够表示的安全整数范围

数据也可以分为原始数据类型和引用数据类型：

• 栈：原始数据类型（Undefined、Null、Boolean、Number、String）
• 堆：引用数据类型（对象、数组、函数）

类型检测

1. typeof：数组、对象、null为object，function被判断为function，NaN为number

   console.log(typeof 2);               // number
   console.log(typeof NaN);             // number
   console.log(typeof true);            // boolean
   console.log(typeof 'str');           // string
   console.log(typeof []);              // object    
   console.log(typeof function(){});    // function
   console.log(typeof {});              // object
   console.log(typeof undefined);       // undefined
   console.log(typeof null);            // object

2. instanceof：原理是判断在原型链中能否找到该类型的原型，只能判断引用类型。具体说就是在原型链中一层一层去找，找到则返回true，一直到原型链的最顶层null则寻找结束返回false，代码如下：

   var a = [1, 2, 3]
   a instanceof Array // true，原型链寻找1次 a.__proto__ = Array.prototype
   a instanceof Object // true，原型链寻找2次 a.__proto__.__proto__ = Object.prototype
   a instanceof Function // false, 原型链寻找3次找到最后的null，然后返回false
   // 理解上面的例子，面试的时候如果让你手写instanceof就非常简单了
   function myInstanceof(left, right) {
     // 获取右侧的显式原型
     const rightProtoType = right.prototype;
     // 获取左侧的隐式原型
     let leftProto = left.__proto__;
     // 遍历原型链，如果找不到，最后会遍历到null，也会自动跳出while的
     while (leftProto) {
       if (leftProto === rightProtoType) {
         return true
       }
       leftProto = leftProto.__proto__;
     }
     return false
   }

3. constructor：如果对象的原型改变，将无法正确判断。

   // 数据类型判断
   (3).constructor === Number // true
   ('string').constructor === String // true
   // true -> Boolean
   // [] -> Array
   // function(){} -> Function
   // {} -> Object
   
   function Fn() {}
   var f = new Fn();
   f.constructor === Fn // true
   // 改变原型为一个新的对象
   Fn.protoype = new Array()
   f.constructor === Fn // false
   f.constructor === Array // true

两个变量比较时，强制类型转换规则：

包装对象

let str = 'abc'，实际上会包一层new String('abc')

检测对象类型的通用方法

return Object.prototype.toString.call(value).slice(8, -1).tolowerCase()

0.1+0.2不等于0.3

原因：计算机是通过二进制的方式存储数据的，0.1和0.2的二进制都是无限循环的数，相加得到0.300000很多04

解决：设置一个误差范围，ES6新增了一个Number.EPSILON，只要两个数的差值小于即可认为相等Math.abs(arg1 - arg2) < Number.EPSILON

NaN

console.log(typeof NaN) // number
// isNaN和Number.isNaN的区别是，判断之前必须先确定类型是数字类型
Number.isNaN = Number.isNaN || function(value) {
    return typeof value === "number" && isNaN(value);
}