如果你在2018面試前端，那這篇文章最好看一看！

阿新 • • 發佈：2018-12-09

前端目錄

Html相關

<div id="html">1 html語義化</div>

意義：根據內容的結構化（內容語義化），選擇合適的標籤（程式碼語義化）便於開發者閱讀和寫出更優雅的程式碼的同時讓瀏覽器的爬蟲和機器很好地解析。注意：1.儘可能少的使用無語義的標籤div和span；2.在語義不明顯時，既可以使用div或者p時，儘量用p, 因為p在預設情況下有上下間距，對相容特殊終端有利；3.不要使用純樣式標籤，如：b、font、u等，改用css設定。4.需要強調的文字，可以包含在strong或者em標籤中（瀏覽器預設樣式，能用CSS指定就不用他們），strong預設樣式是加粗（不要用b），em是斜體（不用i）；5.使用表格時，標題要用caption，表頭用thead，主體部分用tbody包圍，尾部用tfoot包圍。表頭和一般單元格要區分開，表頭用th，單元格用td；6.表單域要用fieldset標籤包起來，並用legend標籤說明表單的用途；7.每個input標籤對應的說明文字都需要使用label標籤，並且通過為input設定id屬性，在lable標籤中設定for=someld來讓說明文字和相對應的input關聯起來。

新標籤： h5新元素

2 meta viewport相關

<!DOCTYPE html>  H5標準宣告，使用 HTML5 doctype，不區分大小寫
<head lang=”en”> 標準的 lang 屬性寫法
<meta charset=’utf-8′>    宣告文件使用的字元編碼
<meta http-equiv=”X-UA-Compatible” content=”IE=edge,chrome=1″/>   優先使用 IE 最新版本和 Chrome
<meta name=”description” content=”不超過150個字元”/>       頁面描述
<meta name=”keywords” content=””/>      頁面關鍵詞
<meta name=”author” content=”name,  
[email protected]”/>    網頁作者
<meta name=”robots” content=”index,follow”/>      搜尋引擎抓取
<meta name=”viewport” content=”initial-scale=1, maximum-scale=3, minimum-scale=1, user-scalable=no”> 為移動裝置新增 viewport
<meta name=”apple-mobile-web-app-title” content=”標題”> iOS 裝置 begin
<meta name=”apple-mobile-web-app-capable” content=”yes”/>  新增到主屏後的標題（iOS 6 新增）
是否啟用 WebApp 全屏模式，刪除蘋果預設的工具欄和選單欄
<meta name=”apple-itunes-app” content=”app-id=myAppStoreID, affiliate-data=myAffiliateData, app-argument=myURL”>
新增智慧 App 廣告條 Smart App Banner（iOS 6+ Safari）
<meta name=”apple-mobile-web-app-status-bar-style” content=”black”/>
<meta name=”format-detection” content=”telphone=no, email=no”/>  設定蘋果工具欄顏色
<meta name=”renderer” content=”webkit”>  啟用360瀏覽器的極速模式(webkit)
<meta http-equiv=”X-UA-Compatible” content=”IE=edge”>     避免IE使用相容模式
<meta http-equiv=”Cache-Control” content=”no-siteapp” />    不讓百度轉碼
<meta name=”HandheldFriendly” content=”true”>     針對手持裝置優化，主要是針對一些老的不識別viewport的瀏覽器，比如黑莓
<meta name=”MobileOptimized” content=”320″>   微軟的老式瀏覽器
<meta name=”screen-orientation” content=”portrait”>   uc強制豎屏
<meta name=”x5-orientation” content=”portrait”>    QQ強制豎屏
<meta name=”full-screen” content=”yes”>              UC強制全屏
<meta name=”x5-fullscreen” content=”true”>       QQ強制全屏
<meta name=”browsermode” content=”application”>   UC應用模式
<meta name=”x5-page-mode” content=”app”>    QQ應用模式
<meta name=”msapplication-tap-highlight” content=”no”>    windows phone 點選無高光
設定頁面不快取
<meta http-equiv=”pragma” content=”no-cache”>
<meta http-equiv=”cache-control” content=”no-cache”>
<meta http-equiv=”expires” content=”0″>

3 canvas 相關

使用前需要獲得上下文環境，暫不支援3d
常用api:
    1.fillRect(x,y,width,height)實心矩形
    2.strokeRect(x,y,width,height)空心矩形
    3.fillText("Hello world",200,200);實心文字
    4.strokeText("Hello world",200,300)空心文字
各種東西！！！

新標籤相容低版本

ie9之前版本通過createElement建立html5新標籤
引入html5shiv.js

<div id="css">CSS相關</div>

1.盒模型

1.ie盒模型算上border、padding及自身（不算margin），標準的只算上自身窗體的大小css設定方法如下

/* 標準模型 */
box-sizing:content-box;
 /*IE模型*/
box-sizing:border-box;

2.margin、border、padding、content由外到裡3.幾種獲得寬高的方式

dom.style.width/height

　　這種方式只能取到dom元素內聯樣式所設定的寬高，也就是說如果該節點的樣式是在style標籤中或外聯的CSS檔案中設定的話，通過這種方法是獲取不到dom的寬高的。

dom.currentStyle.width/height

　　這種方式獲取的是在頁面渲染完成後的結果，就是說不管是哪種方式設定的樣式，都能獲取到。但這種方式只有IE瀏覽器支援。

window.getComputedStyle(dom).width/height

　　這種方式的原理和2是一樣的，這個可以相容更多的瀏覽器，通用性好一些。

dom.getBoundingClientRect().width/height

　　這種方式是根據元素在視窗中的絕對位置來獲取寬高的

dom.offsetWidth/offsetHeight

　　這個就沒什麼好說的了，最常用的，也是相容最好的。

4.拓展各種獲得寬高的方式

獲取螢幕的高度和寬度（螢幕解析度）：

window.screen.height/width

獲取螢幕工作區域的高度和寬度（去掉狀態列）：

window.screen.availHeight/availWidth

網頁全文的高度和寬度：

document.body.scrollHeight/Width

滾動條捲上去的高度和向右卷的寬度：

document.body.scrollTop/scrollLeft

網頁可見區域的高度和寬度（不加邊線）：

document.body.clientHeight/clientWidth

網頁可見區域的高度和寬度（加邊線）：

document.body.offsetHeight/offsetWidth

5.邊距重疊解決方案(BFC)BFC原理

內部的box會在垂直方向，一個接一個的放置

