ECMAScript数据类型概念:

　　ECMAScript数据类型分为两类：原始类型和对象类型（即基本类型和引用类型）；

　　ECMAScript数据类型也可以分为可变类型和不可变类型，数组和对象属于可变类型，Undefined、Null、Boolean、Number 和 String属于不可变类型；

　　ECMAScript 包含 5 种原始类型（primitive type），即 Undefined、Null、Boolean、Number 和 String，除此之外的就都是对象了（例如：对象、数组、函数）！！！

两种数据类型的存储方式：

　　基本类型值：指的是保存在栈内存中的简单数据段；

　　引用类型值：指的是那些保存在堆内存中的对象，意思是，变量中保存的实际上只是一个指针，这个指针指向内存中的另一个位置，由该位置保存对象。

两种数据类型的访问方式：

　　基本类型值：按值访问，操作的是他们实际保存的值；

　　引用类型值：按引用访问，当查询时，我们需要先从栈中读取内存地址，然后再顺藤摸瓜地找到保存在堆内存中的值。

两种数据类型的复制：

　　基本类型变量的复制：从一个变量向一个变量复制时，会在栈中创建一个新值，然后把值复制到为新变量分配的位置上；

　　引用类型变量的复制：进行引用类型变量的复制时，实际上是将存储在栈中的指针进行复制并将其保存在栈内存中，而这个复制的指针副本和原指针指向存储在堆中的同一个对象。复制操作结束后，两个变量实际上将引用同一个对象；因此改变其中的一个，将影响另一个。以下有两个例子，可以自行体会下！

　　var A = { name: "福尔摩斯"};
　　var B = A;
　　A.name="华生"; //此时修改的是Object的属性值，而变量B和A指向的是内存中的同一个Object，所以B的修改会对A产生影响
　　console.log(A.name);  //华生
　　console.log(B.name);  //华生

　　var A= { name: "福尔摩斯"};
　　var B = A;
　　B= {name:"华生"};  //此时B变量指向了内存中的一个新对象 {name:"华生"}，B变量存储的地址也是指向这个新的Object，所以B的修改对A不会再产生影响
　　console.log(A.name);  //福尔摩斯
　　console.log(B.name);  //华生

数据类型判断：

1.typeof

　　typeof可以解决大部分的数据类型判断，是一个一元运算，放在一个运算值之前，其返回值为一个字符串，该字符串说明运算数的类型，所以判断某个是否为String类型，可以直接 if(typeof(你的值) == "string"){}；

　　var a = "hello world";
　　var b = 222;
　　var c= [1,2,3];
　　var d = new Date();
　　var e = function(){alert(111);};
　　var f = function(){this.name="22";};
　　console.log(typeof a); //string
　　console.log(typeof b); //number
　　console.log(typeof c); //object
　　console.log(typeof d); //object
　　console.log(typeof e); //function
　　console.log(typeof f); //function

　　console.log(typeof a=="string"); //true

　　console.log(typeof b=="number"); //true

2. instanceof

 　　instanceof可以判断已知对象类型的方法；

　　var c= [1,2,3];
　　var d = new Date();
　　var e = function(){alert(111);};
　　console.log(c instanceof Array);  //true
　　console.log(d instanceof Date);  //true
　　console.log(e instanceof Function);  //true

3. constructor

　　根据对象的constructor判断

　　var c= [1,2,3];
　　var d = new Date();
　　var e = function(){alert(111);};
　　console.log(c.constructor=== Array);  //true
　　console.log(d.constructor=== Date);  //true
　　console.log(e.constructor=== Function);  //true

　　但 constructor 在类继承时会出错

　　function A(){};
　　function B(){};
　　A.prototype = new B(); //A继承自B
　　var c = new A();
　　console.log(c.constructor === B);  //true
　　console.log(c.constructor === A);  //false

　　而instanceof方法不会出现该问题，对象直接继承和间接继承的都会报true

　　function A(){};
　　function B(){};
　　A.prototype = new B(); //A继承自B
　　var c = new A();
　　console.log(c instanceof B);  //true
　　console.log(c instanceof A);  //true

　　解决construtor的问题通常是让对象的constructor手动指向自己：

　　function A(){};
　　function B(){};
　　A.prototype = new B(); //A继承自B
　　var c = new A();
　　c.constructor=A;
　　console.log(c.constructor === B);  //true
　　console.log(c.constructor === A);  //false

4. prototype

　　Object.prototype.toString.call()这种方式既解决了instanceof存在的跨页面问题，也解决了属性检测方式所存在的问题，是一个很好的解决方案。