摘要：使用構(gòu)造函數(shù)創(chuàng)建對(duì)象后，新對(duì)象與構(gòu)造函數(shù)沒有關(guān)系了，新對(duì)象的屬性指向的是構(gòu)造函數(shù)的原型對(duì)象。構(gòu)造繼承使用父類的構(gòu)造函數(shù)來增強(qiáng)子類的實(shí)例，等于是在子類的構(gòu)造函數(shù)內(nèi)部執(zhí)行。

在js中，存在著6種原始值：

* boolean 
* number 
* string 
* undefined 
* null 
* symbol 

注意： 雖然typeof null輸出的是object，但是null并不是object類型，因?yàn)樵缙诘腷ug；

number類型是浮點(diǎn)數(shù)類型，所以才會(huì)有js精度問題出現(xiàn)。0.1+0.2 !== 0.3。 原始類型存儲(chǔ)的都是值，是沒有函數(shù)可以調(diào)用的。 

symbol類型： symbol類型的對(duì)象永遠(yuǎn)不相等，即便創(chuàng)建他們的時(shí)候傳入了相同的值，可以借助此特性解決屬性名的沖突問題。
for...in..拿不到symbol類型的屬性值，而且要用[]的方式來讀取symbol類型的屬性值，用點(diǎn)的方式讀不到。

在js中，除了原始類型其他的就是對(duì)象類型了。
Q1：對(duì)象類型和原始類型的不同之處？

答：對(duì)象類型和原始類型不同的是，原始類型存貯的是值，對(duì)象那個(gè)類型存儲(chǔ)的是地址（指針）。當(dāng)創(chuàng)建了一個(gè)對(duì)象類型的時(shí)候，計(jì)算機(jī)回在內(nèi)存
中開辟一個(gè)空間賴存放值，但是我們需要找到這個(gè)空間，這個(gè)控件會(huì)擁有一個(gè)地址（指針）。當(dāng)我們將變量賦值給另外一個(gè)變量時(shí)，復(fù)制的是原本變量的地址（指針）。 

Q2：函數(shù)參數(shù)是對(duì)象會(huì)發(fā)生什么？

答：函數(shù)參數(shù)是對(duì)象的話，在函數(shù)內(nèi)部可能會(huì)改變這個(gè)參數(shù)對(duì)象，生成新對(duì)象。

Q1：typeof是否能正確判斷類型？

答：對(duì)于原始類型來說，typeof除了null都可以正確顯示類型，typeof null顯示的是object是錯(cuò)誤的。對(duì)于其他的，除了function會(huì)返回function，其他都會(huì)返回object。

Q2. instanceof能正確判斷對(duì)象的原理是什么？

答：instanceof內(nèi)部機(jī)制是通過原型鏈來判斷對(duì)象類型的。 
  eg: const Person = function () {} 
      const p1 = new Person() p1
      instanceof Person // true 
      var str = "hello world" str instanceof String // false 

1.轉(zhuǎn)Boolean: 在條件判斷時(shí)，除了undefined,null,0,-0,NaN,"",false，其他所有值都轉(zhuǎn)化為true，包括所有對(duì)象。
2.對(duì)象轉(zhuǎn)原始類型： 對(duì)象在轉(zhuǎn)換類型的時(shí)候，會(huì)調(diào)用內(nèi)置的[[ToPrimitive]]函數(shù)，對(duì)于該函數(shù)來說，

算法邏輯一般來說如下：
  * 如果已經(jīng)是原始類型了，就不需要換磚了
  * 調(diào)用x.valueof(),如果轉(zhuǎn)換為基礎(chǔ)類型，就返回轉(zhuǎn)換的值
  * 調(diào)用x.toString(),如果轉(zhuǎn)化為基礎(chǔ)類型，就返回轉(zhuǎn)換的值 
  * 如果都沒有返回原始類型，就會(huì)報(bào)錯(cuò) 1）四則運(yùn)算符： 加法運(yùn)算符特點(diǎn)： 
  *運(yùn)算中如果一方為字符串，那么就會(huì)把另一方葉轉(zhuǎn)換為字符串，1 + "1" // "11" 
  *如果一方不是字符串或者數(shù)字，那么會(huì)將它轉(zhuǎn)化為數(shù)字或者字符串：true+ true // 2 ; 4 + [1,2,3] // "41,2,3" 
