Es6自我记录

对象扩展：Object.create（创建）
Object.defineproperties

call（thisArg,param1,param2…） 挨个传 立即调用
apply(thisArg,[param1,param2…]) 传的是数组 立即调用
bind(thisArg,param1,param2) 先返回，再加（）再调用
三者都可以改变this的指向，都是调用

var 用于函数 会提升变量 但也会污染变量 因为他定义的是全局变量
const 块级 const一旦声明变量，就必须立即初始化 可用于定义常量 即值不会变的
let 块级 不会初始化 定义局部变量

解构赋值（数组，对象）

for of循环
例子：

let arr1 = [1, 2, 3, 4, 5];
	for (let value of arr1) {
	    console.log(value);
	}

字符串的拼接：

var name = 'smyhvae';
    var age = '26';

    console.log('name:'+name+',age:'+age);   //传统写法

    console.log(`name:${name},age:${age}`);  //ES6 写法

箭头函数：
普通函数：

function fn1(a, b) {
    return a + b;
}
console.log(fn1(1, 2)); 

箭头函数：

var fn2=(a,b)=>(a+b);
 console.log(fn2(3,4))

扩展运算符：我们在定义一个方法，但是不确定其参数的个数时，我们就可以用扩展运算符作为参数。
扩展运算符会重新开辟新的内存地址

扩展运算符的格式为`...`
rest运算符的格式为`...变量名`

例子：

function fn(...arg) {   //当不确定方法的参数时，可以使用扩展运算符
    console.log(arg[0]);
    console.log(arg[1]);
    console.log(arg[2]);
    console.log(arg[3]);
}
fn(1, 2, 3);

promise对象：他是有三个状态

• 初始化状态（等待状态）：pending
• 成功状态：fullfilled
• 失败状态：rejected

    let promise = new Promise((resolve, reject) => {
        //进来之后，状态为pending
        console.log('111');  //这一行代码是同步的
        //开始执行异步操作（这里开始，写异步的代码，比如ajax请求 or 开启定时器）
        if (异步的ajax请求成功) {
            console.log('333');
            resolve();//如果请求成功了，请写resolve()，此时，promise的状态会被自动修改为fullfilled
        } else {
            reject();//如果请求失败了，请写reject()，此时，promise的状态会被自动修改为rejected
        }
    })
    console.log('222');

    //调用promise的then()
    promise.then(() => {
            //如果promise的状态为fullfilled，则执行这里的代码
            console.log('成功了');
        }
        , () => {
            //如果promise的状态为rejected，则执行这里的代码
            console.log('失败了');
        }
    )

栗子分析：
（1）当new Promise()执行之后，promise对象的状态会被初始化为pending，这个状态是初始化状态。new Promise()这行代码，括号里的内容是同步执行的。括号里定义一个function，function有两个参数：resolve和reject。如下：

• 如果请求成功了，请写resolve()，此时，promise的状态会被自动修改为fullfilled。

• 如果请求失败了，请写reject()，此时，promise的状态会被自动修改为rejected

（2）promise.then()方法，括号里面有两个参数，分别代表两个函数 function1 和 function2：

• 如果promise的状态为fullfilled（意思是：如果请求成功），则执行function1里的内容

• 如果promise的状态为rejected（意思是，如果请求失败），则执行function2里的内容

ajax请求举例：

    //定义一个请求news的方法
    function getNews(url) {
        //创建一个promise对象
        let promise = new Promise((resolve, reject) => {
            //初始化promise状态为pending
            //启动异步任务
            let request = new XMLHttpRequest();
            request.onreadystatechange = function () {
                if (request.readyState === 4) {
                    if (request.status === 200) {
                        let news = request.;
                        resolve(news);
                    } else {
                        reject('请求失败了。。。');
                    }
                }
            };
            request.responseType = 'json';//设置返回的数据类型
            request.open("GET", url);//规定请求的方法，创建链接
            request.send();//发送
        })
        return promise;
    }

    getNews('http://localhost:3000/news?id=2')
        .then((news) => {
            console.log(news);
            document.write(JSON.stringify(news));
            console.log('http://localhost:3000' + news.commentsUrl);
            return getNews('http://localhost:3000' + news.commentsUrl);
        }, (error) => {
            alert(error);
        })
        .then((comments) => {
            console.log(comments);
            document.write('<br><br><br><br><br>' + JSON.stringify(comments));
        }, (error) => {
            alert(error);
        })

try catch finally三者区别：

try {
           //可能出现异常的部分
        } catch (Exception e) {
           //捕获到的异常处理
        }finally {
           //不管有没有出现异常，都会执行的部分
        }

set和map方法:
在ES6中，集合类型有Set和Map，Set类型没有键值对，且不能出现重复的元素；Map类是以键值对形式展示，键不能重复，但是值可以重复。Set添加元素使用add()，Map使用set()；Set和Map删除元素都是使用delete()，判断元素是否在集合中都是使用has()，
map其实相当于是一个对象，是键值对的存储形式，用到对象的时候就可以用map的时候就可以了
set是去重复的。就是这个集合里不要有重复的用set，
set和map都是可迭代的对象