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() {},然後分析:
- a是new出來,所以是經過構造,因此已經是對象,不再是函數,所以false
- a是經過構造的對象,返回ture沒問題
- 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屬性的神祕面紗