每個元素的margin box的左邊，與包含塊border box的左邊相接觸（對於從做往右的格式化，否則相反）

box垂直方向的距離由margin決定，屬於同一個bfc的兩個相鄰box的margin會發生重疊
bfc的區域不會與浮動區域的box重疊
bfc是一個頁面上的獨立的容器，外面的元素不會影響bfc裡的元素，反過來，裡面的也不會影響外面的
計算bfc高度的時候，浮動元素也會參與計算

建立bfc

float屬性不為none（脫離文件流）
position為absolute或fixed
display為inline-block,table-cell,table-caption,flex,inine-flex
overflow不為visible
根元素

demo

<section class="top">
    <h1>上</h1>
    這塊margin-bottom:30px;
</section>
<!-- 給下面這個塊新增一個父元素，在父元素上建立bfc -->
<div style="overflow:hidden">
    <section class="bottom">
    <h1>下</h1>
    這塊margin-top:50px;
    </section>
</div>

css reset 和 normalize.css 有什麼區別

兩者都是通過重置樣式，保持瀏覽器樣式的一致性
前者幾乎為所有標籤添加了樣式，後者保持了許多瀏覽器樣式，保持儘可能的一致
後者修復了常見的桌面端和移動端瀏覽器的bug：包含了HTML5元素的顯示設定、預格式化文字的font-size問題、在IE9中SVG的溢位、許多出現在各瀏覽器和作業系統中的與表單相關的bug。
前者中含有大段的繼承鏈
後者模組化，文件較前者來說豐富

居中方法

水平方向上

針對inline, 內聯塊inline-block, 內聯表inline-table, inline-flex元素及img,span,button等元素
.text_div{
    text-align:center;
}

不定寬塊狀元素居中
.text_div{
    margin:0 auto;
}

通過給父元素設定 float，然後給父元素設定 position:relative 和 left:50%，子元素設定 position:relative 和 left: -50% 來實現水平居中。
.wrap{
    float:left;
    position:relative;
    left:50%;
    clear:both;
}
.wrap-center{
    left:-50%;
}

垂直居中

單行內聯(inline-)元素垂直居中 
通過設定內聯元素的高度(height)和行高(line-height)相等，從而使元素垂直居中。

.text_div{
    height: 120px;
    line-height: 120px;
}

利用表佈局
.father {
    display: table;
}
.children {
    display: table-cell;
    vertical-align: middle;
}

flex佈局
.center-flex {
    display: flex;
    flex-direction: column;//上下排列
    justify-content: center;
}

絕對佈局方式
已知高度
.parent {
  position: relative;
}
.child {
  position: absolute;
  top: 50%;
  height: 100px;
  margin-top: -50px; 
}
未知高度
.parent {
    position: relative;
}
.child {
    position: absolute;
    top: 50%;
    transform: translateY(-50%);
}

垂直水平居中根據上方結合

flex方式
.parent {
    display: flex;
    justify-content: center;
    align-items: center;
}
grid方式
.parent {
  height: 140px;
  display: grid;
}
.child { 
  margin: auto;
}

css優先順序確定

每個選擇器都有權值，權值越大越優先
繼承的樣式優先順序低於自身指定樣式
！important優先順序最高 js也無法修改
權值相同時，靠近元素的樣式優先順序高順序為內聯樣式表（標籤內部）> 內部樣式表（當前檔案中）> 外部樣式表（外部檔案中）

bfc內容見盒模型

如何清除浮動

不清楚浮動會發生高度塌陷：浮動元素父元素高度自適應（父元素不寫高度時，子元素寫了浮動後，父元素會發生高度塌陷）

clear清除浮動（新增空div法）在浮動元素下方新增空div,並給該元素寫css樣式： {clear:both;height:0;overflow:hidden;}
給浮動元素父級設定高度
父級同時浮動（需要給父級同級元素新增浮動）
父級設定成inline-block，其margin: 0 auto居中方式失效
利用br標籤的clear屬性
給父級新增overflow:hidden 清除浮動方法
萬能清除法 after偽類清浮動（現在主流方法，推薦使用）

.float_div:after{
    content:".";
    clear:both;
    display:block;
    height:0;
    overflow:hidden;
    visibility:hidden;
}
.float_div{
    zoom:1
}

自適應佈局

思路：

左側浮動或者絕對定位，然後右側margin撐開
使用div包含，然後靠負margin形成bfc
使用flex

畫三角形

#item {
    width: 0;
    height: 0;
    border-left: 50px solid transparent;
    border-right: 50px solid transparent;
    border-top: 50px solid transparent;
    border-bottom: 50px solid blue;
    background: white;
}

link @import匯入css

link是XHTML標籤，除了載入CSS外，還可以定義RSS等其他事務；@import屬於CSS範疇，只能載入CSS。
link引用CSS時，在頁面載入時同時載入；@import需要頁面網頁完全載入以後載入。
link無相容問題；@import是在CSS2.1提出的，低版本的瀏覽器不支援。
ink支援使用Javascript控制DOM去改變樣式；而@import不支援。

animation

長寬比方案

使用padding方式結合calc實現
長寬一項設定百分比另一項aspect-ratio實現（需藉助外掛實現）

display相關

block:div等容器型別
inline:img span等行內型別
table系列：將樣式變成table型別
flex:重點把握，非常強大
grid:同上
inline-block:可設定寬度，兩者間有一點間隙
inherit:繼承父級

<div id="javascript">JavaScript相關</div>

1 ["1", "2", "3"].map(parseInt)

首先, map接受兩個引數, 一個回撥函式 callback, 一個回撥函式的this值

其中回撥函式接受三個引數 currentValue, index, arrary;

而題目中, map只傳入了回撥函式--parseInt.

其次, parseInt 只接受兩個兩個引數 string, radix(基數).  
本題理解來說也就是key與 index 

所以本題即問
parseInt('1', 0);
parseInt('2', 1);
parseInt('3', 2);

parseInt(string, radix)
string    必需。要被解析的字串。
radix 可選。表示要解析的數字的基數。該值介於 2 ~ 36 之間。
如果省略該引數或其值為 0，則數字將以 10 為基礎來解析。如果它以 “0x” 或 “0X” 開頭，將以 16 為基數。

2 [[3,2,1].reduce(Math.pow), [].reduce(Math.pow)]

arr.reduce(callback[, initialValue])
reduce接受兩個引數, 一個回撥, 一個初始值.
回撥函式接受四個引數 previousValue, currentValue, currentIndex, array
需要注意的是 If the array is empty and no initialValue was provided, TypeError would be thrown.
所以第二個表示式會報異常. 第一個表示式等價於 Math.pow(3, 2) => 9; Math.pow(9, 1) =>9

