JavaScript共有八种数据类型，分别是 Undefined、Null、Boolean、Number、String、Object、Symbol、BigInt。

其中 Symbol 和 BigInt 是ES6 中新增的数据类型：

Symbol 代表创建后独一无二且不可变的数据类型，它主要是为了解决可能出现的全局变量冲突的问题。

BigInt 是一种数字类型的数据，它可以表示任意精度格式的整数，使用 BigInt 可以安全地存储和操作大整数，即使这个数已经超出了 Number 能够表示的安全整数范围。

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

栈：原始数据类型，Undefined、Null、Boolean、Number、String

堆：引用数据类型，对象、数组和函数

两种类型的区别在于存储位置的不同：

原始数据类型直接存储在栈中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储；

引用数据类型存储在堆中的对象，占据空间大、大小不固定。如果存储在栈中，将会影响程序运行的性能；引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

堆和栈的概念存在于数据结构和操作系统内存中，在数据结构中：

在数据结构中，栈中数据的存取方式为先进后出。

堆是一个优先队列，是按优先级来进行排序的，优先级可以按照大小来规定。

在操作系统中，内存被分为栈区和堆区：

栈区内存由编译器自动分配释放，存放函数的参数值，局部变量的值等，其操作方式类似于数据结构中的栈。

堆区内存一般由开发着分配释放，若开发者不释放，程序结束时可能由垃圾回收机制回收。

其中数组、对象、null都会被判断为object，其他判断都正确。

instanceof可以正确判断对象的类型，其内部运行机制是判断在其原型链中能否找到该类型的原型。

可以看到，instanceof 只能正确判断引用数据类型，而不能判断基本数据类型。instanceof 运算符可以用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。

constructor有两个作用，一是判断数据的类型，二是对象实例通过 constrcutor 对象访问它的构造函数。需要注意，如果创建一个对象来改变它的原型，constructor就不能用来判断数据类型了：

Object.prototype.toString.call() 使用 Object 对象的原型方法 toString 来判断数据类型：

同样是检测对象obj调用toString方法，obj.toString()的结果和Object.prototype.toString.call(obj)的结果不一样，这是为什么？

这是因为toString是Object的原型方法，而Array、function等类型作为Object的实例，都重写了toString方法。不同的对象类型调用toString方法时，根据原型链的知识，调用的是对应的重写之后的toString方法，比如function类型返回内容为函数体的字符串，Array类型返回元素组成的字符串，而不会去调用Object上原型toString方法返回对象的具体类型，所以采用obj.toString()不能得到其对象类型，只能将obj转换为字符串类型；因此，在想要得到对象的具体类型时，应该调用Object原型上的toString方法。

1. 通过Object.prototype.toString.call()做判断；

2. 通过原型链做判断；

3. 通过ES6的Array.isArray()做判断；

4. 通过instanceof做判断；

5. 通过Array.prototype.isPrototypeOf；

首先 Undefined 和 Null 都是基本数据类型，这两个基本数据类型分别都只有一个值，就是 undefined 和 null。

undefined 代表的含义是未定义，null 代表的含义是空对象。一般变量声明了但还没有定义的时候会返回 undefined，null主要用于赋值给一些可能会返回对象的变量，作为初始化。

undefined 在 JavaScript 中不是一个保留字，这意味着可以使用 undefined 来作为一个变量名，但是这样的做法是非常危险的，它会影响对 undefined 值的判断。我们可以通过一些方法获得安全的 undefined 值，比如 void 0。

当对这两种类型使用 typeof 进行判断时，Null 类型化会返回 “object”，这是一个历史遗留的问题。当使用双等号对两种类型的值进行比较时会返回 true，使用三个等号时会返回 false。

typeof null 的结果是Object。

在 JavaScript 第一个版本中，所有值都存储在 32 位的单元中，每个单元包含一个小的类型标签以及当前要存储值的真实数据。类型标签存储在每个单元的低位中，共有五种数据类型：

如果最低位是 1，则类型标签标志位的长度只有一位；如果最低位是 0，则类型标签标志位的长度占三位，为存储其他四种数据类型提供了额外两个字节的长度。

有两种特殊数据类型：

1. undefined的值是 (-2)30，一个超出整数范围的数字；

2. null 的值是机器码 NULL 指针，null 指针的值全是 0；

那也就是说null的类型标签也是000，和Object的类型标签一样，所以会被判定为Object。

instanceof 运算符用于判断构造函数的 prototype 属性是否出现在对象的原型链中的任何位置。

在开发过程中遇到类似这样的问题：

这里得到的不是想要的结果，要想等于0.3，就要把它进行转化：

toFixed(num) 方法可把 Number 四舍五入为指定小数位数的数字。那为什么会出现这样的结果呢？

