在javascript中一共有6种基本数据类型和一种引用数据类型，如下所示：
基本类型：String、Number、Boolean、Undefined、Null、Symbol(es6)。由于其占据空间固定，是简单的数据段，数据大小可确定，故将其存储在栈（stack）中，按值访问。
引用类型：Object。其值大小会有所改变，所以不能将其放在栈中，否则会降低变量查询速度，因此，其值存储在堆（heap）中，而存储变量处的值是一个指针，指向存储该对象的内存处，即按地址访问。引用类型除Object外，还包括Function、Array、RegExp、Date等。
下面介绍常用4种判断数据类型的方案：
1. typeof
typeof是一个操作符，其右侧跟一个一元表达式，并返回这个表达式的数据类型。返回的结果用该类型的字符串(全小写字母)形式表示，包括以下6种：number、boolean、string、object、undefined、function。
var und=undefined;
var nul=null;
var boo=true;
var num=1;
var str='xys'
var obj=new Object();
var arr=[1,2,3];
var fun=function(){}
var date=new Date();
var reg = /a/g;
var err=new Error()
var arg;
(function getArg(){
arg=arguments;
})();
console.log(typeof und); // undefined
console.log(typeof nul); // object
console.log(typeof boo); // boolean
console.log(typeof num); // number
console.log(typeof str); // string
console.log(typeof obj); // object
console.log(typeof arr); // object
console.log(typeof fun); // function
console.log(typeof date); // object
console.log(typeof reg); // object
console.log(typeof err); // object
console.log(typeof arg); // object
由上面的代码可以看出，基本类型除null外，都能准确检测并返回正确的类型（null返回Object），而引用类型除Function类型能准确返回function字符串外，其它都返回了Object字符串。
2. instanceof
instanceof 是用来判断A是否为B的实例，表达式为：A instanceof B，如果A是B的实例，则返回true，否则返回false。在这里需要特别注意的是：instanceof检测的是原型。
用一段伪代码来模拟内部执行过程：
instanceof (A,B) = {
var L = A.__proto__;
var R = B.prototype;
if(L === R){
//A的内部属性__proto__指向B的原型对象
return true;
}
return false;
}
从上面的例子可以看出，当A的proto指向B的prototype时，就认为A就是B的实例，我们来看几个例子：
[] instanceof Array; //true
{} instanceof Object; //true
new Date() instanceof Date; //true
function Person(){};
new Person() instanceof Person //true
[] instanceof Object; //true
new Date() instanceof Object;//true
new Person instanceof Object;//true
由此可见instanceof 即认为 [ ] 是Array的实例，但也认为 [ ] 是Object的实例（与原型链之间的继承指向有关），所以instanceof 只能用来判断两个对象是否属于实例关系， 而不能判断一个对象实例具体属于哪种类型。
3.constructor
当一个函数F被定义时，js引擎会为F添加prototype原型，然后再在prototype上添加一个constructor属性，并让其指向F的引用。如下所示：
当执行var f = new F()时，F被当成了构造函数，f是F的实例对象，此时F原型上的constructor传递到了f上，因此f.constructor == F
可以看出，F 利用原型对象上的 constructor 引用了自身，当 F 作为构造函数来创建对象时，原型上的 constructor 就被遗传到了新创建的对象上， 从原型链角度讲，构造函数 F 就是新对象的类型。这样做的意义是，让新对象在诞生以后，就具有可追溯的数据类型。
同样，JavaScript 中的内置对象在内部构建时也是这样做的：
细节问题：
- null 和 undefined 是无效的对象，因此是不会有 constructor 存在的，这两种类型的数据需要通过其他方式来判断。
-
函数的 constructor 是不稳定的，这个主要体现在自定义对象上，当开发者重写 prototype 后，原有的constructor 引用会丢失，constructor 会默认为 Object
为什么变成了 Object？
因为 prototype 被重新赋值的是一个 { }， { } 是 new Object() 的字面量，因此 new Object() 会将 Object 原型上的 constructor 传递给 { }，也就是 Object 本身。
4.toString
toString 是 Object 原型对象上的方法，使用 call 来调用该方法会返回调用者的类型字符串，格式为 [object,xxx]，xxx 是调用者的数据类型，包括：String、Number、Boolean、Undefined、Null、Function、Date、Array、RegExp、Error、HTMLDocument 等， 基本上，所有的数据类型都可以通过这个方法获取到。
Object.prototype.toString.call('') ; // [object String]
Object.prototype.toString.call(1) ; // [object Number]
Object.prototype.toString.call(true) ; // [object Boolean]
Object.prototype.toString.call(Symbol()); //[object Symbol]
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) ; // [objectHTMLDocument]
Object.prototype.toString.call(window) ;
//[object global] window是全局对象 global 的引用
需要注意的是，必须通过 call 或 apply 来调用，而不能直接调用 toString ， 从原型链的角度讲，所有对象的原型链最终都指向了 Object， 按照JS变量查找规则，其他对象应该也可以直接访问到 Object 的 toString方法，而事实上，大部分的对象都实现了自身的 toString 方法，这样就可能会导致 Object 的 toString 被终止查找，因此要用 call/apply 来强制调用Object 的 toString 方法。
参考链接：https://blog.csdn.net/liwenfei123/article/details/77978027