注意： + "a"是快速將"a"轉(zhuǎn)化成number類型的寫法；"a" + + "b" // "aNaN" 那么對(duì)于除了加法運(yùn)算符其他運(yùn)算符來說，只要一方是數(shù)字，那么另一方就會(huì)被轉(zhuǎn)化為數(shù)字。反正最終都是要轉(zhuǎn)化為數(shù)字來運(yùn)算。
      4 * "3" // 12 4 * [] // 0 4 * [1,2] // NaN 2)比較運(yùn)算符 大于小于運(yùn)算都會(huì)轉(zhuǎn)化為數(shù)字進(jìn)行運(yùn)算。 
關(guān)于 ==： 
*undefined 等于 null 
*字符串和數(shù)字比較時(shí)，字符串轉(zhuǎn)數(shù)字 
*數(shù)字和布爾類型比較時(shí)，布爾轉(zhuǎn)數(shù)字
*字符串和布爾比較時(shí)，兩者轉(zhuǎn)數(shù)字 

this永遠(yuǎn)指向最后調(diào)用它的那個(gè)對(duì)象。
1.改變this指向：

* 使用es6箭頭函數(shù) 
* 在函數(shù)內(nèi)部使用 _this = this 
* 使用 apply,call,bind 
* new 實(shí)例化一個(gè)對(duì)象

2.箭頭函數(shù)： 箭頭函數(shù)的this始終指向函數(shù)定義時(shí)的this，而非執(zhí)行時(shí)（意味著如果箭頭函數(shù)被非箭頭函數(shù)包含，this綁定的就是最近一層非箭頭函數(shù)的this）。

箭頭函數(shù)中沒有this綁定，必須通過查找作用域鏈來決定其值。 

3.apply，call，bind區(qū)別
apply和call只是傳入的參數(shù)不同。call接受的是若干個(gè)參數(shù)列表，而apply接受的是一個(gè)包含多個(gè)參數(shù)的數(shù)組。
bind和apply，call區(qū)別：

bind創(chuàng)建了一個(gè)新的函數(shù)，需要手動(dòng)去調(diào)用它； 

創(chuàng)建一個(gè)空對(duì)象obj；

將新創(chuàng)建的空對(duì)象的隱式原型指向其構(gòu)造函數(shù)的顯示原型；

使用call改變this的指向；

如果無返回值或者返回一個(gè)非對(duì)象值，則將obj返回作為新對(duì)象；如果返回值時(shí)一個(gè)新對(duì)象的華那么直接返回該對(duì)象。

Q1: ==和 === 有什么區(qū)別？

答： 對(duì)于 == 來說，如果雙方的類型不一樣的華，就會(huì)進(jìn)行類型轉(zhuǎn)換。
    流程： 
      * 首先判斷兩者類型是否相同 
      * 判斷是否為 undefined == null //true 
      * string轉(zhuǎn)number比較 * boolean轉(zhuǎn)number比較
      * object轉(zhuǎn)原始類型比較 但是，=== 的比較只需要判斷兩者類型和值是否相同。 

Q1: 什么是閉包？

答：函數(shù)A內(nèi)部有一個(gè)函數(shù)B，函數(shù)B可以訪問到函數(shù)A中的變量，那么函數(shù)B就是閉包。 

Q2：經(jīng)典面試題：循環(huán)中使用閉包解決var定義函數(shù)的問題：
答：第一種：使用閉包的方式： for (var i = 1; i <=5 ; i++) { ;(function(j) { setTimeout(function timer() { console.log(j) }, j * 1000) })(i)}

  第二種：用let定義的方式： for (let i=1 ; i <=5 ; i++) { setTimeout(function timer() { console.log(i) }, i * 1000) } Q3：閉包的優(yōu)缺點(diǎn)？ 閉包作用（優(yōu)點(diǎn)）：可以讀取到函數(shù)內(nèi)部的變量，可以讓這些變量的值始終保持在內(nèi)存中，不會(huì)被垃圾回收掉。

閉包缺點(diǎn)：因?yàn)殚]包會(huì)使得函數(shù)中變量保存在內(nèi)存中，所以會(huì)增大內(nèi)存使用量，使用不當(dāng)很容易造成內(nèi)存泄漏。浪費(fèi)內(nèi)存。
清除閉包：退出函數(shù)之前，將不使用的局部變量刪除。

1.堆和棧：棧（stack）為自動(dòng)分配的內(nèi)存空間，它由系統(tǒng)自動(dòng)釋放；而堆（heap）則是動(dòng)態(tài)分配的內(nèi)存，大小不定也不會(huì)自動(dòng)釋放。
2.基本數(shù)據(jù)類型存放在棧中，數(shù)據(jù)大小確定，內(nèi)存空間大小可以分配，是直接按值存放的，所以可以直接訪問?；绢愋偷谋容^是值的比較。
3.引用類型存放在堆中，變量實(shí)際上存放的是棧1內(nèi)存的指針，引用類型的值可變。引用類型的比較是引用的比較。所以比較兩個(gè)引用類型，是看其的引用是否指向同一個(gè)對(duì)象。
Q1.淺拷貝？