计算机是通过二进制的方式存储数据的，计算机计算0.1+0.2实际上是计算的两个数的二进制的和。0.1的二进制是0.0001100110011001100...（1100循环），0.2的二进制是：0.00110011001100...（1100循环），这两个数的二进制都是无限循环的数。那JavaScript是如何处理无限循环的二进制小数呢？

一般我们认为数字包括整数和小数，但是在 JavaScript 中只有一种数字类型：Number，它的实现遵循IEEE 754标准，使用64位固定长度来表示，也就是标准的double双精度浮点数。在二进制科学表示法中，双精度浮点数的小数部分最多只能保留52位，再加上前面的1，其实就是保留53位有效数字，剩余的需要舍去，遵从“0舍1入”的原则。

根据这个原则，0.1和0.2的二进制数相加，再转化为十进制数就是：0.30000000000000004。

下面看一下双精度数是如何保存的：

1. 第一部分（蓝色）：用来存储符号位（sign），用来区分正负数，0表示正数，占用1位；

2. 第二部分（绿色）：用来存储指数（exponent），占用11位；

3. 第三部分（红色）：用来存储小数（fraction），占用52位；

对于0.1，它的二进制为：

转为科学计数法（科学计数法的结果就是浮点数）：

可以看出0.1的符号位为0，指数位为-4，小数位为：

那么问题又来了，指数位是负数，该如何保存呢？

IEEE标准规定了一个偏移量，对于指数部分，每次都加这个偏移量进行保存，这样即使指数是负数，那么加上这个偏移量也就是正数了。由于JavaScript的数字是双精度数，这里就以双精度数为例，它的指数部分为11位，能表示的范围就是0~2047，IEEE固定双精度数的偏移量为1023。

1. 当指数位不全是0也不全是1时（规格化的数值），IEEE规定，阶码计算公式为 e-Bias。 此时e最小值是1，则1-1023= -1022，e最大值是2046，则2046-1023=1023，可以看到，这种情况下取值范围是-1022~1023；

2. 当指数位全部是0的时候（非规格化的数值），IEEE规定，阶码的计算公式为1-Bias，即1-1023= -1022；

3. 当指数位全部是1的时候（特殊值），IEEE规定这个浮点数可用来表示3个特殊值，分别是正无穷，负无穷，NaN。 具体的，小数位不为0的时候表示NaN；小数位为0时，当符号位s=0时表示正无穷，s=1时候表示负无穷；

对于上面的0.1的指数位为-4，-4+1023 = 1019 转化为二进制就是：1111111011

所以，0.1表示为：

说了这么多，是时候该最开始的问题了，如何实现0.1+0.2=0.3呢？

对于这个问题，一个直接的解决方法就是设置一个误差范围，通常称为“机器精度”。对JavaScript来说，这个值通常为2-52，在ES6中，提供了Number.EPSILON属性，而它的值就是2-52，只要判断0.1+0.2-0.3是否小于Number.EPSILON，如果小于，就可以判断为0.1+0.2 ===0.3。

因为 undefined 是一个标识符，所以可以被当作变量来使用和赋值，但是这样会影响 undefined 的正常判断。表达式 void ___ 没有返回值，因此返回结果是 undefined。void 并不改变表达式的结果，只是让表达式不返回值。因此可以用 void 0 来获得 undefined。

NaN 指“不是一个数字”（not a number），NaN 是一个“警戒值”（sentinel value，有特殊用途的常规值），用于指出数字类型中的错误情况，即“执行数学运算没有成功，这是失败后返回的结果”。

NaN 是一个特殊值，它和自身不相等，是唯一一个非自反（自反，reflexive，即 x === x 不成立）的值，而 NaN !== NaN 为 true。

函数 isNaN 接收参数后，会尝试将这个参数转换为数值，任何不能被转换为数值的的值都会返回 true，因此非数字值传入也会返回 true ，会影响 NaN 的判断。

函b数 Numer.isNaN 会首先判断传入参数是否为数字，如果是数字再继续判断是否为 NaN ，不会进行数据类型的转换，这种方法对于 NaN 的判断更为准确。

对于 == 来说，如果对比双方的类型不一样，就会进行类型转换。假如对比 X和Y是否相同，就会进行如下判断流程：

1. 首先会判断两者类型是否相同，相同的话就比较两者的大小；

2. 类型不相同的话，就会进行类型转换；

3. 会先判断是否在对比 null 和 undefined，是的话就会返回 true；

4. 判断两者类型是否为 string 和 number，是的话就会将字符串转换为 number；

5. 判断其中一方是否为 boolean，是的话就会把 boolean 转为 number 再进行判断；

