es6入门总结，几个简单的属性。

1. let
let用法基本跟var差不多，只是更加的严谨了。
不存在变量提升，变量要在声明后才能够使用。
不允许在相同作用域重复命名同一变量。

2. const
const 常量，定义后不能再改变，不能赋值，同样不能变量提升，不可重复声明。

3. 变量解构赋值
以前只能这样子写

function data(){
    var obj={
        a:1,
        b:2
    }
    return obj;
}
var aa=data();

es6可以这样写

function  data(){
    var a=1,b=2;
    return [a,b];
}
var [x,y]=data();
console.log(x);    //1
console.log(y);    //2

深度匹配

function setting(){
    return {display:{color:'red'},keyboard:{layout:‘querty’}};
}
const {display:{color: displayColor},keyboard:{layout:keyboardLayout}} = setting();
console.log(displayColor, keyboardLayout);    //red querty

4. 模板字符串
es5填充字符串需要这样

var a=1,b=2;
docuemnt.getElementById('test').appendChild('<b>'+a+'</b><b>'+b+'</b>');

这样的写法很不方便，也很难读懂。
es6可以这样写

let a=1,b=2;
docuemnt.getElementById('test').appendChild(`<b>${a}</b><b>${b}</b>`);

模板字符串是增强版字符串，用反引号（`）标记

5. Math对象的扩充
Math.trunc() 去掉小数部分
Math.sign() 判断一个数是正数，负数还是零

6.函数扩展

• 函数参数默认值
  可以设置默认值，eg：

function log(x,y='小明'){
    console.log(x,y);
}
log('hello');    //hello 小明
log('hello','xiaoming');    //hello xiaoming
log('nihao','');    //nihao

后来开发人员可以方便的调用你的函数

• rest参数，代替arguments，用途不大，写法（...变量名）
• 扩展运算符
  可代替apply方法

Math.max(null,[14,3,77]);

Math.max(...[14,3,7]);

Math.max(14,3,7)

三种写法运行效果相同。

7. 箭头函数

一个参数的写法

var f= v => v
//es5
var f=function(v){
    return v;
}

没有参数或者是多个参数

var f = () => 1
//es5
var f = function(){
    return 1;
}

var sum = (num1, num2) =>  num1 + num2;
//es5
var sum = function(num1, num2){
    return num1+num2;
}

一个参数其实也是可以加括号的，所以可以统一一下都加括号，就不用记那么多了

var f = (v) => v;

• => 函数使用说明：
  （1）函数体this是指定义时所在的对象，不是使用时所在对象。
  （2）不可以使用new命令，否则会抛出一个错误。
  （3）不可使用auguments对象，可以用rest参数代替。

8.类和对象
es5

var Animal=function(name){
    this.name=name;
}
animal.prototype={
    speak:function(){
        console.log("I am"+this.name);
    }
}
var animal = new Animal("cat");
animal.speak();  //I am cat

es6

class Animal(){
    constructor(name){
        this.name=name;
    }
    speak(){
        console.log("I am"+this.name);
    }
}
const animal=new Animal("cat");
animal.speak();    //I am cat

其实我并不觉得这个有很大作用，代码也不会缩少很多，只是适应后台java人员转成前端。不过对于继承却有比较大作用。

9.继承
es5

function A(){
    this.a='a';
}
function B(){
    this.b='b';
}
B.prototype=new A();

var b=new B();
b.a;        //a 
B.prototype.a='changed';
b.a;        //changed

es6

class A{
    constructor(){
        this.a='a';
    }
}
class B extends A{
    constructor(){
        super();
        this.b='b';
    }
}
var b=new B();
b.a;        //a

10.promise
用promise可以替代回调函数，不过这个现在用babel还是转不了。没多大用。
es5

function printAfterTimeout(string, timeout, done){
      setTimeout(function(){
            done(string);
      }, timeout);
}
printAfterTimeout('Hello ', 2e3, function(result){
      console.log(result);
      printAfterTimeout(result + 'Reader', 2e3, function(result){
            console.log(result);
      });
});

可以看到这样一环一环的进行下去是很恐怖的，也很难维护。
es6的写法是这样的。

function pat(string,timeout){
    var p = new Promise((resolve,reject) => {
        setTimeout(function(){
            resolve(string);
        },timeout);
    });
    return p;
}
pat('hello',1000).then( (result) => {
    console.log(result);    //hello
    return pat(result + '  小明',2000);
}).then( (result) => {
    console.log(result);      //hello 小明
})

这个比较难，说明一下：
var p = new promise(function(resolve,reject){});
主要是promise对象上有个then( fn1, fn2);
fn1对应的是resove就是执行成功的函数。
fn2对应的是reject就是执行失败的函数。
在ajax中就会运用到这两个东西。