【ES6】最經常使用的es6特性（一）

參考連接：

http://www.jianshu.com/p/ebfeb687eb70

http://www.cnblogs.com/Wayou/p/es6_new_features.html

1.let, const

這兩個的用途與var相似，都是用來聲明變量的，但在實際運用中他倆都有各自的特殊用途。

1.1第一種場景就是你如今看到的內層變量覆蓋外層變量

var name = 'zach'

while (true) {
    var name = 'obama'
    console.log(name)  //obama
    break
}

console.log(name)  //obama

使用var兩次輸出都是obama，這是由於ES5只有全局做用域和函數做用域，沒有塊級做用域。

而let則實際上爲JavaScript新增了塊級做用域。用它所聲明的變量，只在let命令所在的代碼塊內有效。

let name = 'zach'

while (true) {
    let name = 'obama'
    console.log(name)  //obama
    break
}

console.log(name)  //zach

1.2var帶來的第二個不合理場景就是用來計數的循環變量泄露爲全局變量

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

變量i是var聲明的，在全局範圍內都有效。因此每一次循環，新的i值都會覆蓋舊值，致使最後輸出的是最後一輪的i的值。而使用let則不會出現這個問題。

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

1.3const也用來聲明變量，可是聲明的是常量。一旦聲明，常量的值就不能改變

const PI = Math.PI

PI = 23 //Module build failed: SyntaxError: /es6/app.js: "PI" is read-only

當咱們嘗試去改變用const聲明的常量時，瀏覽器就會報錯。
const有一個很好的應用場景，就是當咱們引用第三方庫的時聲明的變量，用const來聲明能夠避免將來不當心重命名而致使出現bug：

const monent = require('moment')

2.class, extends, super

ES6提供了更接近傳統語言的寫法，引入了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

上面代碼首先用class定義了一個「類」，constructor方法，就是構造方法，而this關鍵字則表明實例對象。

簡單地說，constructor內定義的方法和屬性是實例對象本身的，而constructor外定義的方法和屬性則是全部實例對象能夠共享的。

Class之間能夠經過extends關鍵字實現繼承，這比ES5的經過修改原型鏈實現繼承，要清晰和方便不少。上面定義了一個Cat類，該類經過extends關鍵字，繼承了Animal類的全部屬性和方法。

super關鍵字，它指代父類的實例（即父類的this對象）。子類必須在constructor方法中調用super方法，不然新建實例時會報錯。這是由於子類沒有本身的this對象，而是繼承父類的this對象，而後對其進行加工。若是不調用super方法，子類就得不到this對象。

ES6的繼承機制，實質是先創造父類的實例對象this（因此必須先調用super方法），而後再用子類的構造函數修改this。

3.箭頭操做符

ES6中新增的箭頭操做符=>便有殊途同歸之妙。它簡化了函數的書寫。操做符左邊爲輸入的參數，而右邊則是進行的操做以及返回的值Inputs=>outputs

function(i){ return i + 1; } //ES5
(i) => i + 1 //ES6

若是方程比較複雜，則須要用{}把代碼包起來：

function(x, y) { 
    x++;
    y--;
    return x + y;
}
(x, y) => {x++; y--; return x+y}

除了看上去更簡潔之外，arrow function還有一項超級無敵的功能！
長期以來，JavaScript語言的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

運行上面的代碼會報錯，這是由於setTimeout中的this指向的是全局對象。因此爲了讓它可以正確的運行，傳統的解決方法有兩種：