答：淺拷貝只復(fù)制一層對(duì)象的屬性，并不包括對(duì)象里面的為引用類型的數(shù)據(jù)。 

Q2.深拷貝？

答： 深拷貝遞歸復(fù)制了對(duì)象的所有層級(jí)屬性。 

Q3.深拷貝，淺拷貝以及賦值的區(qū)別？

答：淺拷貝，深拷貝和原數(shù)據(jù)都不是指向同一對(duì)象，而賦值對(duì)象和原對(duì)象是指向同一對(duì)象。
第一層數(shù)據(jù)為基本類型，改變會(huì)使原數(shù)據(jù)改變，深拷貝以及淺拷貝不會(huì)。 原數(shù)據(jù)中包含子對(duì)象，改變子對(duì)象會(huì)使賦值對(duì)象以及淺拷貝對(duì)象改變，不會(huì)使深拷貝對(duì)象改變。 

Q4.如何實(shí)現(xiàn)淺拷貝？

答：1.可以通過Object.assign來解決。（Object.assign()方法用于將所有可枚舉的值從一個(gè)或多個(gè)源對(duì)象復(fù)制到目標(biāo)對(duì)象。它將返回目標(biāo)對(duì)象。）
    eg: 
      let a={ age: 1 } 
      let b=O bject.assign({}, a) 
      a.age=2 console.log(b.age) // 1 
    2.可以通過展開運(yùn)算符...來實(shí)現(xiàn)淺拷貝 
    eg: 
      let a={ age: 1} 
      let b={ ...a } 
      a.age=2 console.log(b.age) // 1 

Q5.如何實(shí)現(xiàn)深拷貝？

答：1.該問題可以通過JSON.parse(JSON.stringify(object))來解決。 
    eg: let a={age: 1, jobs: { first: "FE" } } 
        let b=J SON.parse(JSON.stringify(a)) 
        a.jobs.first="native" 
        console.log(b.jobs.first) // FE
    但是該方法也是有局限性的： 
      * 會(huì)忽略u(píng)ndefined 
      * 會(huì)忽略symbol 
      * 不能序列化函數(shù) 
      * 不能解決循環(huán)引用的對(duì)象 

js是基于原型的繼承。
1.使用構(gòu)造函數(shù)創(chuàng)建對(duì)象后，新對(duì)象與構(gòu)造函數(shù)沒有關(guān)系了，新對(duì)象的[[prototype]]屬性指向的是構(gòu)造函數(shù)的原型對(duì)象。
2.構(gòu)造函數(shù)、原型和實(shí)例的關(guān)系：

* 構(gòu)造函數(shù)都有一個(gè)屬性prototype，這個(gè)屬性是一個(gè)對(duì)象（Object的實(shí)例）
* 原型對(duì)象里面有個(gè)constractor屬性，該屬性指向原型對(duì)象所屬的構(gòu)造函數(shù)。當(dāng)原型對(duì)象被修改過，constractor就不一定指向原來的構(gòu)造函數(shù)了。
* 實(shí)例對(duì)象都有一個(gè)_proto_屬性，該屬性也指向構(gòu)造函數(shù)的原型對(duì)象，它是一個(gè)非標(biāo)準(zhǔn)屬性，不可以用于編程，它用于瀏覽器自己使用。

3.prototype和_proto_的關(guān)系：

* prototype是構(gòu)造函數(shù)的屬性；
* _proto_是實(shí)例對(duì)象的屬性；
* 這兩者都會(huì)指向同一個(gè)對(duì)象。
總結(jié)：*函數(shù)也是對(duì)象，對(duì)象不一定是函數(shù)；
      * 對(duì)象的本質(zhì)：無序的鍵值對(duì)集合，鍵值對(duì)當(dāng)中的值可以是任意數(shù)據(jù)類型的值；
      *對(duì)象就是一個(gè)容器，這個(gè)容器當(dāng)中放的是屬性和方法。

4.原型鏈：

原型鏈就是可以理解為有限的實(shí)例對(duì)象和原型之間組成的有限鏈，就是用來實(shí)現(xiàn)屬性共享和繼承的。

5.屬性搜索：

