JavaScript类型判断

JS(ES6)中的基本数据类型:1.数值型（Number）：包括整数、浮点数、2.布尔型（Boolean）、3.字符串型（String）、4.数组（Array）、5.空值(Null) 、6.未定义（Undefined），基本数据类型是按值访问的，由于能够直接操做保存在变量中的实际值。
引用类型：Object 、Array 、Function 、Data，引用数据类型是保存在堆内存中的对象

1.typeof

var a;
console.log("1:" + typeof a);
var b = null;
console.log("2:" + typeof b);
var c = undefined;
console.log("3:" + typeof c);
var d = new Object;
console.log("4:" + typeof d);
var e = function() {};
console.log("5:" + typeof e);
var f = {};
console.log("6:" + typeof f);
var g = '';
console.log("7:" + typeof g);
var h = [];
console.log("8:" + typeof h);
var i = true;
console.log("9:" + typeof i);
var j = 123;
console.log("10:" + typeof j);
var k = NaN;
console.log("11:" + typeof k);
var l = /^[-+]?\d+$/;
console.log("12:" + typeof l);

打印结果以下

总结：typeof对null、undefined、NaN、数组、正则、Object的类型都为object

---

2.constructor

constructor 用于判断一个变量的原型，constructor 属性返回对建立此对象的数组函数的引用.
当一个函数 F被定义时，JS引擎会为F添加 prototype 原型，而后再在 prototype上添加一个 constructor 属性，并让其指向 F 的引用,当执行 var f = new F() 时，F 被当成了构造函数，f 是F的实例对象，此时 F 原型上的 constructor 传递到了 f 上，所以 f.constructor === F

var F = function(){}
console.log(F.prototype);
var f = new F();
console.log(f.constructor===F) //true

不难看出，F 利用原型对象上的 constructor 引用了自身，当 F 做为构造函数来建立对象时，原型上的 constructor 就被遗传到了新建立的对象上， 从原型链角度讲，构造函数 F 就是新对象的类型。这样作的意义是，让新对象在诞生之后，就具备可追溯的数据类型,也就是说对象的constructor属性指向他的构造函数

因此内置对象在内部构建时阔以这样作出判断

注：

• null 和 undefined 是无效的对象，所以是不会有 constructor 存在的，这两种类型的数据须要经过其余方式来判断
• constructor属性并不是必定指向构造函数，他也是能够修改、变动的(当把F.prototype = {}改写后,会默认把constructor覆盖掉)

instanceof

instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性

及的构造函数有这些基础类型：String、Number、Boolean、Undefined、Null、Symbol(ES6引入了一种新的原始数据类型Symbol，表示独一无二的值)；
复杂类型：Array，Object；
其余类型：Function、RegExp、Date。

var obj = new Object()
obj instanceof Object // true

注意左侧必须是对象（object），若是不是，直接返回false，列如：

var num = 1
num instanceof Number // false

num = new Number(1)
num instanceof Number // true

能够看出都是num，并且都是1，只是由于第一个不是对象，是基本类型，因此直接返回false，而第二个是封装成对象，因此true。
这里要严格注意这个问题，有些说法是检测目标的__proto__与构造函数的prototype相同即返回true，这是不严谨的，检测的必定要是对象才行，如：

基础类型

var num = 1
num.__proto__ === Number.prototype // true
num instanceof Number // false

num = new Number(1)
num.__proto__ === Number.prototype // true
num instanceof Number // true
num.__proto__ === (new Number(1)).__proto__ // true

上面例子能够看出，1与new Number(1)几乎是同样的，只是区别在因而否封装成对象，因此instanceof的结果是不一样的,string、boolean等，这些基础类型同样的。

new String(1) // String {"1"}
String(1) // "1"

new String(1)与String(1)是不一样的，new是封装成对象，而没有new的只是基础类型转换，仍是基础类型
其余基础类型同样的。

复杂类型，好比数组与对象，甚至函数等，与基础类型不一样。

复杂类型

var arr = []
arr instanceof Array // true
arr instanceof Object // true
Array.isArray(arr) // true

复杂类型从字面量是直接生成构造函数的，因此不会像基本类型同样两种状况。
可是上面那个问题，固然，基础类型也会有这个问题，就是与Object对比。没办法，Object在原型链的上层，因此都会返回true，以下：

(new Number(1)) instanceof Object // true

因为从下往上，好比你判断是Number，那就不必判断是否是Object了，由于已是Number了……

其余类型

var reg = new RegExp(//)
reg instanceof RegExp // true
reg instanceof Object // true

var date = new Date()
date instanceof Date // true
date instanceof Object // true

除了Function，都同样，具体Function以下：

function A() {}
var a = new A()
a instanceof Function // false
a instanceof Object // true
A instanceof Function // true

这里要注意，function A() {}至关于var A; A = function() {}，而后分析：

1. a是new出来，因此是通过构造，所以已是对象，再也不是函数，因此false
2. a是通过构造的对象，返回ture没问题
3. A是个函数，这没什么问题

{}.toString.call(obj)

用法以下

console.log({}.toString.call(1));
console.log({}.toString.call("11"));
console.log({}.toString.call(/123/));
console.log({}.toString.call({}));
console.log({}.toString.call(function() {}));
console.log({}.toString.call([]));
console.log({}.toString.call(true));
console.log({}.toString.call(new Date()));
console.log({}.toString.call(new Error()));
console.log({}.toString.call(null));
console.log({}.toString.call(undefined));
console.log(String(null));
console.log(String(undefined));

返回以下

注意：必须经过 call 或 apply 来调用，而不能直接调用 toString ， 从原型链的角度讲，全部对象的原型链最终都指向了 Object， 按照JS变量查找规则，其余对象应该也能够直接访问到 Object 的 toString方法，而事实上，大部分的对象都实现了自身的 toString 方法，这样就可能会致使 Object 的 toString 被终止查找，所以要用 call/apply 来强制调用Object 的 toString 方法

jQuery中的方法$.type(),就是用到了toString

type: function( obj ) {
    if ( obj == null ) {
        return obj + "";
    }
    // Support: Android<4.0, iOS<6 (functionish RegExp)
    return typeof obj === "object" || typeof obj === "function" ?
        class2type[ toString.call(obj) ] || "object" :
        typeof obj;
},

分析源代码：

typeof obj === "object" || typeof obj === "function" ? class2type[ toString.call(obj) ]

经过判断传入类型，若是是object或者function类型就直接返回class2type 中键值是对的结果,若是不是,那么必定就是基本类型, 经过 typeof 就能够

class2type[ toString.call(obj) ] || "object"

这是为了防止一些未知状况的,若是未取到,就返回object，保证了程序可用性

参考文章:
JS类型判断，typeof/constructor/instanceof的区别
js中的constructor和prototype
JS类型判断
jquery源码
揭开js之constructor属性的神秘面纱