https://segmentfault.com/a/11...

對原型的理解

我們知道在es6之前，js沒有類和繼承的概念，js是通過原型來實(shí)現(xiàn)繼承的。在js中一個構(gòu)造函數(shù)默認(rèn)自帶有一個prototype屬性， 這個的屬性值是一個對象，同時這個prototype對象自帶有一個constructor屬性，這個屬性指向這個構(gòu)造函數(shù)，同時每一個實(shí)例 都有一個__proto__屬性指向這個prototype對象，我們可以將這個叫做隱式原型，我們在使用一個實(shí)例的方法的時候，會先檢查 這個實(shí)例中是否有這個方法，沒有則會繼續(xù)向上查找這個prototype對象是否有這個方法，剛剛我們說到prototype是一個對象， 那么也即是說這個是一個對象的實(shí)例，那么這個對象同樣也會有一個__proto__屬性指向?qū)ο蟮膒rototype對象。

JS 原型與原型鏈

javascript有哪些方法定義對象

對象字面量： var obj = {};
構(gòu)造函數(shù)： var obj = new Object();
Object.create(): var obj = Object.create(Object.prototype);

作用域鏈的原理和原型鏈很類似，如果這個變量在自己的作用域中沒有，那么它會尋找父級的，直到最頂層。
注意：JS沒有塊級作用域，若要形成塊級作用域，可通過（function（）｛｝）（）；立即執(zhí)行的形式實(shí)現(xiàn)。

閉包指的是一個函數(shù)可以訪問另一個函數(shù)作用域中變量。常見的構(gòu)造方法，是在一個函數(shù)內(nèi)部定義另外一個函數(shù)。內(nèi)部函數(shù)可以引用外層的變量；外層變量不會被垃圾回收機(jī)制回收。
注意，閉包的原理是作用域鏈，所以閉包訪問的上級作用域中的變量是個對象，其值為其運(yùn)算結(jié)束后的最后一個值。
優(yōu)點(diǎn)：避免全局變量污染。缺點(diǎn)：容易造成內(nèi)存泄漏。
例子：

function makeFunc() {
    var name = "Mozilla";
    function displayName() {
        console.log(name); 
    }
    return displayName;
}
var myFunc = makeFunc();
myFunc();   //輸出Mozilla

myFunc 變成一個 閉包。閉包是一種特殊的對象。它由兩部分構(gòu)成：函數(shù)，以及創(chuàng)建該函數(shù)的環(huán)境。環(huán)境由閉包創(chuàng)建時在作用域中的任何局部變量組成。在我們的例子中，myFunc 是一個閉包，由 displayName 函數(shù)和閉包創(chuàng)建時存在的 "Mozilla" 字符串形成。

這道題考察了以下知識點(diǎn)：
使用 typeof 判斷值得類型；
使用 toString 區(qū)分?jǐn)?shù)組和對象；
遞歸函數(shù)的使用；

實(shí)現(xiàn)一個函數(shù) clone()，可以對 JavaScript 中的5種主要的數(shù)據(jù)類型（包括 Number、String、Object、Array、Boolean）進(jìn)行值復(fù)制。

function clone(obj) {
    //判斷是對象，就進(jìn)行循環(huán)復(fù)制
    if (typeof obj === "object" && typeof obj !== "null") {
        // 區(qū)分是數(shù)組還是對象，創(chuàng)建空的數(shù)組或?qū)ο?        var o = Object.prototype.toString.call(obj).slice(8, -1) === "Array" ? [] : {};
        for (var k in obj) {
            // 如果屬性對應(yīng)的值為對象，則遞歸復(fù)制
            if(typeof obj[k] === "object" && typeof obj[k] !== "null"){
                o[k] = clone(obj[k])
            }else{
                o[k] = obj[k];
            }
        }
    }else{ //不為對象，直接把值返回
        return obj;
    }
    return o;
}

1) 創(chuàng)建一個空對象，并且 this 變量引用該對象，同時還繼承了該函數(shù)的原型。
2) 屬性和方法被加入到 this 引用的對象中。
3) 新創(chuàng)建的對象由 this 所引用，并且最后隱式的返回 this 。

使用new操作符實(shí)例化一個對象的具體步驟
1.構(gòu)造一個新的對象
2.將構(gòu)造函數(shù)的作用域賦給新對象（也就是說this指向了新的對象）
3.執(zhí)行構(gòu)造函數(shù)中的代碼
4.返回新對象

其他問題

Javascript實(shí)現(xiàn)繼承的幾種方式：JavaScript實(shí)現(xiàn)類與繼承的方法（全面整理）

其他問題

typeof 返回哪些數(shù)據(jù)類型

typeof 返回七種值：
“number”、“string”、“boolean”、“object”、"symbol"、“function”和“undefined”。
typeof undefined、null、NaN分別返回undefined,object,number

