摘要：包裝對象即，與數(shù)值字符串布爾值相對應(yīng)的三個原生對象。顯示類型轉(zhuǎn)換強(qiáng)制轉(zhuǎn)換即，顯示調(diào)用函數(shù)進(jìn)行類型轉(zhuǎn)換。返回對象的字符串?dāng)?shù)值或布爾值表示，通常與返回的值相同。

原始類型：

number

string

boolean

null

undefined

Symbol

對象類型：

Object

Array

Function

原始類型（基本類型）和對象類型（引用類型）的區(qū)別：

原始類型不能修改值，對象類型可以。
分析：原始類型存儲在棧內(nèi)存中，對象類型存儲在堆內(nèi)存中。原始類型的修改都是重新賦值。
即，聲明一個原始類型，var a = 2;那么會在棧內(nèi)存中開辟一塊內(nèi)存用于存儲原始類型a，當(dāng)重新賦值a = 234的時候，會重新開辟一塊棧內(nèi)存用于存儲重新賦值的原始類型a，2則被垃圾回收機(jī)制回收。
至于對象類型，棧內(nèi)存中存的是對象數(shù)據(jù)在堆內(nèi)存中的首地址，也就是該數(shù)據(jù)的引用。在訪問變量的時候就會去堆內(nèi)存中找引用對象的值，修改的時候也是修改堆內(nèi)存中的值。

原始類型沒有屬性和方法，對象類型可以有

null和undefined的區(qū)別：

undefined表示一個未被賦值的棧內(nèi)存的空間，null表示棧空間的引用沒有指向一個地址

進(jìn)行顯示類型轉(zhuǎn)換時，null為0，undefined為NaN

typeof(null) === "object"
typeof(undefined) ==="undefined"

包裝對象-by阮一峰/W3cschool(2019.1.4)
JS語言：“一切皆對象”，數(shù)組和函數(shù)本質(zhì)上是對象，三種原始數(shù)據(jù)類型的值（數(shù)值、字符串、布爾值
）在一定條件下、也會自動轉(zhuǎn)為對象、這就是原始類型的“包裝對象”。
包裝對象：即，與數(shù)值、字符串、布爾值相對應(yīng)的Number、String、Boolean三個原生對象。三個原生對象可以把原始類型的值變成（包裝成）對象。

var num = new Number(123);
var str = new String("abc");
var bool = new Boolean(true);

例如：

var str = "test";//通過字符串字面量定義的字符串值不是對象
str.length  //4
str.slice(0,1) //"t"

var a = 7;
a.toString() //"7"

str是原始類型string的變量，進(jìn)行屬性和調(diào)用方法的操作時，js會通過new String()構(gòu)建一個包裝對象（臨時的），這個包裝對象再進(jìn)行屬性和方法的訪問，訪問結(jié)束后，js會銷毀該包裝對象，所以只能讀不能改。null和undefined沒有構(gòu)造函數(shù)，所以也沒有包裝對象，如果訪問其屬性和方法將會跑出異常。
補充：toString()方法是Number對象的方法，把數(shù)字轉(zhuǎn)換成字符串。

JS是弱類型，無論什么類型都是通過var來聲明。
https://www.jb51.net/article/...
一定為false的值：

0或+0、-0，NaN //數(shù)值
"" //空字符串值
false //false布爾值
undefined
null

if (a && b)的正確理解方式是：a && b進(jìn)行表達(dá)式求值后，然后再轉(zhuǎn)換為Boolean類型。
☆ 顯示類型轉(zhuǎn)換（強(qiáng)制轉(zhuǎn)換）
即，顯示調(diào)用String();Number();Boolean()函數(shù)進(jìn)行類型轉(zhuǎn)換。

var a = [9,8]//數(shù)組
    String(a)//"9,8"

var a = 123
String(a) // "123"
Boolean(a) // true
var b = "123a"
Number(b) // NaN
Boolean(b) // true

//引用類型顯示轉(zhuǎn)換為原始類型
var a = ["9"]
Number(a) // 9
String(a) // "9"
var b = {
c: "this is a time",
toString: function(){
return 5
}
}
Number(b) // 5
String(b) // "5"

☆ 隱式轉(zhuǎn)換（自動轉(zhuǎn)換，用的比較多）原始類型的類型轉(zhuǎn)換，引用類型的轉(zhuǎn)換。
通過運算符進(jìn)行轉(zhuǎn)換，例如：== + -
注意：===運算符，是類型和數(shù)值都一樣，才能返回true
以==為例：
首先，null和undefined==其他類型都為false。

null == undefined只能跟自己和對方==返回true，其他情況是false；
可以進(jìn)行強(qiáng)制類型轉(zhuǎn)換：