3

var ary = [0,1,2];
ary[10] = 10;
ary.filter(function(x) { return x === undefined;});
我們看到在迭代這個陣列的時候, 首先檢查了這個索引值是不是陣列的一個屬性, 那麼我們測試一下.

0 in ary; => true
3 in ary; => false
10 in ary; => true
也就是說 從 3 - 9 都是沒有初始化的bug !, 這些索引並不存在與陣列中. 在 array 的函式呼叫的時候是會跳過這些坑的.

4 [typeof null, null instanceof Object]

typeof 返回一個表示型別的字串.
instanceof 運算子用來檢測 constructor.prototype 是否存在於引數 object 的原型鏈上.
type         result
Undefined   "undefined"
Null        "object"
Boolean     "boolean"
Number      "number"
String      "string"
Symbol      "symbol"
Host object Implementation-dependent
Function    "function"
Object      "object"

5 js資料型別

1.number;

2.string;

3.boolean;

4.undefined;

5.null;

6.symbol（ES6新增，文章後面有對著新型別的解釋）Symbol 生成一個全域性唯一的值。

7.Object.（包括Object，Array，Function）

6 promise 用法

定義
var promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 非同步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});
使用
promise.then(function(value) {
  // success
}, function(error) {
  // failure
});
//等價於：
promise.then(function(){
  //success
}).catch(function(){
  //failure
})

7 es6 promise ajax

定義
const myHttpClient = url => {
  return new Promise((resolve, reject) => {
    let client = new XMLHttpRequest();
    client.open("GET", url);
    client.onreadystatechange = handler;
    client.responseType = "json";
    client.setRequestHeader("Accept", "application/json");
    client.send();
    function handler() {
      if (this.readyState !== 4) {
        return;
      }
      if (this.status === 200) {
        resolve(this.response);
      } else {
        reject(new Error(this.statusText));
      }
    }
  });
};
使用
myHttpClient('https://www.baidu.com').then(res => {
  console.log(res);
}).catch(error => {
  console.log(error);
});

8閉包

function foo(x) {
    var tmp = 3;
    return function (y) {
        alert(x + y + (++tmp));
    }
}
var bar = foo(2); // bar 現在是一個閉包
bar(10);
結果是16
es6通常用let const塊級作用域代替，
閉包缺點，ie中會引起記憶體洩漏，嚴格來說是ie的缺點不是閉包的問題

9 什麼是立即執行函式？使用立即執行函式的目的是什麼？

常見兩種方式
1.(function(){...})()
  (function(x){
      console.log(x);
  })(12345)
2.(function(){...}())
  (function(x){
      console.log(x);
  }(12345))
作用 不破壞汙染全域性的名稱空間，若需要使用，將其用變數傳入如
（function(window){...}(window)）

10 async/await 語法

作用：非同步程式碼的新方式
promise示例
const makeRequest = () => {
  return getJSON()
    .then(data => {
      if (data.needsAnotherRequest) {
        return makeAnotherRequest(data)
          .then(moreData => {
            console.log(moreData)
            return moreData
          })
      } else {
        console.log(data)
        return data
      }
    })
}
async/await示例
const makeRequest = async () => {
  const data = await getJSON()
  if (data.needsAnotherRequest) {
    const moreData = await makeAnotherRequest(data);
    console.log(moreData)
    return moreData
  } else {
    console.log(data)
    return data    
  }
}
函式前面多了一個aync關鍵字。await關鍵字只能用在aync定義的函式內。async函式會隱式地返回一個promise，該promise的reosolve值就是函式return的值。(示例中reosolve值就是字串"done")

11 深淺拷貝

let a = {
  aa: 1,
  bb: 2,
  cc: 3,
  dd: {
    ee: 5,
  },
  ff: {
    gg: 6,
  }
};
let d = JSON.parse(JSON.stringify(a));//深複製包含子物件
let c = {...a};//深拷貝單不包含子物件
let b = a;//淺拷貝
b.bb = 22;
c.cc = 33;
c.dd.ee = 55;
d.ff.gg = 66;
console.log(a);
console.log(b);
console.log(c);
console.log(d);

12陣列去重

思路1：定義一個新陣列，並存放原陣列的第一個元素，然後將元素組一一和新陣列的元素對比，若不同則存放在新陣列中
思路2：先將原陣列排序，在與相鄰的進行比較，如果不同則存入新陣列。
思路3：利用物件屬性存在的特性，如果沒有該屬性則存入新陣列。
思路4（最常用）：使用es6 set
let arr= [1, 2, 3, 3, 5, 7, 2, 6, 8];
console.log([...new Set(arr)]);

13正則實現trim()功能

function myTrim(str) {
  let reg = /^\s+|\s+$/g;
  return str.replace(reg, "");
}
console.log(myTrim('    asdf    '));

14 JS原型

1.每個物件都有 __proto__ 屬性，但只有函式物件才有 prototype 屬性
2.個人粗略理解與python的類方法靜態方法例項方法差不多

15 es6 class

面向物件，java中類

16 JS 如何實現繼承

1.使用原型繼承（既繼承了父類的模板，又繼承了父類的原型物件。優點是繼承了父類的模板，又繼承了父類的原型物件，缺點就是父類例項傳參，不是子類例項化傳參，不符合常規語言的寫法）
2.使用call的方式（繼承了父類的模板，不繼承了父類的原型物件。優點是方便了子類例項傳參，缺點就是不繼承了父類的原型物件）

17 手寫jquery外掛

(function ($) {
    $.fn.myPlugins = function (options) {
      //引數賦值
      options = $.extend(defaults, options);//物件合併
      this.each(function () {
          //執行程式碼邏輯
      });
    };
})(jQuery);

$(selector).myPlugins({引數});

18 數組合並去重排序

let arr1 = [1, 25, 2, 26, 1234, 6, 213];
let arr2 = [2, 6, 2134, 6, 31, 623];
let c = [...new Set([...arr1, ...arr2])].sort((a, b) => {
    return a - b;
});

19 call apply

作用：在函式呼叫時改變函式的執行上下文也就是this的值區別：call採用不定長的引數列表，而apply使用一個引數陣列。效能優化圖

20 for 中setTimeOut

要為迴圈題建立不同的迴圈副本

21 sort函式

