前端面試之ES6篇（高產似母豬）

這也是前端面試常常詢問的問題，常常問你es6出現了哪些新的特性，平時又使用過那些。在編寫此教程的時候，第一句話每每就是面試經常問到的地方，而後後面就是他的詳細解釋，面試要求的內容我會用*標記出來。寫技術文檔是真的累啊，雖然是看別人的文檔，可是你得看不少，並且還得本身總結啊。因此說要是以爲對你有用仍是幫我點個star吧https://github.com/skychenbo

一、箭頭函數須要注意的地方
二、ES6 let、const
三、set數據結構
四、promise對象的用法,手寫一個promise
五、class的理解
六、模版語法的理解
七、rest參數
八、    module體系

箭頭函數須要注意的地方

*當要求動態上下文的時候，就不可以使用箭頭函數。也就是this的固定化
一、在使用=>定義函數的時候，this的指向是定義時所在的對象，而不是使用時所在的對象
二、不可以用做構造函數，這就是說，不可以使用new命令，不然就會拋出一個錯誤
三、不可以使用arguments對象
四、不能使用yield命令
這是一道當年很困惑個人一道題不知道你在第一眼能不能看出其結果,this的指向老是讓人困擾，可是有了=>之後媽媽不再用擔憂你使用this了

class Animal {
    constructor(){
        this.type = 'animal'
    }
    says(say) {
        setTimeout(function () {
            console.log(this.type + 'says' + say)
        },1000)
    }
}
var animal = new Animal()
animal.says('hi') // undefined says hi

咱們再來看看=>的狀況

class Animal() {
    constructor() {
        this.type = 'animal'
    }
    says(say) {
        setTimeout(() => {
            console.log(this.type + ' says ' + say)
        }, 1000)
    }
}
var animal = new Animal()
animal.says('hi') // animal says hi

ES6 let、const
*let是更完美的var，不是全局變量，具備塊級函數做用域,大多數狀況不會發生變量提高。const定義常量值，不可以從新賦值，若是值是一個對象，能夠改變對象裏邊的屬性值
let
一、let聲明的變量具備塊級做用域
二、let聲明的變量不能經過window.變量名進行訪問
三、形如for(let x..)的循環是每次迭代都爲x建立新的綁定
下面是var帶來的不合理場景

var a = []
for (var i = 0; i < i; i++) {
    a[i] = function () {
        console.log(i)
    }
}
a[5]() // 10

在上述代碼中，變量i是var聲明的，在全局範圍類都有效。因此每一次循環，新的i值都會覆蓋舊值，致使最後輸出都是10
而若是對循環使用let語句的狀況，那麼每次迭代都是爲x建立新的綁定代碼以下

var a = []
for (let i = 0; i < i; i++) {
    a[i] = function () {
        console.log(i)
    }
}
a[5]() // 5

固然除了這種方式讓數組中的各個元素分別是不一樣的函數，咱們還能夠採用閉包和當即函數兩種方法
這是閉包的方法

function showNum(i) {
    return function () {
        console.log(i)
    }
}
var a = []
for (var i = 0; i < 5; i++) {
    a[i] = showNum(i)
}

這是當即函數的方法

var a = []
for (var i = 0; i < 5; i++) {
    a[i] = (function (i) {
        return function () {
            console.log(i)
        }
    })(i)
}
a[2]()

Set數據結構

*es6方法,Set自己是一個構造函數，它相似於數組，可是成員值都是惟一的

const set = new Set([1,2,3,4,4])
[...set] // [1,2,3,4]
Array.from(new Set())是將set進行去重

promise對象的用法,手寫一個promise

promise是一個構造函數，下面是一個簡單實例

var promise = new Promise((resolve,reject) => {
    if (操做成功) {
        resolve(value)
    } else {
        reject(error)
    }
})
promise.then(function (value) {
    // success
},function (value) {
    // failure
})

Class的講解

*class語法相對原型、構造函數、繼承更接近傳統語法，它的寫法可以讓對象原型的寫法更加清晰、面向對象編程的語法更加通俗
這是class的具體用法

class Animal {
    constructor () {
        this.type = 'animal'
    }
    says(say) {
        console.log(this.type + 'says' + say)
    }
}
 let animal = new Animal()
 animal.says('hello') // animal says hello

 class Cat extends Animal {
     constructor() {
         super()
         this.type = 'cat'
     }
 }
 let cat = new Cat()
 cat.says('hello') // cat says hello

能夠看出在使用extend的時候結構輸出是cat says hello 而不是animal says hello。說明contructor內部定義的方法和屬性是實例對象本身的，不能經過extends 進行繼承。在class cat中出現了super(),這是什麼呢
在ES6中，子類的構造函數必須含有super函數，super表示的是調用父類的構造函數，雖然是父類的構造函數，可是this指向的倒是cat

Object.assign 方法

var n = Object.assign(a,b,c)向n中添加a,b,c的屬性

模版語法

*就是這種形式${varible},在以往的時候咱們在鏈接字符串和變量的時候須要使用這種方式'string' + varible + 'string'可是有了模版語言後咱們可使用string${varible}string這種進行鏈接

rest參數

*es6引入rest參數，用於獲取函數的多餘參數，這樣就不須要使用arguments對象了
ex:

function add(...values) {
    let sum = 0
    for(var val of values) {
        sum += val
    }
    return sum
}

module體系

*歷史上js是沒有module體系，沒法將一個大程序拆分紅一些小的程序。在es6以前，有commonJs,AMD兩種
CommonJS是如何書寫的呢

const animal = require('./content.js')
    // content.js
    module.exports = 'a cat'

require.js是這樣作的
// content.js

define('content.js', function () {
    return 'A cat'
})

require(['./content.js'], function (animal) {
    console.log(animal) // a cat
})

ES6的語法（在我用的vue中，就使用的是這個）

import animal from './content'
// content.js
export default 'a cat'

es6 import的其餘用法在vue中能夠 import animal from './content'animal這個值能夠根據你的喜歡而改變，可是有一個問題就是若是一旦引入的是函數或者變量時，你就必須和content中的名字保持一致，能夠參照import { say, type } from './content' 經常使用的還有一種寫法import * as content from './content' 這種寫法就是表示全部的輸出值都在這個對象上