var a = null
String(a)
a==null //強(qiáng)制類型轉(zhuǎn)換，并不會影響a本身的值，只是在運算的時候不同

然后，原始類型之間的轉(zhuǎn)換，都是以構(gòu)造函數(shù)進(jìn)行轉(zhuǎn)換，即將==兩邊的值都轉(zhuǎn)換成Number再進(jìn)行比較
引用類型轉(zhuǎn)換為原始類型過程：
1.先調(diào)用valueOf()方法，如果返回原始類型，則結(jié)束，否則執(zhí)行下一步
2.接著調(diào)用toString()方法，得到初步原始類型（初步原始類型一定是一個非空字符串）
3.將得到的初步原始類型轉(zhuǎn)換為目標(biāo)原始類型

所有引?用類型的最頂層的proto對象(可以理解為基類)，都為Object的prototype，其必包含toString方法，該方法返回數(shù)據(jù)類型字符串，轉(zhuǎn)換為boolean為true，所以所有的對象都為true。

var a = {}, b = []
if(a) {}
if(b) {} // 不能通過這個?方式判定對象和數(shù)組為空，因為空數(shù)組或者空對象轉(zhuǎn)換成boolean值，都為true

原始類型的轉(zhuǎn)換：

“123” == false //false
“123” == true  //false

分析：true轉(zhuǎn)換為1了，false轉(zhuǎn)換成了0；“123”轉(zhuǎn)換成了123.
==符號會把兩邊都會類型轉(zhuǎn)換成Number，再進(jìn)行對比

var obj = {a:"123"}
console.dir()
obj.valueOf

☆ 拓展：
object類型具有valueOf()和toString()方法。valueOf()返回對象的字符串、數(shù)值或布爾值表示，通常與toString()返回的值相同。toString()返回對象的字符串表示。但是！！！！實際上：
拿數(shù)組為例，toString方法返回的是由數(shù)組中每個值的字符串形式拼接而成的一個由逗號分隔的字符串；valueOf方法返回的還是一個數(shù)組。

☆ ==與===
== 判斷相等時，如果兩邊類型不同時，會進(jìn)行類型轉(zhuǎn)換
===（絕對等于號） 判斷相等時，不進(jìn)行類型轉(zhuǎn)換，類型不同，其值?定不絕對等于
當(dāng)兩邊都為引用類型時，== 和 === 都是判斷兩邊是否指向同?個數(shù)據(jù)，是則為true，否則為
false

[] == [] // false
{} == {} // false
var a = b = {}
a == b // true
a === b // true

☆經(jīng)典面試題：設(shè)計一個函數(shù)，讓a既等于1又等于2又等于3。
考的是類型轉(zhuǎn)換，原始類型肯定是不可以的。

題目：a為何值時，下面表達(dá)式為true
if(a == 1 && a == 2 && a == 3){
//
}
答案：
var a = {
b: 0,
toString: function(){
return ++this.b
}
}      

原理：

1）typeof運算符

typeof 1 // ‘number’
typeof NaN // "number"
typeof {} // "Object"
typeof null // "Object"
typeof undefined // "undefined"
var a = function(){}
typeof a // "function"

缺點：typeof只能判斷原始類型和函數(shù)，不能判斷引用類型和null，它們都返回"object".
2)instanceof
使用方法：對象 instanceof 構(gòu)造方法

[] instanceof Array // true
[] instanceof Object // true
var b = {}
b instanceof Object // true
var a = function(){}
a instanceof Function // true

原理：instanceof運算符檢測左邊對象的原型鏈上是否有右邊構(gòu)造函數(shù)的prototype對象。
缺點：
只能用來判斷對象;
不能跨iframe使用，因為不同iframe其window不同.
3)constructor

[].constructor === Array // true
"123".constructor === String // true
function Fn(){
}
var f = new Fn()
f.constructor === Fn // true

原理：構(gòu)造函數(shù)的prototype對象指向構(gòu)造函數(shù)本身，創(chuàng)建新對象后，新對象繼承prototype對象，因此新對象的constructor指向了構(gòu)造函數(shù)。
缺點：不能用來判斷null、undefined；
prototype對象可被重寫，constructor會丟失。
4）toString——最通用的方法
toString是Object的原型?方法，默認(rèn)返回當(dāng)前對象的類型，對所有情況都可以判斷。

Object.prototype.toString.call("1234") // ["Object String"]
Object.prototype.toString.call([]) // ["Object Array"]
Object.prototype.toString.call({}) // ["Object Object"]
Object.prototype.toString.call(null) // ["Object Null"]
Object.prototype.toString.call(undefined) // ["Object Undefined"]

5）其他判斷方法

Array.isArray([]) // true
isNaN(NaN) // true