js专题之类型判断

在ES6以前，javascript有6种基本的数据类型：主要分为5种原始类型和1种引用类型。（bigint ，symbol 此处暂不处理）

原始类型：Boolean、Number、String、Undefined、Null、

引用类型：Object

原始类型，它们的值只包含一个单独的内容，存放在栈中；

引用类型用于存储数据集合或更复杂的实体，存放在堆中，在栈中会存放一个指针，指向堆中的地址；引用类型除 Object 外，还包括 Function 、Array、RegExp、Date 等等。

类型的多样型，使得js的类型判断也存在多种方法，以下就常用的几种介绍：

1.typeof

typeof是最常用的类型判断方法：Boolean、Number、String、Undefined、Null、Object、Function
采用typeof判断出来的类型对应关系分别为：boolean、number、string、undefined、object、object、function。可以看出除了null跟object其他的均能判断出正确的类型

 

2.instanceof

用来判断 a 是否为 b 的实例，写法为 a  instanceof b; 是则返回true,否则返回false

 

3.constructor

每一个对象实例都可以通过constructor访问其构造函数，因此可以通过constructor判断一些引用类型的数据类型：

    var obj = {a: 1}      
    var array = [1, 2, 3];  
    var date = new Date();  
    var error = new Error(); 
    var reg = /a/g;         
    var func = function a(){}; 
    
    console.log(obj.constructor === Object) // true
    console.log(array.constructor === Array) // true
    console.log(date.constructor === Date) // true
    console.log(error.constructor === Error) // true
    console.log(reg.constructor === RegExp) // true
    console.log(func.constructor === Function) // true

4.Object.prototype.toString

话不多说，先上代码：

    var number = 1;          // [object Number]
    var string = '123';      // [object String]
    var boolean = true;      // [object Boolean]
    var und = undefined;     // [object Undefined]
    var nul = null;          // [object Null]
    var obj = {a: 1}         // [object Object]
    var array = [1, 2, 3];   // [object Array]
    var date = new Date();   // [object Date]
    var error = new Error(); // [object Error]
    var reg = /a/g;          // [object RegExp]
    var func = function a(){}; // [object Function]

    let tostring = Object.prototype.toString
    console.log(tostring.call(1))
    console.log(tostring.call('123'))
    console.log(tostring.call(true))
    console.log(tostring.call(null))
    console.log(tostring.call(undefined))
    console.log(tostring.call({}))    
    console.log(tostring.call(new Date))
    console.log(tostring.call(new Array))
    console.log(tostring.call(new Error))
    console.log(tostring.call(a))
    console.log(tostring.call(/a/g))

通过如上代码，是不是发现通过调用 Object.prototype.toString 会返回一个由 "[object " 和 class 和 "]" 组成的字符串，而 class 是要判断的对象的内部属性。

于是，结合typeof封装了一个type方法，可以快速判断出数据类型的公共方法:

    function type(param) {
      // es6中null的类型为object
      if(param === null){
        return param+''
      }
      if(typeof param === 'object'){        
        let val = Object.prototype.toString.call(param).split(' ')[1]
        let type = val.substr(0,val.length-1).toLowerCase()
        return type
      }else {
        return typeof param
      }
    }

    console.log(type(number)) // number
    console.log(type(string)) // string
    console.log(type(boolean)) // boolean
    console.log(type(und)) // undefined
    console.log(type(nul)) // null
    console.log(type(obj)) // object
    console.log(type(array)) // array
    console.log(type(date)) // date
    console.log(type(error)) // error
    console.log(type(reg)) // regexp
    console.log(type(func)) // function