V8 引擎 sort 函式只給出了兩種排序 InsertionSort 和 QuickSort，數量小於10的陣列使用插入，比10大的陣列則使用快排。

22 navigator

Navigator

23 jquery繫結方式

click後者覆蓋
bind後者覆蓋
on(jquery>=1.7)
live
delegate

24 事件流向

冒泡：子節點一層層冒泡到根節點
捕獲順序與冒泡相反
addEventListener最後個引數true代表捕獲反之代表冒泡
阻止冒泡不停止父節點捕獲

25原生操作class

//判斷有無
function hasClass(ele, cls) {
    return ele.className.match(new RegExp("(\\s|^)" + cls + "(\\s|$)"));
}

//新增
function addClass(ele, cls) {
    if (!this.hasClass(ele, cls)) ele.className += " " + cls;
}

//刪除
function removeClass(ele, cls) {
    if (hasClass(ele, cls)) {
        let reg = new RegExp("(\\s|^)" + cls + "(\\s|$)");
        ele.className = ele.className.replace(reg, " ");
    }
}

html5中加入classList 
一系列操作
相容至IE10

<div id="dom">DOM相關</div>

dom事件模型

DOM之事件模型分指令碼模型、內聯模型(同類一個，後者覆蓋)、動態繫結(同類多個)demo

<body>
<!--行內繫結：指令碼模型-->
<button onclick="javascrpt:alert('Hello')">Hello1</button>
<!--內聯模型-->
<button onclick="showHello()">Hello2</button>
<!--動態繫結-->
<button id="btn3">Hello3</button>
</body>
<script>
/*DOM0：同一個元素，同類事件只能新增一個，如果新增多個，
* 後面新增的會覆蓋之前新增的*/
function shoeHello() {
alert("Hello");
}
var btn3 = document.getElementById("btn3");
btn3.onclick = function () {
alert("Hello");
}
/*DOM2:可以給同一個元素新增多個同類事件*/
btn3.addEventListener("click",function () {
alert("hello1");
});
btn3.addEventListener("click",function () {
alert("hello2");
})
if (btn3.attachEvent){
/*IE*/
btn3.attachEvent("onclick",function () {
alert("IE Hello1");
})
}else {
/*W3C*/
btn3.addEventListener("click",function () {
alert("W3C Hello");
})
}
</script>

冒泡解釋：當點選一個元素觸發事件時. 事件會先從元素的最外層父元素一層一層進入到觸發的元素, 然後在從觸發元素一層一層返回到最外層父元素, 從最外層一層一層進入的階段叫事件捕獲階段, 從最裡層一層一層往外的階段叫事件冒泡,

移動端觸控事件

①touchstart：當手指觸碰到螢幕的時候觸發 ②touchmove：當手指在螢幕上滑動的時候觸發 ③touchend：當手指離開螢幕的時候時候觸發 ④touchcancel事件：當系統停止跟蹤觸控的時候觸發(這個事件很少會用，一般不做深入研究)。電話接入或者彈出資訊等其他事件切入event：

touches：表示當前跟蹤的觸控操作的touch物件的陣列。
targetTouches：特定於事件目標的Touch物件的陣列。
changeTouches：表示自上次觸控以來發生了什麼改變的Touch物件的陣列。

每個touch物件包含的屬性

clientX：觸控目標在視口中的x座標。
clientY：觸控目標在視口中的y座標。
identifier：標識觸控的唯一ID。
pageX：觸控目標在頁面中的x座標。
pageY：觸控目標在頁面中的y座標。
screenX：觸控目標在螢幕中的x座標。
screenY：觸控目標在螢幕中的y座標。
target：觸目的DOM節點目標。

事件委託

參考定義：事件委託就是利用事件冒泡，只指定一個事件處理程式，就可以管理某一型別的所有事件好處：給重複的節點新增相同操作，減少dom互動，提高效能實現思路：給父元件新增事件，通過事件冒泡，排查元素是否為指定元素，並進行系列操作

<div id="http">HTTP相關</div>

常見狀態碼

2開頭（請求成功）表示成功處理了請求的狀態程式碼。

200 （成功）伺服器已成功處理了請求。通常，這表示伺服器提供了請求的網頁。 201 （已建立）請求成功並且伺服器建立了新的資源。 202 （已接受）伺服器已接受請求，但尚未處理。 203 （非授權資訊）伺服器已成功處理了請求，但返回的資訊可能來自另一來源。 204 （無內容）伺服器成功處理了請求，但沒有返回任何內容。 205 （重置內容）伺服器成功處理了請求，但沒有返回任何內容。206 （部分內容）伺服器成功處理了部分 GET 請求。

3開頭（請求被重定向）表示要完成請求，需要進一步操作。通常，這些狀態程式碼用來重定向。

300 （多種選擇）針對請求，伺服器可執行多種操作。伺服器可根據請求者 (user agent) 選擇一項操作，或提供操作列表供請求者選擇。 301 （永久移動）請求的網頁已永久移動到新位置。伺服器返回此響應（對 GET 或 HEAD 請求的響應）時，會自動將請求者轉到新位置。302 （臨時移動）伺服器目前從不同位置的網頁響應請求，但請求者應繼續使用原有位置來進行以後的請求。303 （檢視其他位置）請求者應當對不同的位置使用單獨的 GET 請求來檢索響應時，伺服器返回此程式碼。304 （未修改）自從上次請求後，請求的網頁未修改過。伺服器返回此響應時，不會返回網頁內容。 305 （使用代理）請求者只能使用代理訪問請求的網頁。如果伺服器返回此響應，還表示請求者應使用代理。 307 （臨時重定向）伺服器目前從不同位置的網頁響應請求，但請求者應繼續使用原有位置來進行以後的請求。

4開頭（請求錯誤）這些狀態程式碼表示請求可能出錯，妨礙了伺服器的處理。

