JS(ES6)中的基本數(shù)據(jù)類型:1.數(shù)值型（Number）：包括整數(shù)、浮點數(shù)、2.布爾型（Boolean）、3.字符串型（String）、4.數(shù)組（Array）、5.空值(Null) 、6.未定義（Undefined），基本數(shù)據(jù)類型是按值訪問的，因為可以直接操作保存在變量中的實際值。
引用類型：Object 、Array 、Function 、Data，引用數(shù)據(jù)類型是保存在堆內(nèi)存中的對象

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、數(shù)組、正則、Object的類型都為object

---

2.constructor

constructor 用于判斷一個變量的原型，constructor 屬性返回對創(chuàng)建此對象的數(shù)組函數(shù)的引用.
當一個函數(shù) F被定義時，JS引擎會為F添加 prototype 原型，然后再在 prototype上添加一個 constructor 屬性，并讓其指向 F 的引用,當執(zhí)行 var f = new F() 時，F 被當成了構造函數(shù)，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 作為構造函數(shù)來創(chuàng)建對象時，原型上的 constructor 就被遺傳到了新創(chuàng)建的對象上， 從原型鏈角度講，構造函數(shù) F 就是新對象的類型。這樣做的意義是，讓新對象在誕生以后，就具有可追溯的數(shù)據(jù)類型,也就是說對象的constructor屬性指向他的構造函數(shù)

所以內(nèi)置對象在內(nèi)部構建時闊以這樣做出判斷

注：

• null 和 undefined 是無效的對象，因此是不會有 constructor 存在的，這兩種類型的數(shù)據(jù)需要通過其他方式來判斷
• constructor屬性并非一定指向構造函數(shù)，他也是可以修改、變更的(當把F.prototype = {}改寫后,會默認把constructor覆蓋掉)

instanceof

instanceof 運算符用來測試一個對象在其原型鏈中是否存在一個構造函數(shù)的 prototype 屬性 及的構造函數(shù)有這些基礎類型：String、Number、Boolean、Undefined、Null、Symbol(ES6引入了一種新的原始數(shù)據(jù)類型Symbol，表示獨一無二的值)； 復雜類型：Array，Object； 其他類型：Function、RegExp、Date。 var obj = new Object() obj instanceof Object // true

注意左側必須是對象（object），如果不是，直接返回false，列如：

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

可以看出都是num，而且都是1，只是因為第一個不是對象，是基本類型，所以直接返回false，而第二個是封裝成對象，所以true。
這里要嚴格注意這個問題，有些說法是檢測目標的__proto__與構造函數(shù)的prototype相同即返回true，這是不嚴謹?shù)?#xff0c;檢測的一定要是對象才行，如：

基礎類型

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

上面例子可以看出，1與new Number(1)幾乎是一樣的，只是區(qū)別在于是否封裝成對象，所以instanceof的結果是不同的,string、boolean等，這些基礎類型一樣的。

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

new String(1)與String(1)是不同的，new是封裝成對象，而沒有new的只是基礎類型轉換，還是基礎類型
其他基礎類型一樣的。

復雜類型，比如數(shù)組與對象，甚至函數(shù)等，與基礎類型不同。

復雜類型

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

復雜類型從字面量是直接生成構造函數(shù)的，所以不會像基本類型一樣兩種情況。
但是上面那個問題，當然，基礎類型也會有這個問題，就是與Object對比。沒辦法，Object在原型鏈的上層，所以都會返回true，如下：

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

由于從下往上，比如你判斷是Number，那就沒必要判斷是不是Object了，因為已經(jīng)是Number了……

其他類型

var reg = new RegExp(//) reg instanceof RegExp // true reg instanceof Object // truevar 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() {}，然后分析：

a是new出來，所以是經(jīng)過構造，因此已經(jīng)是對象，不再是函數(shù)，所以false

a是經(jīng)過構造的對象，返回ture沒問題

A是個函數(shù)，這沒什么問題

{}.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 來調(diào)用，而不能直接調(diào)用 toString ， 從原型鏈的角度講，所有對象的原型鏈最終都指向了 Object， 按照JS變量查找規(guī)則，其他對象應該也可以直接訪問到 Object 的 toString方法，而事實上，大部分的對象都實現(xiàn)了自身的 toString 方法，這樣就可能會導致 Object 的 toString 被終止查找，因此要用 call/apply 來強制調(diào)用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的區(qū)別
js中的constructor和prototype
JS類型判斷
jquery源碼
揭開js之constructor屬性的神秘面紗

總結

以上是生活随笔為你收集整理的JavaScript类型判断的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。