6. 判断其中一方是否为 object 且另一方为 string、number 或者 symbol，是的话就会把 object 转为原始类型再进行判断；

其流程图如下：

1. Null 和 Undefined 类型 ，null 转换为 “null”，undefined 转换为 “undefined”；

2. Boolean 类型，true 转换为 “true”，false 转换为 “false”；

3. Number 类型的值直接转换，不过那些极小和极大的数字会使用指数形式；

4. Symbol 类型的值直接转换，但是只允许显式强制类型转换，使用隐式强制类型转换会产生错误；

5. 对普通对象来说，除非自行定义 toString() 方法，否则会调用 toString()（Object.prototype.toString()）来返回内部属性 [[Class]] 的值，如"[object Object]"。如果对象有自己的 toString() 方法，字符串化时就会调用该方法并使用其返回值；

1. Undefined 类型的值转换为 NaN；

2. Null 类型的值转换为 0；

3. Boolean 类型的值，true 转换为 1，false 转换为 0；

4. String 类型的值转换如同使用 Number() 函数进行转换，如果包含非数字值则转换为 NaN，空字符串为 0；

5. Symbol 类型的值不能转换为数字，会报错；

6. 对象（包括数组）会首先被转换为相应的基本类型值，如果返回的是非数字的基本类型值，则再遵循以上规则将其强制转换为数字；

为了将值转换为相应的基本类型值，抽象操作 ToPrimitive 会首先（通过内部操作 DefaultValue）检查该值是否有valueOf()方法。如果有并且返回基本类型值，就使用该值进行强制类型转换。如果没有就使用 toString() 的返回值（如果存在）来进行强制类型转换。

如果 valueOf() 和 toString() 均不返回基本类型值，会产生 TypeError 错误。

以下这些是假值：

1. undefined

2. null

3. false

4. +0、-0 和 NaN

5. “”

假值的布尔强制类型转换结果为 false。从逻辑上说，假值列表以外的都应该是真值。

|| 和 && 首先会对第一个操作数执行条件判断，如果其不是布尔值就先强制转换为布尔类型，然后再执行条件判断。

1. 对于 || 来说，如果条件判断结果为 true 就返回第一个操作数的值，如果为 false 就返回第二个操作数的值；

2. && 则相反，如果条件判断结果为 true 就返回第二个操作数的值，如果为 false 就返回第一个操作数的值；

|| 和 && 返回它们其中一个操作数的值，而非条件判断的结果。

1. 使用双等号（==）进行相等判断时，如果两边的类型不一致，则会进行强制类型转化后再进行比较；

2. 使用三等号（===）进行相等判断时，如果两边的类型不一致时，不会做强制类型准换，直接返回 false；

3. 使用 Object.is 来进行相等判断时，一般情况下和三等号的判断相同，它处理了一些特殊的情况，比如 -0 和 +0 不再相等，两个 NaN 是相等的；

在 JavaScript 中，基本类型是没有属性和方法的，但是为了便于操作基本类型的值，在调用基本类型的属性或方法时，JavaScript 会在后台隐式地将基本类型的值转换为对象，如：

在访问'abc'.length时，JavaScript 将'abc'在后台转换成String('abc')，然后再访问其length属性。

JavaScript也可以使用Object函数显式地将基本类型转换为包装类型：

也可以使用valueOf方法将包装类型倒转成基本类型：

看看如下代码会打印出什么：

答案是什么都不会打印，因为虽然包裹的基本类型是false，但是false被包裹成包装类型后就成了对象，所以其非值为false，所以循环体中的内容不会运行。

首先要介绍ToPrimitive方法，这是 JavaScript 中每个值隐含的自带的方法，用来将值 （无论是基本类型值还是对象）转换为基本类型值。如果值为基本类型，则直接返回值本身；如果值为对象，其看起来大概是这样：

type的值为number或者string。

1. 当type为number时规则如下：

(1). 调用obj的valueOf方法，如果为原始值，则返回，否则下一步；

(2). 调用obj的toString方法，后续同上；

(3). 抛出TypeError 异常；

2. 当type为string时规则如下：

(1). 调用obj的toString方法，如果为原始值，则返回，否则下一步；

(2). 调用obj的valueOf方法，后续同上；

(3). 抛出TypeError 异常；

可以看出两者的主要区别在于调用toString和valueOf的先后顺序。默认情况下：

(4). 如果对象为 Date 对象，则type默认为string；

(5). 其他情况下，type默认为number；

总结上面的规则，对于 Date 以外的对象，转换为基本类型的大概规则可以概括为一个函数：

而 JavaScript 中的隐式类型转换主要发生在 "+" 和"-"和"*"和"/ "以及"=="和 ">" 和"