JavaScript 数据类型有两种，分别是基本数据类型和引用数据类型。
-
Number
-
String
-
Boolean
-
Undefined
-
Null
-
Symbol
(ES6 新增，表示独一无二的值)
1. 基本数据类型
值不可变
var name = 'javascript';
name.toUpperCase(); // 'JAVASCRIPT'
console.log(name); // 'javascript'
let a = 1
console.log(++a) // '2'
其实这个时候并不是 a 指向的 1 直接加了 1，而是 新建了一个 1+1 = 2 的值，再将 a 指向这个新建出来的 2，原来的那个 1 并没有发生改变，留由垃圾回收机制处理。
也就是说不是 a 指向的值发生了改变，而是 a 变量指针指向了一个新的值，这和「基本类型的值是不可变的」这句话并不矛盾。
数据存放在栈区
原始数据类型直接存储在栈
(stack)
中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储。
2. 引用数据类型
值是可变的
let a = { age : 20 }；
a.age = 21；
console.log(a.age) //21
同时保存在栈内存和堆内存
引用数据类型占据空间大，大小不固定，储存在堆内存，但是指向该引用数据类型的变量指针「a」是储存在栈内存中。
当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。
基本数据类型的赋值为复制了一个新的值，对新变量的修改不会影响原变量。
let a = 1;
let b = a;
b++
console.log(a) // 1
console.log(b) // 2
但是引用数据类型就不一样，因为引用数据内型占用空间大，所以赋值操作是将新变量指针指向了原对象，修改其一都会影响到另一个。
let a={id=1234}
let b=a
b.id=1222
console.log(a.id) // 1222
console.log(b.id) // 1222
关于引用对象的拷贝又分为深拷贝和浅拷贝，限于篇幅就留给下篇文章了。
1. typeof
这应该初学者首次接触的类型判断方法了，它返回一个表示数据类型的字符串，返回结果包括：
typeof Symbol();
// symbol 正确
typeof '';
// string 正确
typeof 1;
// number正确
typeof true;
//boolean 正确
typeof undefined;
//undefined 正确
typeof new Function();
// function 正确
typeof null;
//object 无效
typeof [] ;
//object 无效
typeof new Date();
//object 无效
typeof new RegExp();
//object 无效
typeof 缺点
可以看到
Date
和
RegExp
对象都只是被是被成了
object
对象，也就是说除
function
以外的对象都会被识别成
object
，这样显然是不合理的，这时就需要
instanceof
来进行判断。
2. instanceof
instanceof
运算符用于检测构造函数的
prototype
属性是否出现在某个实例对象的原型链上。简单来说就是
instanceof
是用来判断 A 是否为 B 的实例，表达式为
A (object) instanceof B (constructor)
如果 A 是 B 的实例，则返回
true
,否则返回
false
。
// 定义构造函数
function C(){}
function D(){}
var o = new C();
o instanceof C; // true，因为 Object.getPrototypeOf(o) === C.prototype
o instanceof D; // false，因为 D.prototype 不在 o 的原型链上
o instanceof Object; // true，因为 Object.prototype.isPrototypeOf(o) 返回 true
C.prototype instanceof Object // true，同上
C.prototype = {};
var o2 = new C();
o2 instanceof C; // true
o instanceof C; // false，C.prototype 指向了一个空对象,这个空对象不在 o 的原型链上.
D.prototype = new C(); // 继承
var o3 = new D();
o3 instanceof D; // true
o3 instanceof C; // true 因为 C.prototype 现在在 o3 的原型链上
[] instanceof Array; //true
{} instanceof Object;//true
new Date() instanceof Date;//true
new RegExp() instanceof RegExp//true
instanceof 的缺点
instanceof 方法判断的是是否处于原型链上，而不是是不是处于原型链最后一位，所以会出现下面这种情况：
var arr = [1, 2, 3];
console.log(arr instanceof Array) // true
console.log(arr instanceof Object); // true
function fn(){}
console.log(fn instanceof Function)// true
console.log(fn instanceof Object)// true
因为所有原型链的尽头都是 object，所以就造成了这种状况。
当你自定义了一个类 A，并且继承了一个原生类 B，这个时候检测结果未必准确：
A instanceof A // true
A instanceof B // true
A instanceof Object true
对于基本数据类型来说，字面量方式创建出来的结果和实例方式创建的是有一定区别的
console.log(1 instanceof Number)//false
console.log(new Number(1) instanceof Number)//true
从严格意义上来讲，只有实例创建出来的结果才是标准的对象数据类型值，也是标准的 Number 这个类的一个实例；
对于字面量方式创建出来的结果是基本的数据类型值，不是严谨的实例，但是由于 JS 的松散特点，导致了可以使用
Number.prototype
上提供的方法。
对于特殊的数据类型
null
和
undefined
，他们的所属类是
Null
和
Undefined
，但是浏览器把这两个类保护起来了，不允许我们在外面访问使用。
3. constructor
constructor
作用和
instanceof
非常相似。
但
constructor
检测
Object
与
instanceof
不一样，还可以处理基本数据类型的检测。
var aa=[1,2];
console.log(aa.constructor===Array);//true
console.log(aa.constructor===RegExp);//false
console.log((1).constructor===Number);//true
var reg=/^$/;
console.log(reg.constructor===RegExp);//true
console.log(reg.constructor===Object);//false
constructor 的缺点
null 和 undefined 是无效的对象，因此是不会有
constructor
