JS數(shù)據(jù)類型判斷和數(shù)組判斷
js七種數(shù)據(jù)類型：Number, String, Boolean, symbol, null, undefined, object
前六種都是基本數(shù)據(jù)類型，只有object(數(shù)組array，函數(shù)function都屬于object)是引用數(shù)據(jù)類型。
undefined 和 null沒(méi)有本質(zhì)區(qū)別，undefined就是定義了一個(gè)變量或函數(shù)卻沒(méi)有給他賦值。
typeof實(shí)現(xiàn)原理
在判斷不是 object 類型的數(shù)據(jù)的時(shí)候，typeof能比較清楚的告訴我們具體是哪一類的類型。
但是很遺憾的一點(diǎn)是，typeof 在判斷一個(gè) object的數(shù)據(jù)的時(shí)候只能告訴我們這個(gè)數(shù)據(jù)是 object, 而不能細(xì)致的具體到是哪一種 object, 比如??
let s = new String('abc');
typeof s === 'object'// true
s instanceof String // true
要想判斷一個(gè)數(shù)據(jù)具體是哪一種 object 的時(shí)候，我們需要利用 instanceof 這個(gè)操作符。
js 在底層存儲(chǔ)變量的時(shí)候，會(huì)在變量的機(jī)器碼的低位1-3位存儲(chǔ)其類型信息??
- 000：對(duì)象
- 010：浮點(diǎn)數(shù)
- 100：字符串
- 110：布爾
- 1：整數(shù)
但是對(duì)于 undefined 和 null 來(lái)說(shuō)，這兩個(gè)值的信息存儲(chǔ)是有點(diǎn)特殊的。 - null：所有機(jī)器碼均為0
- undefined：用 ?2^30 整數(shù)來(lái)表示
所以，typeof 在判斷 null 的時(shí)候就出現(xiàn)問(wèn)題了，由于 null 的所有機(jī)器碼均為0，因此直接被當(dāng)做對(duì)象來(lái)看待。
然而用 instanceof 來(lái)判斷的話??
null instanceof null // TypeError: Right-hand side of 'instanceof' is not an object
null 直接被判斷為不是 object，這也是 JavaScript 的歷史遺留bug,可以參考typeof
最好是用 typeof 來(lái)判斷基本數(shù)據(jù)類型（包括symbol），避免對(duì) null 的判斷。
Object.prototype.toString
還有一個(gè)不錯(cuò)的判斷類型的方法，就是Object.prototype.toString，我們可以利用這個(gè)方法來(lái)對(duì)一個(gè)變量的類型來(lái)進(jìn)行比較準(zhǔn)確的判斷
Object.prototype.toString.call(1) // "[object Number]"
Object.prototype.toString.call('hi') // "[object String]"
Object.prototype.toString.call({a:'hi'}) // "[object Object]"
Object.prototype.toString.call([1,'a']) // "[object Array]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(() => {}) // "[object Function]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(Symbol(1)) // "[object Symbol]"
instanceof實(shí)現(xiàn)原理
instanceof是用來(lái)判斷對(duì)象的具體類型，其實(shí) instanceof 主要的作用就是判斷對(duì)象是否是構(gòu)造函數(shù)原型鏈上的實(shí)例。
let obj1 = {}
let obj2 = new Date()
let obj3 = []
let obj4 = Object.create(null)
obj1 instanceof Object // true
obj2 instanceof Object //true
obj2 instanceof Date // true
obj3 instanceof Object // true
obj3 instanceof Array // true
obj3 instanceof String //false
obj4 instanceof Object //false
// 由于obj4的原型是null， 因此是false
let person = function () {
}
let nicole = new person()
nicole instanceof person // true
當(dāng)然，instanceof 也可以判斷一個(gè)實(shí)例是否是其父類型或者祖先類型的實(shí)例。
let person = function () {
}
let programmer = function () {
}
programmer.prototype = new person()
let nicole = new programmer()
nicole instanceof person // true
nicole instanceof programmer // true
instanceof 的原理是什么呢？
其實(shí) instanceof 主要的實(shí)現(xiàn)原理就是只要右邊變量的 prototype 在左邊變量的原型鏈上即可。因此，instanceof 在查找的過(guò)程中會(huì)遍歷左邊變量的原型鏈，直到找到右邊變量的 prototype，如果查找失敗，則會(huì)返回 false，告訴我們左邊變量并非是右邊變量的實(shí)例。
function new_instance_of(leftVaule, rightVaule) {
let rightProto = rightVaule.prototype; // 取右表達(dá)式的 prototype 值
leftVaule = leftVaule.__proto__; // 取左表達(dá)式的__proto__值
while (true) {
if (leftVaule === null) {
return false;
}
if (leftVaule === rightProto) {
return true;
}
leftVaule = leftVaule.__proto__
}
}
看幾個(gè)有趣的例子
function Foo() {
}
Object instanceof Object // true
Function instanceof Function // true
Function instanceof Object // true
Foo instanceof Foo // false
Foo instanceof Object // true
Foo instanceof Function // true
要想全部理解 instanceof 的原理，除了我們剛剛提到的實(shí)現(xiàn)原理，我們還需要知道 JavaScript 的原型繼承原理。
- Object instanceof Object
由圖可知，Object 的 prototype 屬性是 Object.prototype, 而由于 Object 本身是一個(gè)函數(shù)，由 Function 所創(chuàng)建，所以 Object.proto 的值是 Function.prototype，而 Function.prototype 的 proto 屬性是 Object.prototype，所以我們可以判斷出，Object instanceof Object 的結(jié)果是 true 。用代碼簡(jiǎn)單的表示一下
leftValue = Object.__proto__ = Function.prototype;
rightValue = Object.prototype;
// 第一次判斷
leftValue != rightValue
leftValue = Function.prototype.__proto__ = Object.prototype
// 第二次判斷
leftValue === rightValue
// 返回 true
Function instanceof Function 和 Function instanceof Object 的運(yùn)行過(guò)程與 Object instanceof Object 類似，故不再詳說(shuō)。
- Foo instanceof Foo
Foo 函數(shù)的 prototype 屬性是 Foo.prototype，而 Foo 的 proto 屬性是 Function.prototype，由圖可知，F(xiàn)oo 的原型鏈上并沒(méi)有 Foo.prototype ，因此 Foo instanceof Foo 也就返回 false 。
leftValue = Foo, rightValue = Foo
leftValue = Foo.__proto = Function.prototype
rightValue = Foo.prototype
// 第一次判斷
leftValue != rightValue
leftValue = Function.prototype.__proto__ = Object.prototype
// 第二次判斷
leftValue != rightValue
leftValue = Object.prototype = null
// 第三次判斷
leftValue === null
// 返回 false
- Foo instanceof Object
leftValue = Foo, rightValue = Object
leftValue = Foo.__proto__ = Function.prototype
rightValue = Object.prototype
// 第一次判斷
leftValue != rightValue
leftValue = Function.prototype.__proto__ = Object.prototype
// 第二次判斷
leftValue === rightValue
// 返回 true
- Foo instanceof Function
leftValue = Foo, rightValue = Function
leftValue = Foo.__proto__ = Function.prototype
rightValue = Function.prototype
// 第一次判斷
leftValue === rightValue
// 返回 true
總結(jié)
簡(jiǎn)單來(lái)說(shuō)，我們使用 typeof 來(lái)判斷基本數(shù)據(jù)類型是 ok 的，不過(guò)需要注意當(dāng)用 typeof 來(lái)判斷 null 類型時(shí)的問(wèn)題，如果想要判斷一個(gè)對(duì)象的具體類型可以考慮用instanceof，但是 instanceof 也可能判斷不準(zhǔn)確，比如一個(gè)數(shù)組，他可以被 instanceof 判斷為 Object。所以我們要想比較準(zhǔn)確的判斷對(duì)象實(shí)例的類型時(shí)，可以采取 Object.prototype.toString.call 方法。