400 （錯誤請求）伺服器不理解請求的語法。 401 （未授權）請求要求身份驗證。對於需要登入的網頁，伺服器可能返回此響應。 403 （禁止）伺服器拒絕請求。404 （未找到）伺服器找不到請求的網頁。405 （方法禁用）禁用請求中指定的方法。 406 （不接受）無法使用請求的內容特性響應請求的網頁。 407 （需要代理授權）此狀態程式碼與 401（未授權）類似，但指定請求者應當授權使用代理。408 （請求超時）伺服器等候請求時發生超時。 409 （衝突）伺服器在完成請求時發生衝突。伺服器必須在響應中包含有關衝突的資訊。 410 （已刪除）如果請求的資源已永久刪除，伺服器就會返回此響應。 411 （需要有效長度）伺服器不接受不含有效內容長度標頭欄位的請求。 412 （未滿足前提條件）伺服器未滿足請求者在請求中設定的其中一個前提條件。 413 （請求實體過大）伺服器無法處理請求，因為請求實體過大，超出伺服器的處理能力。 414 （請求的 URI 過長）請求的 URI（通常為網址）過長，伺服器無法處理。 415 （不支援的媒體型別）請求的格式不受請求頁面的支援。 416 （請求範圍不符合要求）如果頁面無法提供請求的範圍，則伺服器會返回此狀態程式碼。 417 （未滿足期望值）伺服器未滿足"期望"請求標頭欄位的要求。

5開頭（伺服器錯誤）這些狀態程式碼表示伺服器在嘗試處理請求時發生內部錯誤。這些錯誤可能是伺服器本身的錯誤，而不是請求出錯。

500 （伺服器內部錯誤）伺服器遇到錯誤，無法完成請求。 501 （尚未實施）伺服器不具備完成請求的功能。例如，伺服器無法識別請求方法時可能會返回此程式碼。 502 （錯誤閘道器）伺服器作為閘道器或代理，從上游伺服器收到無效響應。 503 （服務不可用）伺服器目前無法使用（由於超載或停機維護）。通常，這只是暫時狀態。 504 （閘道器超時）伺服器作為閘道器或代理，但是沒有及時從上游伺服器收到請求。 505 （HTTP 版本不受支援）伺服器不支援請求中所用的 HTTP 協議版本。

快取

Expires在http1.0中使用，與伺服器時間有誤差，在1.1中由Cache-control替代

Cache-Control 和 Etag 的區別

如下圖區別圖

Cookie sessionStorage localStorage

共同點：都是儲存在瀏覽器端，且同源的。區別：cookie資料始終在同源的http請求中攜帶，即cookie在瀏覽器和伺服器間來回傳遞。而sessionStorage和localStorage不會自動把資料發給伺服器，僅在本地儲存。cookie資料不能超過4k(適合儲存小資料)。sessionStorage和localStorage容量較大，資料有效期不同，sessionStorage：僅在當前瀏覽器視窗關閉前有效。localStorage：始終有效，視窗或瀏覽器關閉也一直儲存，需手動清楚；cookie只在設定的cookie過期時間之前一直有效，即使視窗或瀏覽器關閉。作用域不同。sessionStorage不在不同的瀏覽器視窗中共享；localStorage 在所有同源視窗中都是共享的；cookie也是在所有同源視窗中都是共享的。

應用場景：localStorage：常用於長期登入（+判斷使用者是否已登入），適合長期儲存在本地的資料。sessionStorage ：敏感賬號一次性登入； cookies與伺服器互動。

GET POST區別

get_post

請求行，請求頭，請求體詳解

1,2,3請求行，4請求體，5請求體

跨域、JSONP 、CORS、postMessage

跨域概念解釋：當前發起請求的域與該請求指向的資源所在的域不一樣。這裡的域指的是這樣的一個概念：我們認為若協議 + 域名 + 埠號均相同，那麼就是同域。如下表

jsoup實現

原生
<script>
    var script = document.createElement('script');
    script.type = 'text/javascript';
 
    // 傳參並指定回撥執行函式為onBack
    script.src = 'http://www.domain2.com:8080/login?user=admin&callback=onBack';
    document.head.appendChild(script);
 
    // 回撥執行函式
    function onBack(res) {
        alert(JSON.stringify(res));
    }
 </script>
 
jquery
$.ajax({
    url: 'http://www.domain2.com:8080/login',
    type: 'get',
    dataType: 'jsonp',  // 請求方式為jsonp
    jsonpCallback: "onBack",    // 自定義回撥函式名
    data: {}
});

vue
this.$http.jsonp('http://www.domain2.com:8080/login', {
    params: {},
    jsonp: 'onBack'
}).then((res) => {
    console.log(res); 
})

配合的後端node實現,其他伺服器語言也可以
const querystring = require('querystring');
const http = require('http');
const server = http.createServer();
server.on('request', function(req, res) {
    var params = qs.parse(req.url.split('?')[1]);
    var fn = params.callback;
 
    // jsonp返回設定
    res.writeHead(200, { 'Content-Type': 'text/javascript' });
    res.write(fn + '(' + JSON.stringify(params) + ')');
 
    res.end();
});
server.listen('8080');

jsoup缺點只能實現get請求

CORS：跨源資源共享 Cross-Origin Resource Sharing(CORS)，通常伺服器設定，若帶cookie請求，則前後端都需要設定後端常見設定response.setHeader("Access-Control-Allow-Origin", "http://www.domain1.com"); // 若有埠需寫全（協議+域名+埠），允許那些外源請求response.setHeader("Access-Control-Allow-Credentials", "true"); //是否需要驗證

前端示例

原生

var xhr = new XMLHttpRequest(); // IE8/9需用window.XDomainRequest相容
// 前端設定是否帶cookie
xhr.withCredentials = true;
xhr.open('post', 'http://www.domain2.com:8080/login', true);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr.send('user=admin');
 
