在JavaScript中，变量一共有七种内置类型，分别为：

string： 字符串类型，由单引号或双引号来说明，如"string"
number：数字类型，比如什么整数啊浮点数啊都叫数字。
Boolean: 布尔类型，也就是true和false啦。
undefined：未定义类型，就是你创建一个变量后却没给它赋值~
null: 空值，null就是没有，什么也不表示。
object: 对象类型，是我们在js中经常使用的类型。
symbol ： ES6引入了一种新的原始数据类型，Symbo表示独一无二的值。

判断js中数据类型的方法主要有：typeof、instanceof、 constructor、 prototype.toString.call()等，下面就逐一介绍它们的异同。

1、最常见的判断方法：typeof

console.log(typeof 'hello')   // string
console.log(typeof 1)   // number
console.log(typeof {})   // object
console.log(typeof function(){})   // function
console.log(typeof true)   // boolen
console.log(typeof Symbol())  //symbol
//其中typeof返回的类型都是字符串形式，需注意，例如：
console.log(typeof 'string' == "string") // true
console.log(typeof 'a' == 'String')  // false
//另外typeof 可以判断function的类型；在判断除Object类型的对象时比较方便。

2、判断已知对象类型的方法： instanceof

console.log([] instanceof Array) //判断是数组类型 true
console.log(new Date instanceof Date) //判断是日期类型  true
console.log(function(){} instanceof Function) //判断为function类型   true

注意：

1.instanceof 后面一定要是对象类型，并且大小写不能错，该方法适合一些条件选择或分支。

2.instanceof判断一个对象是否是另一个对象的实例,所以下面返回的是false:

console.log(true instanceof Boolean) //false
console.log('hello' instanceof String) //false
console.log(1 instanceof Number) // false

上面返回false的原因是，都是基本数据类型，不是对象，可以使用typeof来判断。使用new的形式就可以了，如下：

console.log(new String('hello') instanceof String) //true
console.log(new Number(1) instanceof Number) // true
console.log(new Boolean(true) instanceof Boolean) //true

3、根据对象的constructor判断

var a=[1,2];
console.log(a.constructor === Array); // true	数组
var b=1
console.log(b.constructor === Number);  // true	数字
var c='hello'
console.log(c.constructor === String); // true	字符串
var d={a: 1}
console.log(d.constructor === Object);  // true 对象
var e=Symbol()
console.log(e.constructor === Symbol);	// true 符号
var f = function a() { };
console.log(f.constructor === Function);  // true 函数
var j= new Date();
console.log(j.constructor === Date);	 // true 日期 
var h= new RegExp();
console.log(h.constructor === RegExp);	// true 正则

注意点1：如果数据不存在构造函数的时候，就会报错，如null,undefined：

var a=null
a.constructor// 报错：null 是 JS 原型链的起点，没有构造函数；
var b=undefined
b.constructor // 报错：undefined没有构造函数；
//错误提示：Uncaught TypeError: Cannot read property 'constructor' of null at <anonymous>:2:3

注意点2：constructor在类继承时会出错，解决construtor的问题通常是让对象的constructor手动指向自己。如下：

function A(){};
function B(){};
A.prototype = new B(); //A继承自B
var aObj = new A();
console.log(aobj.constructor === B) //true;
console.log(aobj.constructor === A) //false;
//而instanceof方法不会出现该问题，对象直接继承和间接继承的都会报true：
console.log(aobj instanceof B) -----//true;
console.log(aobj instanceof B) -----//true;
//言归正传，解决construtor的问题通常是让对象的constructor手动指向自己：
aobj.constructor = A; //将自己的类赋值给对象的constructor属性
console.log(aobj.constructor === A) //true;
console.log(aobj.constructor === B) //false; //基类不会为true;

4、prototype.toString.call()方法

var a=[1,2]
console.log(Object.prototype.toString.call(a) === '[object Array]') // true;
var b=1
console.log(Object.prototype.toString.call(b) === '[object Number]') // true;
var c='hello'
console.log(Object.prototype.toString.call(c) === '[object String]') // true;
var d=new Date()
console.log(Object.prototype.toString.call(d) === '[object Date]') // true;
var e=function(){}
console.log(Object.prototype.toString.call(e) === '[object Function]') // true;
var f={};
console.log(Object.prototype.toString.call(f) === '[object Object]') // true;
var j=Symbol()
console.log(Object.prototype.toString.call(j) === '[object Symbol]') // true;
var h=null
console.log(Object.prototype.toString.call(h) === '[object Null]')//true
var i=undefined
console.log(Object.prototype.toString.call(i)=== '[object Undefined]')	//true
var k=Math
console.log(Object.prototype.toString.call(k)=== '[object Math]')	//true

可以看出使用prototype.toString.call()方法，能更加精准的判断多种类型，比typeof判断的更多更具体。

链接: https://www.fly63.com/article/detial/566