* 在訪問對(duì)象的某個(gè)成員的時(shí)候在對(duì)象中查找是否存在；
* 如果當(dāng)前對(duì)象中沒有就在構(gòu)造函數(shù)的原型對(duì)象中查找；
* 如果原型對(duì)象中沒有就在原型對(duì)象的原型上找；
* 直到找到Object的原型對(duì)象的原型是null為止。
eg:
  var arr = []
  原型鏈：arr -> Array.prototype -> Object.prototype -> null

Q1：什么是原型？

答： 原型也是一個(gè)對(duì)象，并且這個(gè)對(duì)象中包含了很多函數(shù)。原型的constract屬性指向構(gòu)造函數(shù)，構(gòu)造函數(shù)又通過prototype屬性指回原型，到那時(shí)并不是所有函數(shù)都具有這個(gè)屬性。

1.原型鏈繼承：將父類的實(shí)例作為子類的原型。

eg：Cat.prototype = new Animal()
缺點(diǎn)：子類無法給父類傳參，子類要新增屬性和方法的話，必須要在new Parent（）這樣的語句之后執(zhí)行，否則會(huì)被覆蓋。

2.構(gòu)造繼承：使用父類的構(gòu)造函數(shù)來增強(qiáng)子類的實(shí)例，等于是在子類的構(gòu)造函數(shù)內(nèi)部執(zhí)行Parent.call(this)。

eg：function Cat(name) {
  Animal.call(this);
  this.name = name || "Tom";
}
var cat = new Cat();
缺點(diǎn)：沒有原型，每次創(chuàng)建一個(gè)子類實(shí)例都要執(zhí)行一遍Parent函數(shù)。

3.組合式繼承：結(jié)合原型鏈繼承和構(gòu)造繼承，組合式繼承在使用過程中會(huì)被調(diào)用兩次：一次是創(chuàng)建子類的時(shí)候，一次是在子類構(gòu)造函數(shù)的內(nèi)部。

eg: function Cat(name){
    Animal.call(this);
    this.name = name || "Tom";
  }
  Cat.prototype = new Animal();

3.class繼承：

class繼承的核心在于使用extends表明繼承自哪個(gè)父類，并且在子類構(gòu)造函數(shù)中必須調(diào)用super，因?yàn)檫@段代碼可以看成Parent.call(this,value).
eg：
class Parent {
  constructor(value) {
    this.val = value
  }
  getValue() {
    console.log(this.val)
  }
}
class Child extends Parent {
  constructor(value) {
    super(value)
    this.val = value
  }
}
let child = new Child(1)
child.getValue() // 1
child instanceof Parent // true

1.var和let區(qū)別：

* let有塊級(jí)作用域的說法，也就是let聲明的變量只能在這個(gè)塊內(nèi)部使用，別的地方不能使用。var聲明的變量可以在全局使用，var在函數(shù)內(nèi)部聲明的變量只能在函數(shù)內(nèi)部使用。
* let沒有變量提升，var有變量提升
* let聲明的變量存在“暫時(shí)性死區(qū)”，而var聲明的變量沒有
* let不允許在同一個(gè)快內(nèi)重復(fù)聲明一個(gè)變量。因此也不能在函數(shù)內(nèi)部重復(fù)聲明一個(gè)變量。
* var聲明的變量會(huì)掛載到window上，而let聲明的對(duì)象不會(huì)掛載到window上。

const特性：

const聲明一個(gè)只讀的常量。一旦聲明，常量的值就不能改變；

const聲明的變量必須初始化，不然會(huì)報(bào)錯(cuò)；

const聲明的變量也存在暫時(shí)性死區(qū)；

const聲明的變量只在所聲明的塊級(jí)作用域內(nèi)有效；

const聲明的常量也與let一樣不可重復(fù)聲明。

Q1.什么是提升？

答：就是變量可以在神明之前使用，并且值為undefined。

Q2. 什么是暫時(shí)性死區(qū)？

答：在let命令聲明之前，該變量都素hi不可用的。

Q1.為什么要使用模塊化？

答：使用模塊化可以帶來以下好處：
  * 解決命名沖突；
  * 提供復(fù)用性；
  * 提高代碼可維護(hù)性。

Q2.實(shí)現(xiàn)模塊化的方式？

CommonJS  AMD  CMD

1.require/exports:

遵循CommonJS/AMD，只能在運(yùn)行時(shí)確定模塊的依賴關(guān)系及輸入/輸出的變量，無法進(jìn)行靜態(tài)優(yōu)化。

2.import/export：

遵循ES6規(guī)范，支持編譯時(shí)靜態(tài)分析，便于JS引入宏和類型檢驗(yàn)，動(dòng)態(tài)綁定。

