摘要：春招季如何橫掃面試核心考點基礎版前端面試之路二基礎整理的繼承和的繼承有什么區(qū)別的繼承時通過或構(gòu)造函數(shù)機制來實現(xiàn)。作用創(chuàng)建私有變量，減少全局變量，防止變量名污染。異步瀏覽器訪問服務器請求，用戶正常操作，瀏覽器后端進行請求。

春招季如何橫掃 Javascript 面試核心考點(基礎版)？
前端面試之路二(javaScript基礎整理)

ES5的繼承時通過prototype或構(gòu)造函數(shù)機制來實現(xiàn)。ES5的繼承實質(zhì)上是先創(chuàng)建子類的實例對象，然后再將父類的方法添加到this上（Parent.apply(this)）。
ES6的繼承機制完全不同，實質(zhì)上是先創(chuàng)建父類的實例對象this（所以必須先調(diào)用父類的super()方法），然后再用子類的構(gòu)造函數(shù)修改this。
具體的：ES6通過class關鍵字定義類，里面有構(gòu)造方法，類之間通過extends關鍵字實現(xiàn)繼承。子類必須在constructor方法中調(diào)用super方法，否則新建實例報錯。因為子類沒有自己的this對象，而是繼承了父類的this對象，然后對其進行加工。如果不調(diào)用super方法，子類得不到this對象。
ps：super關鍵字指代父類的實例，即父類的this對象。在子類構(gòu)造函數(shù)中，調(diào)用super后，才可使用this關鍵字，否則報錯。

在一個函數(shù)里面嵌套另一個函數(shù)，被嵌套的那個函數(shù)的作用域是一個閉包。
作用：創(chuàng)建私有變量，減少全局變量，防止變量名污染?？梢圆僮魍獠孔饔糜虻淖兞?，變量不會被瀏覽器回收，保存變量的值。

Object 是 JavaScript 中所有對象的父對象
數(shù)據(jù)封裝類對象：Object、Array、Boolean、Number、String
其他對象：Function、Argument、Math、Date、RegExp、Error

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

同步的概念應該是來自于操作系統(tǒng)中關于同步的概念:不同進程為協(xié)同完成某項工作而在先后次序上調(diào)整(通過阻塞,喚醒等方式)。
同步強調(diào)的是順序性，誰先誰后；異步則不存在這種順序性。

同步：瀏覽器訪問服務器請求，用戶看得到頁面刷新，重新發(fā)請求,等請求完，頁面刷新，新內(nèi)容出現(xiàn)，用戶看到新內(nèi)容,進行下一步操作。

異步：瀏覽器訪問服務器請求，用戶正常操作，瀏覽器后端進行請求。等請求完，頁面不刷新，新內(nèi)容也會出現(xiàn)，用戶看到新內(nèi)容。

缺點：回調(diào)地獄，不能用 try catch 捕獲錯誤，不能 return
優(yōu)點：解決了同步的問題

Promise就是為了解決callback的問題而產(chǎn)生的。
回調(diào)地獄的根本問題在于：

缺乏順序性： 回調(diào)地獄導致的調(diào)試困難，和大腦的思維方式不符
嵌套函數(shù)存在耦合性，一旦有所改動，就會牽一發(fā)而動全身，即（控制反轉(zhuǎn)）
嵌套函數(shù)過多的多話，很難處理錯誤

Promise 實現(xiàn)了鏈式調(diào)用，也就是說每次 then 后返回的都是一個全新 Promise，如果我們在 then 中 return ，return 的結(jié)果會被 Promise.resolve() 包裝

優(yōu)點：解決了回調(diào)地獄的問題
缺點：無法取消 Promise ，錯誤需要通過回調(diào)函數(shù)來捕獲

特點：可以控制函數(shù)的執(zhí)行，可以配合 co 函數(shù)庫使用

async、await 是異步的終極解決方案

優(yōu)點：代碼清晰，不用像 Promise 寫一大堆 then 鏈，處理了回調(diào)地獄的問題
缺點：await 將異步代碼改造成同步代碼，如果多個異步操作沒有依賴性而使用 await 會導致性能上的降低。