JavaScript有幾種類型的值？你能畫一下他們的內(nèi)存圖嗎？

基本數(shù)據(jù)類型存儲在棧中，引用數(shù)據(jù)類型（對象）存儲在堆中，指針放在棧中。
兩種類型的區(qū)別是：存儲位置不同；原始數(shù)據(jù)類型直接存儲在棧中的簡單數(shù)據(jù)段，占據(jù)空間小、大小固定，屬于被頻繁使用數(shù)據(jù)，所以放入棧中存儲；引用數(shù)據(jù)類型存儲在堆中的對象,占據(jù)空間大、大小不固定,如果存儲在棧中，將會影響程序運(yùn)行的性能
引用數(shù)據(jù)類型在棧中存儲了指針，該指針指向堆中該實(shí)體的起始地址。當(dāng)解釋器尋找引用值時，會首先檢索其在棧中的地址，取得地址后從堆中獲得實(shí)體。

棧和堆的區(qū)別

棧（stack）：由編譯器自動分配釋放，存放函數(shù)的參數(shù)值，局部變量等；
堆（heap）：一般由程序員分配釋放，若程序員不釋放，程序結(jié)束時可能由操作系統(tǒng)釋放。

對象到數(shù)字的轉(zhuǎn)換步驟

如果對象有valueOf()方法并且返回元素值，javascript將返回值轉(zhuǎn)換為數(shù)字作為結(jié)果

否則，如果對象有toString()并且返回原始值，javascript將返回結(jié)果轉(zhuǎn)換為數(shù)字作為結(jié)果

否則，throws a TypeError

對象到字符串的轉(zhuǎn)換步驟

1.如果對象有toString()方法，javascript調(diào)用它。如果返回一個原始值（primitive value如：string number boolean）,將這個值轉(zhuǎn)換為字符串作為結(jié)果
2.如果對象沒有toString()方法或者返回值不是原始值，javascript尋找對象的valueOf()方法，如果存在就調(diào)用它，返回結(jié)果是原始值則轉(zhuǎn)為字符串作為結(jié)果
3.否則，javascript不能從toString()或者valueOf()獲得一個原始值，此時throws a TypeError

javascript做類型判斷的方法有哪些？

typeof、instanceof 、 Object.prototype.toString()(待續(xù))

實(shí)現(xiàn)一個類型判斷函數(shù)，需要鑒別出基本類型、function、null、NaN、數(shù)組、對象？

只需要鑒別這些類型那么使用typeof即可，要鑒別null先判斷雙等判斷是否為null，之后使用typeof判斷，如果是obejct的話，再用Array.isArray判斷 是否為數(shù)組，如果是數(shù)字再使用isNaN判斷是否為NaN,（需要注意的是NaN并不是JavaScript數(shù)據(jù)類型，而是一種特殊值）如下：

function type(ele) {
  if(ele===null) {
    return null;
  } else if(typeof ele === "object") {
    if(Array.isArray(ele)) {
      return "array";
    } else {
      return typeof ele;
    }
  } else if(typeof ele === "number") {
    if(isNaN(ele)) {
      return NaN;
    } else {
      return typeof ele;
    }
  } else{
    return typeof ele;
  }
}

對js模塊化的理解

在ES6出現(xiàn)之前，js沒有標(biāo)準(zhǔn)的模塊化概念，這也就造成了js多人寫作開發(fā)容易造成全局污染的情況，以前我們可能會采用立即執(zhí)行 函數(shù)、對象等方式來盡量減少變量這種情況，后面社區(qū)為了解決這個問題陸續(xù)提出了AMD規(guī)范和CMD規(guī)范，這里不同于Node.js的 CommonJS的原因在于服務(wù)端所有的模塊都是存在于硬盤中的，加載和讀取幾乎是不需要時間的，而瀏覽器端因?yàn)榧虞d速度取決于網(wǎng)速， 因此需要采用異步加載，AMD規(guī)范中使用define來定義一個模塊，使用require方法來加載一個模塊，現(xiàn)在ES6也推出了標(biāo)準(zhǔn)的模塊 加載方案，通過export和import來導(dǎo)出和導(dǎo)入模塊。

模塊化開發(fā)怎么做

模塊化開發(fā)指的是在解決某一個復(fù)雜問題或者一系列問題時，依照一種分類的思維把問題進(jìn)行系統(tǒng)性的分解。模塊化是一種將復(fù)雜系統(tǒng)分解為代碼結(jié)構(gòu)更合理，可維護(hù)性更高的可管理的模塊方式。對于軟件行業(yè)：系統(tǒng)被分解為一組高內(nèi)聚，低耦合的模塊。
（1）定義封裝的模塊
（2）定義新模塊對其他模塊的依賴
（3）可對其他模塊的引入支持。在JavaScript中出現(xiàn)了一些非傳統(tǒng)模塊開發(fā)方式的規(guī)范。 CommonJS的模塊規(guī)范，AMD（Asynchronous Module Definition），CMD（Common Module Definition）等。AMD是異步模塊定義，所有的模塊將被異步加載，模塊加載不影響后邊語句運(yùn)行。