1. 并發(fā)(concurrency)和并行(parallelism)區(qū)別：
    Q1：并發(fā)與并行的區(qū)別？
        答：并發(fā)是宏觀概念，我分別有任務(wù)A和任務(wù)B，在一段時(shí)間內(nèi)通過任務(wù)間的切換完成了這個(gè)任務(wù)。
            并行是微觀概念，假設(shè)CPU中存在兩個(gè)核心，那么我就可以同時(shí)完成任務(wù)A和任務(wù)B。同時(shí)完成多個(gè)任務(wù)的情況可以稱之為并行。
2.回調(diào)函數(shù)(callback):
    Q1.什么是回調(diào)函數(shù)？
        答：ajax(url,() => {
            //處理邏輯；
        })

    Q2.回調(diào)函數(shù)有什么缺點(diǎn)？
        答：1）回調(diào)函數(shù)有一個(gè)致命的弱點(diǎn)就是容易寫出回調(diào)地獄(callback hell)。
            eg：
                ajax(url, () => {
                    // 處理邏輯
                    ajax(url1, () => {
                        // 處理邏輯
                        ajax(url2, () => {
                            // 處理邏輯
                        })
                    })
                })
        回調(diào)地獄根本問題：
        * 嵌套函數(shù)存在耦合性，一旦有所改動(dòng)，就會(huì)牽一發(fā)而動(dòng)全身；
        * 嵌套函數(shù)一多，就很難處理錯(cuò)誤。
        2）回調(diào)函數(shù)不能使用trycatch捕獲錯(cuò)誤，不能直接return。
    Q3.如何解決“地獄回調(diào)”？
        答：* function拆解
            * promise
            * generater
            * async/await
    3. Generator：
    4. promise:
        Q1：Promise的特點(diǎn)？
            答：對(duì)象的狀態(tài)不受外界影響，只有三種狀態(tài)：pending resolved  rejected
                狀態(tài)一旦改變，就不會(huì)再變，任何時(shí)候都可以得到這個(gè)結(jié)果。
        Q2. Promise的優(yōu)缺點(diǎn)？
            答：缺點(diǎn)：* promise無法取消，一旦新建就會(huì)立即執(zhí)行，無法中途取消；
                    * 如果不設(shè)置回調(diào)函數(shù)，promise內(nèi)部會(huì)拋出錯(cuò)誤，不會(huì)反映到外部；
                    * 當(dāng)處于pending狀態(tài)時(shí)，無法得知目前進(jìn)展到哪一個(gè)階段（剛剛開始還是即將完成）。
                優(yōu)點(diǎn)：可以解決回調(diào)地獄問題。
        Q3. 什么是Promise鏈？
            答：就是在Promise構(gòu)造函數(shù)里面通過then來一步一步使用promise，因?yàn)閠hen方法返回的也是一個(gè)全新的promise實(shí)例。
        Q4. Promise構(gòu)造函數(shù)執(zhí)行和then函數(shù)執(zhí)行有什么區(qū)別？
            答：then方法每次都返回一個(gè)promise實(shí)例。
    5. Async/Await:
        Q1.async的特點(diǎn)？
            答：一個(gè)函數(shù)如果加上async，那么該函數(shù)就會(huì)返回一個(gè)promise。async就是將函數(shù)返回值使用Promise.resolve()包裹了一下，和then中處理返回值一樣，并且await只能配套在async函數(shù)內(nèi)部使用。
        Q2.優(yōu)缺點(diǎn)？
            答： 優(yōu)點(diǎn)：處理then的調(diào)用鏈能夠更清晰的寫出代碼，并且能夠優(yōu)雅的解決回調(diào)地獄問題。
                缺點(diǎn)：因?yàn)閍wait將一部代碼改造成了同步代碼，如果多個(gè)異步代碼沒有依賴性卻使用了await會(huì)導(dǎo)致性能上的降低。
        Q3.await原理是什么？
            答：await內(nèi)部實(shí)現(xiàn)了generator。
        實(shí)現(xiàn)async/await：
            async function doIt() {
                console.time("doIt");
                const time1 = 300;
                const time2 = await step1(time1);
                const time3 = await step2(time2);
                const result = await step3(time3);
                console.log(`result is ${result}`);
                console.timeEnd("doIt");
            }
            
            doIt();
    6.常用定時(shí)器函數(shù)： setTimeout() setInterval()  requestAnimationFrame()
        requestAnimationFrame自帶函數(shù)節(jié)流功能，基本可以保證在16.6毫秒內(nèi)只執(zhí)行一次，并且該函數(shù)的延時(shí)效果是精準(zhǔn)的。如果有循環(huán)定時(shí)器的需求，requestAnimationFrame是最好的選擇。