第一種是將this傳給self,再用self來指代this

 says(say){
     var self = this;
     setTimeout(function(){
         console.log(self.type + ' says ' + say)
     }, 1000)

第二種方法是用bind(this),即

 says(say){
     setTimeout(function(){
         console.log(self.type + ' says ' + say)
     }.bind(this), 1000)

但如今咱們有了箭頭函數，就不須要這麼麻煩了：

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

當咱們使用箭頭函數時，函數體內的this對象，就是定義時所在的對象，而不是使用時所在的對象。
並非由於箭頭函數內部有綁定this的機制，實際緣由是箭頭函數根本沒有本身的this，它的this是繼承外面的，所以內部的this就是外層代碼塊的this。

4.template string（字符串模板）

字符串模板相對簡單易懂些。

用反引號（`）來標識起始，用${}來引用變量，並且全部的空格和縮進都會被保留在輸出之中

//產生一個隨機數
var num=Math.random();
//將這個數字輸出到console
console.log(`your num is ${num}`);

你們能夠先看下面一段代碼：

$("#result").append(
  "There are <b>" + basket.count + "</b> " +
  "items in your basket, " +
  "<em>" + basket.onSale +
  "</em> are on sale!"
);

咱們要用一堆的'+'號來鏈接文本與變量，而使用ES6的新特性模板字符串``後，咱們能夠直接這麼來寫：

$("#result").append(`
  There are <b>${basket.count}</b> items
   in your basket, <em>${basket.onSale}</em>
  are on sale!
`);

5.destructuring

自動解析數組或對象中的值。

好比若一個函數要返回多個值，常規的作法是返回一個對象，將每一個值作爲這個對象的屬性返回。

let cat = 'ken'
let dog = 'lili'
let zoo = {cat: cat, dog: dog}
console.log(zoo)  //Object {cat: "ken", dog: "lili"}

但在ES6中，利用解構這一特性，能夠直接返回一個數組，而後數組中的值會自動被解析到對應接收該值的變量中。

let cat = 'ken'
let dog = 'lili'
let zoo = {cat, dog}
console.log(zoo)  //Object {cat: "ken", dog: "lili"}

反過來能夠這麼寫：

let dog = {type: 'animal', many: 2}
let { type, many} = dog
console.log(type, many)   //animal 2

var [x,y]=getVal(),//函數返回值的解構
    [name,,age]=['wayou','male','secrect'];//數組解構

function getVal() {
    return [ 1, 2 ];
}

console.log('x:'+x+', y:'+y);//輸出：x:1, y:2 
console.log('name:'+name+', age:'+age);//輸出： name:wayou, age:secrect 

6.default, rest

default很簡單，意思就是默認值。

調用animal()方法時忘了傳參數，傳統的作法就是加上這一句type = type || 'cat'來指定默認值。

function sayHello(name){
    //傳統的指定默認參數的方式
    var name=name||'dude';
    console.log('Hello '+name);
}
//運用ES6的默認參數
function sayHello2(name='dude'){
    console.log(`Hello ${name}`);
}
sayHello();//輸出：Hello dude
sayHello('Wayou');//輸出：Hello Wayou
sayHello2();//輸出：Hello dude
sayHello2('Wayou');//輸出：Hello Wayou

不定參數是在函數中使用命名參數同時接收不定數量的未命名參數。這只是一種語法糖，在之前的JavaScript代碼中咱們能夠經過arguments變量來達到這一目的。不定參數的格式是三個句點後跟表明全部不定參數的變量名。好比下面這個例子中，…x表明了全部傳入add函數的參數。

//將全部參數相加的函數
function add(...x){
    return x.reduce((m,n)=>m+n);
}
//傳遞任意個數的參數
console.log(add(1,2,3));//輸出：6
console.log(add(1,2,3,4,5));//輸出：15

拓展參數則是另外一種形式的語法糖，它容許傳遞數組或者類數組直接作爲函數的參數而不用經過apply。

var people=['Wayou','John','Sherlock'];
//sayHello函數原本接收三個單獨的參數人妖，人二和人三
function sayHello(people1,people2,people3){
    console.log(`Hello ${people1},${people2},${people3}`);
}
//可是咱們將一個數組以拓展參數的形式傳遞，它能很好地映射到每一個單獨的參數
sayHello(...people);//輸出：Hello Wayou,John,Sherlock 

//而在之前，若是須要傳遞數組當參數，咱們須要使用函數的apply方法
sayHello.apply(null,people);//輸出：Hello Wayou,John,Sherlock