摘要：看到下面的題，是不是已經(jīng)蒙了，讀完這篇文章，就能順利通關(guān)了沒(méi)有輸出數(shù)據(jù)類型判斷數(shù)據(jù)類型數(shù)據(jù)類型一共有種，類型判斷特殊情況由此可以看出，不能區(qū)分?jǐn)?shù)組，和對(duì)象運(yùn)算符返回一個(gè)布爾值，表示對(duì)象是否為某個(gè)構(gòu)造函數(shù)的實(shí)例。

無(wú)論筆試還是面試，總會(huì)問(wèn)到數(shù)據(jù)類型和隱式轉(zhuǎn)換。今天徹底整理一下這塊的知識(shí)，希望對(duì)大家有幫助。

看到下面的題，是不是已經(jīng)蒙了，讀完這篇文章，就能順利通關(guān)了

console.log([] == 0) //true 

console.log(![] == 0)  //true 

console.log([] == ![]) //true

console.log([] == []) //false

console.log({} == {}) //false

console.log({} == !{}) //false

console.log([] == false) //true

console.log({} == false) //false

if([]) {console.log(3)} //3 

if([1] == [1]){console.log(4)} //沒(méi)有輸出

console.log("2" > 10) //false

console.log("2" > "10") //true

js數(shù)據(jù)類型一共有7種，undefined、 null、 boolean 、string、 number、 object、 Symbol

typeof undefined //undefined
typeof true //boolean
typeof 42 //number
typeof "42" //string
typeof { life: 42 } //object
let s = Symbol();
typeof s //symbol

//特殊情況
typeof [1,2,3,4]// object
typeof null //object
typeof new Date()  //object
typeof function () {}  //function

由此可以看出，typeof不能區(qū)分?jǐn)?shù)組， null和對(duì)象

let getType=Object.prototype.toString;

getType.call(undefined) //[object Undefined]

console.log(getType.call(true)) //[object Boolean]

console.log(getType.call(42)) //[object Number]

console.log(getType.call(Symbol()))//[object Symbol]

console.log(getType.call([1,2,3,4])) //[object Array]

console.log(getType.call(null))//[object Null]

console.log(getType.call(new Date())) //[object Date]

console.log(getType.call(function () {} )) //[object Function]

instanceof運(yùn)算符返回一個(gè)布爾值，表示對(duì)象是否為某個(gè)構(gòu)造函數(shù)的實(shí)例。

instanceof運(yùn)算符的左邊是實(shí)例對(duì)象，右邊是構(gòu)造函數(shù)。它會(huì)檢查右邊構(gòu)建函數(shù)的原型對(duì)象（prototype），是否在左邊對(duì)象的原型鏈上。

new Date instanceof Date //true
[1,2,3] instanceof Array //true

instanceof運(yùn)算符只能用于對(duì)象，不適用原始類型的值。

prototype對(duì)象有一個(gè)constructor屬性，默認(rèn)指向prototype對(duì)象所在的構(gòu)造函數(shù)。

function P() {}
P.prototype.constructor === P // true

[1,2].constructor === Array //true
"123".constructor === String //true

instanceof、constructor、Object.prototype.toString.call、Array.isArray

[1,2] instanceof Array //true
[1,2].constructor === Array //true
Object.prototype.toString.call([1,2]) === "[object Array]" //true
Array.isArray([1,2]) //true

轉(zhuǎn)換成json字符串判斷

JSON.stringify({}) == "{}"

for in 循環(huán)判斷

let isEmptyObject = function(obj) {
    for (let key in obj) {
        return false;
    }
    return true;
}
console.log(isEmptyObject(obj));//true

使用ES6的Object.keys()

Object.keys({}).length === 0

類數(shù)組和數(shù)組都可以讀寫，獲取長(zhǎng)度，遍歷，但是類數(shù)組不能調(diào)用數(shù)組的方法，比如push等

Array.prototype.slice.call(arguments)

或者Array.from(arguments)

"abc".split("").reverse().join("")

["a", "b", "c"].join("") //"abc"

"abc".split("") //["a", "b", "c"]

// 數(shù)值：轉(zhuǎn)換后還是原來(lái)的值
Number(324) // 324

// 字符串：如果可以被解析為數(shù)值，則轉(zhuǎn)換為相應(yīng)的數(shù)值
Number("324") // 324

// 字符串：如果不可以被解析為數(shù)值，返回 NaN
Number("324abc") // NaN

// 空字符串轉(zhuǎn)為0
Number("") // 0

// 布爾值：true 轉(zhuǎn)成 1，false 轉(zhuǎn)成 0
Number(true) // 1
Number(false) // 0

// undefined：轉(zhuǎn)成 NaN
Number(undefined) // NaN

// null：轉(zhuǎn)成0
Number(null) // 0

//對(duì)象轉(zhuǎn)化
Number({a: 1}) // NaN
Number({}) //NaN 

//數(shù)組
Number([1, 2, 3]) // NaN
Number([5]) // 5
Number([]) //0

Number方法參數(shù)是對(duì)象時(shí)轉(zhuǎn)換規(guī)則

第一步，調(diào)用對(duì)象自身的valueOf方法。如果返回原始類型的值，則直接對(duì)該值使用Number函數(shù)，不再進(jìn)行后續(xù)步驟。

第二步，如果valueOf方法返回的還是對(duì)象，則改為調(diào)用對(duì)象自身的toString方法。如果toString方法返回原始類型的值，則對(duì)該值使用Number函數(shù)，不再進(jìn)行后續(xù)步驟。

第三步，如果toString方法返回的是對(duì)象，就報(bào)錯(cuò)。

轉(zhuǎn)換規(guī)則示例：

var obj = {x: 1};
Number(obj) // NaN