xhr.onreadystatechange = function() {
    if (xhr.readyState == 4 && xhr.status == 200) {
        alert(xhr.responseText);
    }

jquery
$.ajax({
    ...
   xhrFields: {
       withCredentials: true    // 前端設定是否帶cookie
   },
   crossDomain: true,   // 會讓請求頭中包含跨域的額外資訊，但不會含cookie
    ...
});

postMessage(data,origin)方法接受兩個引數
demo

a.html
<iframe id="iframe" src="http://www.domain2.com/b.html" style="display:none;"></iframe>
<script>       
    var iframe = document.getElementById('iframe');
    iframe.onload = function() {
        var data = {
            name: 'aym'
        };
        // 向domain2傳送跨域資料
        iframe.contentWindow.postMessage(JSON.stringify(data), 'http://www.domain2.com');
    };
 
    // 接受domain2返回資料
    window.addEventListener('message', function(e) {
        alert('data from domain2 ---> ' + e.data);
    }, false);
</script>

b.html  與a.html不同源

<script>
    // 接收domain1的資料
    window.addEventListener('message', function(e) {
        alert('data from domain1 ---> ' + e.data);
 
        var data = JSON.parse(e.data);
        if (data) {
            data.number = 16;
 
            // 處理後再發回domain1
            window.parent.postMessage(JSON.stringify(data), 'http://www.domain1.com');
        }
    }, false);
</script>

osi模型

七層結構：物理層、資料鏈路層、網路層、傳輸層、會話層、表示層、應用層tcp ucp屬於傳輸層；http屬於應用層

http2.0 http1

HTTP2.0的基本單位為二進位制幀
HTTP2.0中幀具有優先順序
HTTP2.0的多路複用（ 1次連線）
HTTP2.0壓縮訊息頭
HTTP2.0服務端推送
HTTP2.0只適用於HTTPS的場景

<div id="vue">Vue相關</div>

生命週期順序

生命週期

元件通訊

1.父傳子用props,父用子用ref 子調父用$emit,無關係用Bus

Vuex

元件通訊庫，可以避免子元件無法改變props的弊端等mutations 同步操作，用於改變狀態官方不推薦非同步action 執行多個mutaions，官方推薦非同步操作mapState、mapGetters、mapActions使用示例

<template>
  <el-dialog :visible.sync="show"></el-dialog>
</template>

<script>
import {mapState} from 'vuex';
export default {
  computed:{

    //這裡的三點叫做 : 擴充套件運算子
    ...mapState({
      show:state=>state.dialog.show
    }),
  }
}
</script>

後兩者類似

VueRouter

定義
var routes = [
    {
        path:"/one",

        component:匯入的元件1
    },
    {
        path:"/two",
        component:匯入的元件2
    },
];
// 定義路由元件
var router = new VueRouter({
    routes
});
// 定義路由
new Vue({
    el:"#box",
    router
});
 訪問設定的路由後 會將<router-view></router-view>替換成相應的模版
 html訪問方式 <router-link to="/one">One</router-link>(類似a標籤)
 js訪問方式 this.$router.push('/one'); 
 replace方式 替換當前頁面
 攜帶的引數 可以通過this.$route.query.xxxx來獲取

Vue雙向繫結

原理：利用了 Object.defineProperty() 這個方法重新定義了物件獲取屬性值(get)和設定屬性值(set)的操作來實現的。缺點：雙向資料流是自動管理狀態的, 但是在實際應用中會有很多不得不手動處理狀態變化的邏輯, 使得程式複雜度上升, 難以除錯。

computed watch methods

用法：區別：

前兩者自動追蹤資料，執行相關函式，最後一個手動呼叫；
computed是計算屬性，用法與data一致
watch像事件監聽，物件發生變化時，執行相關操作
methods與js中執行方法類似
computed通常只有get屬性
資料變化的同時進行非同步操作或者是比較大的開銷，那麼watch為最佳選擇
watch的物件必須事先宣告

<div id="sort">演算法相關</div>

各種排序實現

相關資料

// 氣泡排序: 比較兩個相鄰的項，如果第一個大於第二個則交換他們的位置,元素項向上移動至正確的順序，就好像氣泡往上冒一樣
冒泡demo:
function bubbleSort(arr) {
    let len = arr.length;
    for (let i = 0; i < len; i++) {
        for (let j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        //相鄰元素兩兩對比
                [arr[j + 1], arr[j]] = [arr[j], arr[j + 1]];
            }
        }
    }
    return arr;
}
// 1) 首先，在陣列中選擇一箇中間項作為主元
// 2) 建立兩個指標，左邊的指向陣列第一個項，右邊的指向最後一個項，移動左指標，直到找到一個比主元大的項，接著，移動右邊的指標，直到找到一個比主元小的項，然後交換它們。重複這個過程，直到
// 左側的指標超過了右側的指標。這個使比主元小的都在左側，比主元大的都在右側。這一步叫劃分操作
// 3) 接著，演算法對劃分後的小陣列（較主元小的值組成的的小陣列， 以及較主元大的值組成的小陣列）重複之前的兩個步驟，直到排序完成
快排demo:
function quickSort(arr, left, right) {
    let len = arr.length;
    let partitionIndex;
    left = typeof left !== 'number' ? 0 : left;
    right = typeof right !== 'number' ? len - 1 : right;
    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex - 1);
        quickSort(arr, partitionIndex + 1, right);
    }
    return arr;
}

function partition(arr, left, right) {     //分割槽操作
    let pivot = left;                      //設定基準值（pivot）
    let index = pivot + 1;
    for (let i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            [arr[i], arr[index]] = [arr[index], arr[i]];
            index++;
        }
    }
    [arr[pivot], arr[index - 1]] = [arr[index - 1], arr[pivot]];
    return index - 1;
}
// 選擇排序：大概思路是找到最小的放在第一位，找到第二小的放在第二位，以此類推 演算法複雜度O(n^2)
選擇demo:
function selectionSort(arr) {
    let len = arr.length;
    let minIndex;
    for (let i = 0; i < len - 1; i++) {
        minIndex = i;
        for (let j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     //尋找最小的數
                minIndex = j;                 //將最小數的索引儲存
            }
        }
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
return arr;
}
// 插入排序：每次排一個數組項，假設陣列的第一項已經排序，接著，把第二項與第一項進行對比，第二項是該插入到第一項之前還是之後，第三項是該插入到第一項之前還是第一項之後還是第三項
插入demo:
function insertionSort(arr) {
    let len = arr.length;
    let preIndex, current;
    for (let i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr;
}
// 歸併排序：Mozilla Firefox 使用歸併排序作為Array.prototype.sort的實現，而chrome使用快速排序的一個變體實現的,前面三種演算法效能不好，但歸併排序效能不錯 演算法複雜度O(nlog^n)
// 歸併排序是一種分治演算法。本質上就是把一個原始陣列切分成較小的陣列，直到每個小陣列只有一個位置，接著把小陣列歸併成較大的陣列，在歸併過程中也會完成排序，直到最後只有一個排序完畢的大陣列
歸併demo:
function mergeSort(arr) {  //採用自上而下的遞迴方法
    let len = arr.length;
    if(len < 2) {
        return arr;
    }
    let middle = Math.floor(len / 2),
    left = arr.slice(0, middle),
    right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right){
    let result = [];
    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            result.push(left.shift());
        } else {
            result.push(right.shift());
        }
    }
    result.push(...left);
    result.push(...right);
    return result;
}
//堆排序：堆排序把陣列當中二叉樹來排序而得名。
// 1）索引0是樹的根節點；2）除根節點為，任意節點N的父節點是N/2；3）節點L的左子節點是2*L；4）節點R的右子節點為2*R + 1
// 本質上就是先構建二叉樹，然後把根節點與最後一個進行交換，然後對剩下對元素進行二叉樹構建，進行交換，直到剩下最後一個
堆demo:
var len;    //因為宣告的多個函式都需要資料長度，所以把len設定成為全域性變數

