ES6新语法

let/const

let不存在变量提升(变量不允许在声明之前使用)
let不允许重复声明
在全局作用域中let变量不是window属性，和它没关系
typeof 未被声明的变量不是undefined而是报错(暂时性死区)
let会形成块级作用域

解构赋值

按照一个数据结构，快速解析获取到其中的内容（一般是数组和对象）

数组的解构赋值

let ary=[1,2,3];
let [a,b,c,d=0,e]=ary;
console.log(a, b, c, d);//1,2,3,0,undefined

对象的解构赋值

let obj={name:'xxx',age:25,sex:0};
let {age:ageAA}=obj;//给解构的属性名起别名作为变量
console.log(age);//报错
console.log(ageAA);//25

...拓展、展开、剩余运算符

let ary=[1,2,3]
Math.max(...arg);//=>3
let ary1=[...arguments];//=>类数组转数组

箭头函数

x => (x,y) => x+y;
//相当于
function (x) {
    return function (x,y){
         return x * x;
    }
}

没有arguments（可以基于...arg获取实参集合）
没有自己的this，this是继承上下文中的this，箭头函数this不能被改变

``模板字符串

${}大括号内可以放入任意的JavaScript表达式。
模板字符串之间可以进行嵌套

标签模板

var a = 5, b = 10;
 
function tag(strings, ...values) {
    console.log(strings[0]);    // "Hello "
    console.log(strings[1]);    // " world"
    console.log(strings[2]);    // ""
    console.log(values[0]);     // 15
    console.log(values[1]);     // 50
 
    return "Anything";
}
 
tag`Hello ${a + b} world ${a * b}`;
//=>tag(['Hello ',' world', ''], 3, 2);

Promise(async/await)

Promise是ES6中新增加的内置类：目的是为了管理异步操作的

1.new Promise() 创建类的一个实例，每一个实例都可以管理一个异步操作

->必须传递一个回调函数进去（回调函数中管理你的异步操作）,不传递会报错

->回调函数中会有两个参数

resolve：异步操作成功做的事情（代指成功后的事件队列 =>成功后要做的所有的事情都存放到成功这个事件队列中）

reject：异步操作失败做的事情（代指失败后的事件队列）

->new Promise的时候立即把回调函数执行了（Promise是同步的）

2.基于Promise.prototype.then方法（还有catch/finally两个方法）向成功队列和失败队列中依次加入需要处理的事情

3.如果是多个THEN掉用，不是像我们想象的依次把增加的方法执行

异步操作成功或者失败，先把第一个THEN中的方法执行，每当执行一个THEN会返回一个新的Promise实例，这个实例管控的是第一个THEN中方法执行的是成功还是失败

//=>建议不要使用THEN中的第二个参数（这样看起来很乱），而是建议我们使用Promise.prototype.catch来管理失败的情况
let promise1 = new Promise((resolve, reject) => {
    $.ajax({
        url: 'json/data2.json',
        success(result) {
            resolve(result);
        },
        error(msg) {
            reject('no');
        }
    });
});
promise1.then(result => {
    console.log('THEN1 OK', result);
    100();
    return 100;
}).catch(msg => {
    //=>第一个CATCH
    //1.异步请求失败会执行它
    //2.第一个THEN方法失败也会执行它
    console.log('CATCH1', msg);
}).then(result => {
    console.log('THEN2 OK', result);
}).catch(msg => {
    console.log('CATCH2', msg);
});
//结果是CATCH1 THEN2 OK
/***************************************************/
let A = function A() {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve();
        }, 1000);
    });
};

let B = function B() {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve();
        }, 1000);
    });
};

let promise = A();
promise.then(() => {
    console.log(1);
    return B();//=>如果方法中返回的一个具体值，而且执行中没有错误异常，会立即执行下一个THEN中的方法（不写RETURN也是返回的了具体值：undefined），但是如果返回的是一个PROMISR实例（并且管控了一个异步操作），只能等PROMISE完成，把成功后的结果当做具体的值返回，才能进入下一个函数执行
}).then(() => {
    console.log(2);
});

4.利用promise解决jquery中ajax请求回调地狱的问题

let queryA = function queryA() {
        return new Promise(resolve => {
            $.ajax({
                url: 'https://www.easy-mock.com/mock/5b0412beda8a195fb0978627/temp/list',
                success: resolve
            });
        });
    };

    let queryB = function queryB() {
        return new Promise(resolve => {
            $.ajax({
                url: 'https://www.easy-mock.com/mock/5b0412beda8a195fb0978627/temp/info',
                success: resolve
            });
        });
    };

    let queryC = function queryC() {
        return new Promise(resolve => {
            $.ajax({
                url: 'https://www.easy-mock.com/mock/5b0412beda8a195fb0978627/temp/add',
                method: 'POST',
                success: resolve
            });
        });
    };

    let promise = queryA();
    promise.then(result => {
        console.log('A', result);
        return queryB();//=>上一个THEN中函数手动返回一个新的PROMISE实例(管控了一个异步操作)，下一个THEN会等上一个THEN中的异步成功后在执行
    }).then(result => {
        console.log('B', result);
        return queryC();
    }).then(result => {
        console.log('C', result);
    });

class(ES6中创建类的)

class A{
    constructor(){//构造函数 
    }
    a(){//定义在A原型上的方法
    }
}

interator(for of循环)

Map/Set

Map

创建Map实例：let map=new Map(/*[key,value],*/[[true,true],[{},{}],[[],[]],[null,null]]);

下面是Map实例的常用方法

set(key,value) 返回当前Map

get(key) 返回对应的value

has(key) 判断有没有返回true/false

clear

delete

forEach

map.forEach((value,key)=>{
    });

keys 得到所有key的Iterator接口

values 得到所有values的Iterator接口

entries 得到所有key和value的Iterator接口

Set

创建Set实例let set=new Set(/*Array()*/[1,2,3]);

下面是Set实例的常用方法

add 参数1个返回当前Set

delete 删除返回true/false

has 判断有没有返回true/false

clear 清空Set 无返回值

size 返回Set大小

forEach Set不能遍历索引