// 等同于
if (typeof obj.valueOf() === "object") {
  Number(obj.toString());
} else {
  Number(obj.valueOf());
}

先使用valueOf返回了對(duì)象本身，再代用toString()返回了"[object Object]"

注意：
任何涉及NaN的操作都返回NaN，NaN和任何值不相等

除了以下值的轉(zhuǎn)換結(jié)果為false，其他的值全部為true。

false, "", 0, NaN, null, undefined

（1）原始類型值

//數(shù)值：轉(zhuǎn)為相應(yīng)的字符串。
String(123) // "123"

//字符串：轉(zhuǎn)換后還是原來(lái)的值。
String("abc") // "abc"

//布爾值：true轉(zhuǎn)為字符串"true"，false轉(zhuǎn)為字符串"false"。
String(true) // "true"

//undefined：轉(zhuǎn)為字符串"undefined"。
String(undefined) // "undefined"


//null：轉(zhuǎn)為字符串"null"。
String(null) // "null"

（2）對(duì)象

//String方法的參數(shù)如果是對(duì)象，返回一個(gè)類型字符串
String({a: 1}) // "[object Object]"


//如果是數(shù)組，返回該數(shù)組的字符串形式。
String([1, 2, 3]) // "1,2,3"

String方法背后的轉(zhuǎn)換規(guī)則，與Number方法基本相同，只是互換了valueOf方法和toString方法的執(zhí)行順序。

if條件，while,

主要發(fā)生在字符串加法，一個(gè)值為字符串，另一個(gè)非字符串，則后者直接轉(zhuǎn)為字符串

"5" + 1 // "51"
"5" + true // "5true"
"5" + {} // "5[object Object]"

除了加法運(yùn)算符（+）有可能把運(yùn)算子轉(zhuǎn)為字符串，其他運(yùn)算符都會(huì)把運(yùn)算子自動(dòng)轉(zhuǎn)成數(shù)值。

++/--(自增自減運(yùn)算符) 

+ - * / %(算術(shù)運(yùn)算符) 

+ > < >= <= == != === !=== (關(guān)系運(yùn)算符)

"5" - "2" // 3
"5" * "2" // 10
true - 1  // 0
false / "5" // 0

//"abc"轉(zhuǎn)為數(shù)值為NaN,NaN任何運(yùn)算都是NaN
"abc" - 1   // NaN

//null進(jìn)行Number運(yùn)算轉(zhuǎn)成0
null + 1 // 1

//undefined轉(zhuǎn)為數(shù)值時(shí)為NaN
undefined + 1 // NaN

（1）原始類型的數(shù)據(jù)會(huì)轉(zhuǎn)換成數(shù)值類型再進(jìn)行比較。

1 == true // true
// 等同于 1 === Number(true)

0 == false // true
// 等同于 0 === Number(false)

2 == true // false
// 等同于 2 === Number(true)


"true" == true // false
// 等同于 Number("true") === Number(true)
// 等同于 NaN === 1

"" == 0 // true
// 等同于 Number("") === 0
// 等同于 0 === 0

"" == false  // true
// 等同于 Number("") === Number(false)
// 等同于 0 === 0

"1" == true  // true
// 等同于 Number("1") === Number(true)
// 等同于 1 === 1

"
  123  	" == 123 // true
// 因?yàn)樽址D(zhuǎn)為數(shù)字時(shí)，省略前置和后置的空格

（2）對(duì)象與原始類型值比較

對(duì)象（這里指廣義的對(duì)象，包括數(shù)組和函數(shù)）與原始類型的值比較時(shí)，對(duì)象轉(zhuǎn)化成原始類型的值，再進(jìn)行比較。

[1] == 1 // true
// 等同于 Number([1]) == 1

[1] == "1" // true
// 等同于 Number([1]) == Number("1")

[1] == true // true
// 等同于 Number([1]) == Number(true)

//true,空數(shù)組valueOf還是空數(shù)組，toString()轉(zhuǎn)成得到空字符串，空字符串調(diào)用Number轉(zhuǎn)成0
console.log([] == 0) //true 

//true，非的運(yùn)算級(jí)別高，空數(shù)組轉(zhuǎn)為布爾值為true,所以![]得到的false，Number轉(zhuǎn)換為0， 最后結(jié)果還是true
console.log(![] == 0)  //true 

//true,前面是調(diào)用valueOf()后調(diào)用toString()轉(zhuǎn)成false，后邊是非轉(zhuǎn)成false
console.log([] == ![]) 


//false，2個(gè)數(shù)組放在堆里面，棧中存儲(chǔ)的是地址
console.log([] == []) 

//引用類型存儲(chǔ)在堆中，棧中的是地址，所以是false
console.log({} == {}) 

//{}.valueOf().toString()得到的是[object, Object], !{}得到的是false，Number轉(zhuǎn)換后不相等
console.log({} == !{})

//數(shù)組的valueOf().toString()后為空，所以是真
console.log([] == false) //true

//因?yàn)閷?duì)象調(diào)用valueOf后為{}, toString后轉(zhuǎn)為[object, Object]，Number后是NaN,
//任何涉及NaN的操作都返回NaN，NaN和任何值不相等
console.log({} == false) //false

//空數(shù)組的boolean值為true
if([]) {console.log(3)} //3 

//2個(gè)數(shù)組的棧地址不同
if([1] == [1]){console.log(4)} //沒(méi)有輸出

//false,轉(zhuǎn)成2>10
console.log("2" > 10) 

//都是字符串，按照字符串的unicode轉(zhuǎn)換，"2".charCodeAt() > "10".charCodeAt = 50 > 49
console.log("2" > "10") 

//都是字符串，按照字符串的unicode轉(zhuǎn)換
console.log("abc" > "b") //false

參考：http://javascript.ruanyifeng....