function buildMaxHeap(arr) {   //建立大頂堆
    len = arr.length;
    for (let i = Math.floor(len / 2); i >= 0; i--) {
        heapify(arr, i);
    }
}

function heapify(arr, i) {     //堆調整
    let left = 2 * i + 1;
    let right = 2 * i + 2;
    let largest = i;
    if (left < len && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest !== i) {
        [arr[i], arr[largest]] = [arr[largest], arr[i]];
        heapify(arr, largest);
    }
}

function heapSort(arr) {
    buildMaxHeap(arr);
    for (let i = arr.length - 1; i > 0; i--) {
        [arr[0],arr[i]]=[arr[i],arr[0]];
        len--;
        heapify(arr, 0);
    }
    return arr;
}

二分查詢

思路（1）首先，從有序陣列的中間的元素開始搜尋，如果該元素正好是目標元素（即要查詢的元素），則搜尋過程結束，否則進行下一步。（2）如果目標元素大於或者小於中間元素，則在陣列大於或小於中間元素的那一半區域查詢，然後重複第一步的操作。（3）如果某一步陣列為空，則表示找不到目標元素。

// 非遞迴演算法
function binary_search(arr, key) {
    let low = 0;
    let high = arr.length - 1;
    while(low <= high){
        let mid = parseInt((high + low) / 2);
        if(key === arr[mid]){
            return  mid;
        }else if(key > arr[mid]){
            low = mid + 1;
        }else if(key < arr[mid]){
            high = mid -1;
        }else{
            return -1;
        }
    }
}
      

// 遞迴演算法
function binary_search(arr,low, high, key) {
    if (low > high){
        return -1;
    }
    let mid = parseInt((high + low) / 2);
    if(arr[mid] === key){
        return mid;
    }else if (arr[mid] > key){
        high = mid - 1;
        return binary_search(arr, low, high, key);
    }else if (arr[mid] < key){
        low = mid + 1;
        return binary_search(arr, low, high, key);
    }
};

二叉樹相關

建立
function Node(data,left,right){
    this.data = data;//數值
    this.left = left;//左節點
    this.right = right;//右節點
};
插入二叉樹
function insert(node,data){
    //建立一個新的節點
    let newNode  = new Node(data,null,null);
    //判斷是否存在根節點，沒有將新節點存入
    if(node == null){
        node = newNode;
    }else{
        //獲取根節點
        let current = node;
        let parent;
        while(true){
            //將當前節點儲存為父節點
            parent = current;
            //將小的資料放在左節點
            if(data < current.data){
                //獲取當前節點的左節點
                //判斷當前節點下的左節點是否有資料
                current = current.left;
                if(current == null){
                    //如果沒有資料將新節點存入當前節點下的左節點
                    parent.left = newNode;
                    break;
                }
            }else{
                current = current.right;
                if(current == null){
                    parent.right = newNode;
                    break;
                }
            }
        }    
    }
}
翻轉二叉樹
function invertTree(node) {
    if (node !== null) {
        node.left, node.right = node.left, node.right;
        invertTree(node.left);
        invertTree(node.right);
    }
    return node;
}

查詢連結串列中倒數第k個結點
2個思路
1：先遍歷出長度，然後查詢長度-k+1的值
2：2個指標，一個指標先走k-1，然後兩個一起走到底部，後者就是結果

<div id="web">網路安全相關</div>

XSS CSRF

XSS(跨站指令碼攻擊)，惡意的注入html程式碼，其他使用者訪問時，會被執行特點：能注入惡意的HTML/JavaScript程式碼到使用者瀏覽的網頁上，從而達到Cookie資料竊取、會話劫持、釣魚欺騙等攻擊防禦手段：

瀏覽器禁止頁面的JS訪問帶有HttpOnly屬性的Cookie
兩端進行輸入格式檢查
通過編碼轉義的方式進行輸出檢查

CSRF(攻擊跨站請求偽造)特點：重要操作的所有引數都是可以被攻擊者猜測到的。攻擊者預測出URL的所有引數與引數值，才能成功地構造一個偽造的請求。防禦手段：

token驗證機制，比如請求資料欄位中新增一個token，響應請求時校驗其有效性
使用者操作限制，比如驗證碼（繁瑣，使用者體驗差）
請求來源限制，比如限制HTTP Referer才能完成操作（防禦效果相比較差）

實踐中常用第一種

<div id="webpack"> webpack相關</div>

打包體積

優化思路

提取第三方庫或通過引用外部檔案的方式引入第三方庫
程式碼壓縮外掛UglifyJsPlugin
伺服器啟用gzip壓縮
按需載入資原始檔 require.ensure
優化devtool中的source-map
剝離css檔案，單獨打包
去除不必要外掛，通常就是開發環境與生產環境用同一套配置檔案導致

打包效率

開發環境採用增量構建，啟用熱更新
開發環境不做無意義的工作如提取css計算檔案hash等
配置devtool
選擇合適的loader
個別loader開啟cache 如babel-loader
第三方庫採用引入方式
提取公共程式碼
優化構建時的搜尋路徑指明需要構建目錄及不需要構建目錄
模組化引入需要的部分

Loader

編寫一個loader

loader就是一個node模組，它輸出了一個函式。當某種資源需要用這個loader轉換時，這個函式會被呼叫。並且，這個函式可以通過提供給它的this上下文訪問Loader API。
reverse-txt-loader
定義
module.exports = function(src) {
  //src是原檔案內容（abcde），下面對內容進行處理，這裡是反轉
  var result = src.split('').reverse().join(''); 
  //返回JavaScript原始碼，必須是String或者Buffer
  return `module.exports = '${result}'`;
}
使用
{
    test: /\.txt$/,
    use: [
        {
            './path/reverse-txt-loader'
        }
    ]
},

plugins

使用範圍更廣，通常只需要require()然後新增到plugins陣列中，且需要new一個

<div id="other">其他</div>

URL到介面顯示發生了什麼

DNS解析

先本地快取找，在一層層找將常見的地址解析成唯一對應的ip地址基本順序為：本地域名伺服器->根域名伺服器->com頂級域名伺服器依次類推下去,找到後記錄並快取下來如www.google.com為. -> .com -> google.com. -> www.google.com.

TCP連線

三次握手，只要沒收到確認訊息就要重新發

