javaScript数据类型和检测数据类型的方法解析

JavaScript 数据类型有两种，分别是基本数据类型和引用数据类型。
        1.基本数据类型
        Number
        String
        Boolean
        Undefined
        Null
        Symbol (ES6 新增，表示独一无二的值)
        特点：原始数据类型直接存储在栈(stack)中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储。
        2.引用数据类型
        Object
        Function
        Array
        特点：引用数据类型占据空间大，大小不固定，储存在堆内存，但是指向该引用数据类型的变量指针「a」是储存在栈内存中。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。
    
        数据类型的检测方法
        方法一、typeof 
            返回结果包括以下的数据类型：
            number
            boolean
            string
            symbol
            object
            undefined
            function
          
            console.log(typeof 11);	
            console.log(typeof Symbol());											//number
            console.log(typeof NaN);												//Symbol
            console.log(typeof "aaa");												//String
            console.log(typeof true);												//boolean
            console.log(typeof undefined);											//undefined
            console.log(typeof null);												//object
            console.log(typeof []);													//object
            console.log(typeof {});													//object
            console.log(typeof function () { });									//function
            console.log(typeof new Date())                                          //object
            console.log(typeof new RegExp())                                        //object

            总结：
            1.typeof 返回的数据不包括null、Array类型  
            2.空的数组[]、空的对象{}、null类型 使用typeof都返回object，不能判断 array 和 null类型
            3.其他的数据类型返回对应的数据类型
            4.NAN返回的是number数据类型
            5.缺点  可以看到 Date 和 RegExp 对象都只是被是被成了 object 对象，也就是说除 function 以外的对象都会被识别成 object ，这样显然是不合理的，这时就需要 instanceof 来进行判断。
        
          方法二、instanceof  instanceof 运算符用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上   
            [] instanceof Array; //true
            {} instanceof Object;//true
            new Date() instanceof Date;//true
            new RegExp() instanceof RegExp//true
            console.log(11 instanceof Number);									//false
            console.log('11' instanceof String);								//false
            console.log([] instanceof Array);									//true
            console.log([] instanceof Object);									//true
            console.log({} instanceof Object);									//true
            console.log(null instanceof Object);									//false
            console.log(undefined instanceof Object);								//false

            instanceof缺点:
            1.是否处于原型链上的判断方法不严谨
            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
            2.无法判断字面量方式创建的基本数据类型
            对于基本数据类型来说，字面量方式创建出来的结果和实例方式创建的是有一定区别的
            console.log(1 instanceof Number)//false
            console.log(new Number(1) instanceof Number)//true
            从严格意义上来讲，只有实例创建出来的结果才是标准的对象数据类型值，也是标准的Number这个类的一个实例；对于字面量方式创建出来的结果是基本的数据类型值，不是严谨的实例，但是由于JS的松散特点，导致了可以使用Number.prototype上提供的方法。
            3. 无法检测 null 和 undefined
            对于特殊的数据类型null和undefined，他们的所属类是Null和Undefined，但是浏览器把这两个类保护起来了，不允许我们在外面访问使用。
           
            方法三、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 缺点：
            1.无法检测 null 和 undefined
            null 和 undefined 是无效的对象，因此是不会有 constructor 存在的，这两种类型的数据需要通过其他方式来判断。
            2.不稳定
            函数的 constructor 是不稳定的，这个主要体现在把类的原型进行重写，在重写的过程中很有可能出现把之前的 constructor 给覆盖了，这样检测出来的结果就是不准确的，由此可知 instanceof 同样也存在这个问题。
            function Fn(){}
            Fn.prototype = new Array()
            var f = new Fn
            console.log(f.constructor)//Array

            方法四、Object.prototype.toString.call()方法  全能检测的方法 比较常用
            Object.prototype.toString.call('') ;   // [object String]
            Object.prototype.toString.call(1) ;    // [object Number]
            Object.prototype.toString.call(true) ; // [object Boolean]
            Object.prototype.toString.call(undefined) ; // [object Undefined]
            Object.prototype.toString.call(null) ; // [object Null]
            Object.prototype.toString.call(new Function()) ; // [object Function]
            Object.prototype.toString.call(new Date()) ; // [object Date]
            Object.prototype.toString.call([]) ; // [object Array]
            Object.prototype.toString.call(new RegExp()) ; // [object RegExp]
            Object.prototype.toString.call(new Error()) ; // [object Error]
            Object.prototype.toString.call(document) ; // [object HTMLDocument]
            Object.prototype.toString.call(window) ; //[object global] window是全局对象global的引用

            console.log(typeofObjectWay(null)) //[object Null]
            console.log(typeofObjectWay(undefined)) //[object undefined]
            console.log(typeofObjectWay(Symbol())) //[object Symbol]
            console.log(typeofObjectWay(112)) //[object Number]
            console.log(typeofObjectWay(NaN)) //[object Number]
            console.log(typeofObjectWay("aaa")) //[object String]
            console.log(typeofObjectWay(true)) //[object Boolean]
            console.log(typeofObjectWay(undefined))  //[object undefined]
            console.log(typeofObjectWay([])) //[object Array]
            console.log(typeofObjectWay({}))  //[object Object]
            console.log(typeofObjectWay(function () { }))  //[object Function]
            console.log(typeofObjectWay( Date()))  //[object Date]
            console.log(typeofObjectWay(new RegExp())) //[object RegExp]        
            
            function typeofObjectWay(type){
                return Object.prototype.toString.call(type);
            }