如何實(shí)現(xiàn)一個JS的AMD模塊加載器

AMD是解決JS模塊化的規(guī)范，實(shí)現(xiàn)這樣的一個模塊加載器的關(guān)鍵在于解決每個模塊依賴的解析。首先我們需要有一個模塊的入口，也就是主模塊，比如我們使用 一個use方法作為入口，之后以數(shù)組的形式列出了主模塊的依賴，這時候我們要想到的是如何解析這一個一個的依賴，也就是如何解析出一個個js文件的絕對地址， 我們可以制定一個規(guī)則，如默認(rèn)為主模塊的路徑為基準(zhǔn)，也可以像requirejs一樣使用一個config方法來指定一個baseurl和為每一個模塊指定一個path，最后就是 模塊的問題，我們需要暴露一個define方法來定義模塊，也就是模塊名，依賴以及每個模塊的各自代碼。其中每個模塊的代碼都應(yīng)該在依賴加載完之后執(zhí)行，這就是一個 回調(diào)函數(shù)，模塊的依賴、回調(diào)函數(shù)、狀態(tài)、名字、模塊導(dǎo)出等可以看做是一個模塊的屬性，因此我們可以使用一個對象來保存所有的模塊，然后每個模塊的各個屬性存放在一個對象中。 最后我們來考慮一下模塊加載的問題，上面我們說到use方法，use方法的邏輯就是遍歷依賴，然后對每個模塊進(jìn)行加載，也就是解析地址然后使用插入script，我們假設(shè) 使用loadModule方法來加載依賴，那么這個函數(shù)的邏輯就應(yīng)該是檢查我們的模塊是否已經(jīng)加載過來判斷是否需要加載，如果這個模塊還有依賴則調(diào)用use方法繼續(xù)解析，模塊依賴中我們 還沒有提到的問題就是每個模塊的依賴是需要被傳進(jìn)模塊里來使用的，解決方法就是每個模塊的callback方法執(zhí)行后的返回的export記錄下來然后使用apply之類的方法將這些參數(shù)傳遞進(jìn)去。 大致就是這樣子的。

參考：
動手實(shí)現(xiàn)一個AMD模塊加載器(一)
動手實(shí)現(xiàn)一個AMD模塊加載器(二)
動手實(shí)現(xiàn)一個AMD模塊加載器(三)

函數(shù)節(jié)流就是讓一個函數(shù)無法在很短的時間間隔內(nèi)連續(xù)調(diào)用，而是間隔一段時間執(zhí)行，這在我們?yōu)樵亟壎ㄒ恍┦录臅r候經(jīng)常會用到，比如我們 為window綁定了一個resize事件，如果用戶一直改變窗口大小，就會一直觸發(fā)這個事件處理函數(shù)，這對性能有很大影響。
什么是函數(shù)節(jié)流？
前端面試查漏補(bǔ)缺--(一) 防抖和節(jié)流

談?wù)剬his對象的理解

1) this總是指向函數(shù)的直接調(diào)用者（而非間接調(diào)用者）
2) 如果有new關(guān)鍵字，this指向new出來的那個對象
3) 在事件中，this指向目標(biāo)元素，特殊的是IE的attachEvent中的this總是指向全局對象window。

簡要介紹ES6

ES6在變量的聲明和定義方面增加了let、const聲明變量，有局部變量的概念，賦值中有比較吸引人的結(jié)構(gòu)賦值，同時ES6對字符串、 數(shù)組、正則、對象、函數(shù)等拓展了一些方法，如字符串方面的模板字符串、函數(shù)方面的默認(rèn)參數(shù)、對象方面屬性的簡潔表達(dá)方式，ES6也 引入了新的數(shù)據(jù)類型symbol，新的數(shù)據(jù)結(jié)構(gòu)set和map,symbol可以通過typeof檢測出來，為解決異步回調(diào)問題，引入了promise和 generator，還有最為吸引人了實(shí)現(xiàn)Class和模塊，通過Class可以更好的面向?qū)ο缶幊?，使用模塊加載方便模塊化編程，當(dāng)然考慮到 瀏覽器兼容性，我們在實(shí)際開發(fā)中需要使用babel進(jìn)行編譯。

let、const、var的使用區(qū)別

let: 相當(dāng)于var,用于聲明一個變量,在塊級作用域有效(可解決for循環(huán)問題);不能重復(fù)聲明;不會變量提升;不會預(yù)處理
const: 用于定義一個常量，不能修改，其他特點(diǎn)等同于let，用于保存不用改變的數(shù)據(jù)