null： null表示空值，轉(zhuǎn)為數(shù)值時為0；
undefined：undefined表示"缺少值"，就是此處應該有一個值，但是還沒有定義。

? 變量被聲明了，但沒有賦值時，就等于undefined。
? 對象沒有賦值的屬性，該屬性的值為undefined。
? 函數(shù)沒有返回值時，默認返回undefined。

JavaScript 原型： 每創(chuàng)建一個函數(shù)，函數(shù)上都有一個屬性為 prototype，它的值是一個對象。 這個對象的作用在于當使用函數(shù)創(chuàng)建實例的時候，那么這些實例都會共享原型上的屬性和方法。

原型鏈： 在 JavaScript 中，每個對象都有一個指向它的原型（prototype）對象的內(nèi)部鏈接（proto）。這個原型對象又有自己的原型，直到某個對象的原型為 null 為止（也就是不再有原型指向）。這種一級一級的鏈結(jié)構(gòu)就稱為原型鏈（prototype chain）。 當查找一個對象的屬性時，JavaScript 會向上遍歷原型鏈，直到找到給定名稱的屬性為止;到查找到達原型鏈的頂部（Object.prototype），仍然沒有找到指定的屬性，就會返回 undefined

 function randomNum(){
     return Math.floor(Math.random()*10)
 }

 str.slice(1)
 str.substr(1)
 str.substring(1)
 str.replace(/./,"")
 str.replace(str.charAt(0),"")

JavaScript 由以下三部分組成：

ECMAScript（核心）：JavaScript 語言基礎
DOM（文檔對象模型）：規(guī)定了訪問HTML和XML的接口
BOM（瀏覽器對象模型）：提供了瀏覽器窗口之間進行交互的對象和方法

前端工程化就是用做工程的思維看待和開發(fā)自己的項目，
而模塊化和組件化是為工程化思想下相對較具體的開發(fā)方式，因此可以簡單的認為模塊化和組件化是工程化的表現(xiàn)形式。
模塊化和組件化一個最直接的好處就是復用，同時我們也應該有一個理念，模塊化和組件化除了復用之外還有就是分治，我們能夠在不影響其他代碼的情況下按需修改某一獨立的模塊或是組件，因此很多地方我們及時沒有很強烈的復用需要也可以根據(jù)分治需求進行模塊化或組件化開發(fā)。
模塊化開發(fā)的4點好處：

　　1 避免變量污染，命名沖突
　　2  提高代碼復用率
　　3 提高維護性
    4 依賴關系的管理

前端模塊化實現(xiàn)的過程如下：
一 函數(shù)封裝
我們在講到函數(shù)邏輯的時候提到過，函數(shù)一個功能就是實現(xiàn)特定邏輯的一組語句打包，在一個文件里面編寫幾個相關函數(shù)就是最開始的模塊了

　　function m1(){
　　　　//...
　　}

　　function m2(){
　　　　//...
　　}

這樣做的缺點很明顯，污染了全局變量，并且不能保證和其他模塊起沖突，模塊成員看起來似乎沒啥關系
二 對象
為了解決這個問題，有了新方法，將所有模塊成員封裝在一個對象中

var module = new Object({

  _count:0,

  m1:function (){  ```  },

  m2:function (){   ```  }                
 
})    

這樣 兩個函數(shù)就被包在這個對象中， 嘿嘿 看起來沒毛病是嗎 繼續(xù)往下：
當我們要使用的時候，就是調(diào)用這個對象的屬性
module.m1()
誒嘿 那么問題來了 這樣寫法會暴露全部的成員，內(nèi)部狀態(tài)可以被外部改變，比如外部代碼可直接改變計數(shù)器的值
//壞人的操作

module._count = 10;

最后的最后，聰明的人類找到了究極新的方法——立即執(zhí)行函數(shù)，這樣就可以達到不暴露私有成員的目的

var module = (function (){

    var _count = 5;
     
    var m1 = function (){  ```   };

    var m2 = function (){  ```   };

    return{
         m1:m1,
         m2:m2
    }

})()    

參考鏈接： http://www.cnblogs.com/ihardc...

