在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