Map與普通對象的區(qū)別

JavaScript 的對象（Object），本質(zhì)上是鍵值對的集合（Hash 結(jié)構(gòu)），但是傳統(tǒng)上只能用字符串當(dāng)作鍵。這給它的使用帶來了很大的限制。為了解決這個問題，ES6 提供了 Map 數(shù)據(jù)結(jié)構(gòu)。它類似于對象，也是鍵值對的集合，但是“鍵”的范圍不限于字符串，各種類型的值（包括對象）都可以當(dāng)作鍵。也就是說，Object 結(jié)構(gòu)提供了“字符串—值”的對應(yīng)，Map 結(jié)構(gòu)提供了“值—值”的對應(yīng)，是一種更完善的 Hash 結(jié)構(gòu)實(shí)現(xiàn)。如果你需要“鍵值對”的數(shù)據(jù)結(jié)構(gòu)，Map 比 Object 更合適。

判斷數(shù)組

Array.isArray([]);  // true
Array.isArray(undefined); // false;

或者
array instanceof Array; // true 檢測對象的原型鏈?zhǔn)欠裰赶驑?gòu)造函數(shù)的prototype對象
或者
array.constructor === Array; // true

終極大招：
if (!Array.isArray) {
  Array.isArray = function(arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
  };
}

注意：typeof []; // "object" 不可以用此方法檢查?。?！

null表示一個對象被定義了，但存放了空指針，轉(zhuǎn)換為數(shù)值時為0。
undefined表示聲明的變量未初始化，轉(zhuǎn)換為數(shù)值時為NAN。
typeof(null) -- object;
typeof(undefined) -- undefined

[1,NaN,NaN]

解析：
Array.prototype.map()
array.map(callback[, thisArg])
callback函數(shù)的執(zhí)行規(guī)則
參數(shù)：自動傳入三個參數(shù)
currentValue（當(dāng)前被傳遞的元素）；
index（當(dāng)前被傳遞的元素的索引）；
array（調(diào)用map方法的數(shù)組）

parseInt方法接收兩個參數(shù)
第三個參數(shù)["1", "2", "3"]將被忽略。parseInt方法將會通過以下方式被調(diào)用
parseInt("1", 0)
parseInt("2", 1)
parseInt("3", 2)

parseInt的第二個參數(shù)radix為0時，ECMAScript5將string作為十進(jìn)制數(shù)字的字符串解析；
parseInt的第二個參數(shù)radix為1時，解析結(jié)果為NaN；
parseInt的第二個參數(shù)radix在2—36之間時，如果string參數(shù)的第一個字符（除空白以外），不屬于radix指定進(jìn)制下的字符，解析結(jié)果為NaN。
parseInt("3", 2)執(zhí)行時，由于"3"不屬于二進(jìn)制字符，解析結(jié)果為NaN。

IE為事件冒泡，F(xiàn)irefox同時支持事件捕獲和事件冒泡。但并非所有瀏覽器都支持事件捕獲。jQuery中使用event.stopPropagation()方法可阻止冒泡;（舊IE的方法 ev.cancelBubble = true;）

如何阻止事件冒泡和默認(rèn)事件？
標(biāo)準(zhǔn)的DOM對象中可以使用事件對象的stopPropagation()方法來阻止事件冒泡，但在IE8以下中IE的事件對象通過設(shè)置事件對象的cancelBubble屬性為true來阻止冒泡； 默認(rèn)事件的話通過事件對象的preventDefault()方法來阻止，而IE通過設(shè)置事件對象的returnValue屬性為false來阻止默認(rèn)事件。

除了正常模式運(yùn)行外，ECMAscript添加了第二種運(yùn)行模式：“嚴(yán)格模式”。
作用：
1) 消除js不合理，不嚴(yán)謹(jǐn)?shù)胤?，減少怪異行為
2) 消除代碼運(yùn)行的不安全之處，
3) 提高編譯器的效率，增加運(yùn)行速度
4) 為未來的js新版本做鋪墊。

全稱：JavaScript Object Notation
JSON中對象通過“{}”來標(biāo)識，一個“{}”代表一個對象，如{“AreaId”:”123”}，對象的值是鍵值對的形式（key：value）。JSON是JS的一個嚴(yán)格的子集，一種輕量級的數(shù)據(jù)交換格式，類似于xml。數(shù)據(jù)格式簡單，易于讀寫，占用帶寬小。
兩個函數(shù)：
JSON.parse(str)
解析JSON字符串 把JSON字符串變成JavaScript值或?qū)ο?br>JSON.stringify(obj)
將一個JavaScript值(對象或者數(shù)組)轉(zhuǎn)換為一個 JSON字符串
eval("("＋json＋")")
用eval方法注意加括號 而且這種方式更容易被攻擊