1. 主機向伺服器傳送一個建立連線的請求（您好，我想認識您）；
2. 伺服器接到請求後傳送同意連線的訊號（好的，很高興認識您）；
3. 主機接到同意連線的訊號後，再次向伺服器傳送了確認訊號（我也很高興認識您），自此，主機與伺服器兩者建立了連線。

傳送HTTP請求

瀏覽器會分析這個url，並設定好請求報文發出。請求報文中包括請求行、請求頭、空行、請求主體。https預設請求埠443， http預設80。常見的http請求如下

POST / HTTP1.1
Host:www.wrox.com
User-Agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)
Content-Type:application/x-www-form-urlencoded
Content-Length:40
Connection: Keep-Alive

name=Professional%20Ajax&publisher=Wiley
第一部分：請求行，第一行說明是post請求，以及http1.1版本。
第二部分：請求頭部，第二行至第六行。
第三部分：空行，第七行的空行。
第四部分：請求資料，第八行。
4. 伺服器處理請求並返回HTTP報文
後端處理返回http報文如下

HTTP/1.1 200 OK
Date: Fri, 22 May 2009 06:07:21 GMT
Content-Type: text/html; charset=UTF-8

<html>
      <head></head>
      <body>
            <!--body goes here-->
      </body>
</html>
第一行為狀態行，（HTTP/1.1）表明HTTP版本為1.1版本，狀態碼為200，狀態訊息為（ok）
第二行和第三行為訊息報頭，
Date:生成響應的日期和時間；Content-Type:指定了MIME型別的HTML(text/html),編碼型別是UTF-8
第三部分：空行，訊息報頭後面的空行是必須的
第四部分：響應正文，伺服器返回給客戶端的文字資訊。
空行後面的html部分為響應正文。

瀏覽器解析渲染頁面

通過HTML解析器解析HTML文件，構建一個DOM Tree，同時通過CSS解析器解析HTML中存在的CSS，構建Style Rules，兩者結合形成一個Attachment。
通過Attachment構造出一個呈現樹（Render Tree）
Render Tree構建完畢，進入到佈局階段（layout/reflow），將會為每個階段分配一個應出現在螢幕上的確切座標。
最後將全部的節點遍歷繪製出來後，一個頁面就展現出來了。

遇到script會停下來執行，所以通常把script放在底部

連線結束

元件封裝

目的：為了重用，提高開發效率和程式碼質量注意：低耦合，單一職責，可複用性，可維護性常用操作：

分析佈局
初步開發
化繁為簡
元件抽象

JS非同步載入

動態生成script標籤
新增h5的async defer屬性，前者亂序不適合依賴性載入
async 是“下載完就執行”， defer 是“渲染完再執行”

css與js動畫差異

css效能好
css程式碼邏輯相對簡單
js動畫控制好
js相容性好
js可實現的動畫多
js可以新增事件

負載均衡

多臺伺服器共同協作，不讓其中某一臺或幾臺超額工作，發揮伺服器的最大作用

http重定向負載均衡：排程者根據策略選擇伺服器以302響應請求，缺點只有第一次有效果，後續操作維持在該伺服器
dns負載均衡：解析域名時，訪問多個ip伺服器中的一個（可監控性較弱）
反向代理負載均衡：訪問統一的伺服器，由伺服器進行排程訪問實際的某個伺服器，對統一的伺服器要求大，效能受到伺服器群的數量

CDN

內容分發網路，基本思路是儘可能避開網際網路上有可能影響資料傳輸速度和穩定性的瓶頸和環節，使內容傳輸的更快、更穩定。

記憶體洩漏

定義：程式中己動態分配的堆記憶體由於某種原因程式未釋放或無法釋放引發的各種問題js中可能出現的記憶體洩漏情況結果：變慢，崩潰，延遲大等原因：

全域性變數
dom清空時，還存在引用
ie中使用閉包
定時器未清理
子元素存在引起的記憶體洩露

避免策略：

減少不必要的全域性變數，或者生命週期較長的物件，及時對無用的資料進行垃圾回收；
注意程式邏輯，避免“死迴圈”之類的；
避免建立過多的物件原則：不用了的東西要及時歸還。
減少層級過多的引用

babel原理

ES6、7程式碼輸入 -> babylon進行解析 -> 得到AST（抽象語法樹）-> plugin用babel-traverse對AST樹進行遍歷轉譯 ->得到新的AST樹->用babel-generator通過AST樹生成ES5程式碼、

promise

特性：Promise 物件的錯誤具有冒泡性質，會一直向後傳遞，直到被捕獲為止，也即是說，錯誤總會被下一個catch語句捕獲

js自定義事件

三要素：document.createEvent()event.initEvent()element.dispatchEvent()

demo:
(en:自定義事件名稱，fn:事件處理函式，addEvent:為DOM元素新增自定義事件，triggerEvent:觸發自定義事件)
window.onload = function(){
    var demo = document.getElementById("demo");
    demo.addEvent("test",function(){console.log("handler1")});
    demo.addEvent("test",function(){console.log("handler2")});
    demo.onclick = function(){
        this.triggerEvent("test");
    }
}
Element.prototype.addEvent = function(en,fn){
    this.pools = this.pools || {};
    if(en in this.pools){
        this.pools[en].push(fn);
    }else{
        this.pools[en] = [];
        this.pools[en].push(fn);
    }
}
Element.prototype.triggerEvent  = function(en){
    if(en in this.pools){
        var fns = this.pools[en];
        for(var i=0,il=fns.length;i<il;i++){
            fns[i]();
        }
    }else{
        return;
    }
}

es6模組 commonjs amd cmd

CommonJS 的規範中，每個 JavaScript 檔案就是一個獨立的模組上下文（module context），在這個上下文中預設建立的屬性都是私有的。也就是說，在一個檔案定義的變數（還包括函式和類），都是私有的，對其他檔案是不可見的。
CommonJS是同步載入模組,在瀏覽器中會出現堵塞情況，所以不適用
AMD 非同步，需要定義回撥define方式
es6 一個模組就是一個獨立的檔案，該檔案內部的所有變數，外部無法獲取。如果你希望外部能夠讀取模組內部的某個變數，就必須使用export關鍵字輸出該變數
es6還可以匯出類、方法，自動適用嚴格模式

前後端路由差別

1.後端每次路由請求都是重新訪問伺服器2.前端路由實際上只是JS根據URL來操作DOM元素，根據每個頁面需要的去服務端請求資料，返回資料後和模板進行組合。