什么是面向過程與面向?qū)ο螅?/p>

? 面向過程就是做圍墻的時候，由你本身操作，疊第一層的時候：放磚頭，糊水泥，放磚頭，糊水泥；然后第二層的時候，繼續(xù)放磚頭，糊水泥，放磚頭，糊水泥……
? 面向?qū)ο缶褪亲鰢鷫Φ臅r候，由他人幫你完成，將做第一層的做法抽取出來，就是放磚頭是第一個動作，糊水泥是第二個動作，然后給這兩個動作加上步數(shù)，最后告訴機器人有 n 層，交給機器人幫你工作就行了。

為什么需要面向?qū)ο髮懛ǎ?/p>

? 更方便
? 可以復用，減少代碼冗余度
? 高內(nèi)聚低耦合
簡單來說，就是增加代碼的可復用性，減少咱們的工作，使代碼更加流暢。

普通添加事件的方法：

var btn = document.getElementById("hello");
btn.onclick = function(){
    alert(1);
}
btn.onclick = function(){
    alert(2);
}

執(zhí)行上面的代碼只會alert 2

事件綁定方式添加事件：

var btn = document.getElementById("hello");
btn.addEventListener("click",function(){
    alert(1);
},false);
btn.addEventListener("click",function(){
    alert(2);
},false);

執(zhí)行上面的代碼會先alert 1 再 alert 2
普通添加事件的方法不支持添加多個事件，最下面的事件會覆蓋上面的，而事件綁定（addEventListener）方式添加事件可以添加多個。
addEventListener不兼容低版本IE
普通事件無法取消
addEventLisntener還支持事件冒泡+事件捕獲

由于字符串、對象和數(shù)組沒有固定大小，所有當他們的大小已知時，才能對他們進行動態(tài)的存儲分配。JavaScript程序每次創(chuàng)建字符串、數(shù)組或?qū)ο髸r，解釋器都必須分配內(nèi)存來存儲那個實體。只要像這樣動態(tài)地分配了內(nèi)存，最終都要釋放這些內(nèi)存以便他們能夠被再用，否則，JavaScript的解釋器將會消耗完系統(tǒng)中所有可用的內(nèi)存，造成系統(tǒng)崩潰。
　　現(xiàn)在各大瀏覽器通常用采用的垃圾回收有兩種方法：標記清除、引用計數(shù)。
1、標記清除
　　這是javascript中最常用的垃圾回收方式。當變量進入執(zhí)行環(huán)境是，就標記這個變量為“進入環(huán)境”。從邏輯上講，永遠不能釋放進入環(huán)境的變量所占用的內(nèi)存，因為只要執(zhí)行流進入相應的環(huán)境，就可能會用到他們。當變量離開環(huán)境時，則將其標記為“離開環(huán)境”。
　　垃圾收集器在運行的時候會給存儲在內(nèi)存中的所有變量都加上標記。然后，它會去掉環(huán)境中的變量以及被環(huán)境中的變量引用的標記。而在此之后再被加上標記的變量將被視為準備刪除的變量，原因是環(huán)境中的變量已經(jīng)無法訪問到這些變量了。最后。垃圾收集器完成內(nèi)存清除工作，銷毀那些帶標記的值，并回收他們所占用的內(nèi)存空間。
關于這一塊，建議讀讀Tom大叔的幾篇文章，關于作用域鏈的一些知識詳解，讀完差不多就知道了，哪些變量會被做標記。

2、引用計數(shù)
　　另一種不太常見的垃圾回收策略是引用計數(shù)。引用計數(shù)的含義是跟蹤記錄每個值被引用的次數(shù)。當聲明了一個變量并將一個引用類型賦值給該變量時，則這個值的引用次數(shù)就是1。相反，如果包含對這個值引用的變量又取得了另外一個值，則這個值的引用次數(shù)就減1。當這個引用次數(shù)變成0時，則說明沒有辦法再訪問這個值了，因而就可以將其所占的內(nèi)存空間給收回來。這樣，垃圾收集器下次再運行時，它就會釋放那些引用次數(shù)為0的值所占的內(nèi)存。