1.ES6介绍
　　    1) ES5的升级
　　    2) 提供了简介的语法和新特性
　　        迭代器
　　        Map,Set
　　        箭头函数
　　        Promise
　　        Generator
　　        ……
　　    3) ES6在浏览器上的兼容性差些，而Node.js环境对ES6支持度更高，如果想要将ES6运行在浏览器上，那么我们需要将ES6转换成ES5
　　        问题：怎么将ES6转换成ES5
　　            使用Babel
　　
　　            怎么下载Babel
　　                使用包管理工具
　　                    npm
　　                    cnpm
　　                    yarn 
　　
　　2.包管理工具
　　    1) npm     
　　        nodejs自带，无需下载
　　        1. 查看版本号
　　            > node -v
　　            > npm -v
　　        2. 初始化node模块
　　            > npm init
　　            或者
　　            > npm init -y
　　        3. 安装第三方模块
　　            全局安装
　　                > npm install -g <package_name>
　　                1) 下载
　　                    > npm install -g jquery
　　                        在任意目录下执行该命令，都是全局安装
　　                2) 卸载
　　                    > npm uninstall -g jquery
　　                    该方式可能无法删除第三方包，此时手动删除node_modules即可
　　            局部安装
　　                > npm install moment
　　                > npm install moment --sava
　　                注意：默认将第三方依赖安装到当前目录的node_modules中,将这个依赖信息添加到package.json中的dependencies中（dependencies中的依赖为产品依赖，项目上线后依然需要的依赖）
　　                
　　                > npm install moment --sava-dev
　　                devDependencies是开发依赖，仅在项目开发阶段需要的依赖
　　
　　    2) cnpm 
　　        npm的淘宝镜像
　　        1、cnpm的安装
　　            参考网址：
　　                https://developer.aliyun.com/mirror/NPM?from=tnpm
　　            下载：    
　　                > npm install -g cnpm --registry=https://registry.npm.taobao.org
　　        2、cnpm的使用
　　            > cnpm -v
　　            安装所有依赖包
　　                > cnpm install  
　　            安装moment
　　                > cnpm install moment
　　                > cnpm install -g moment
　　            卸载依赖moment
　　                > cnpm uninstall moment
　　                > cnpm uninstall -g moment
　　
　　    3) yarn
　　        1、yarn的安装
　　            > npm install -g yarn
　　        2、yarn的使用
　　            安装所有依赖包
　　                > yarn
　　                > yarn install
　　            安装moment
　　                > yarn add moment
　　            卸载依赖moment
　　                > yarn remove moment
　　            
　　3.安装babel
　　    0) babel作用？
　　        将es6 -> es5
　　    
　　    1) 全局安装
　　        1、安装babel
　　            > cnpm install -g babel-cli
　　        
　　        2、安装预设(说明转换规则)
　　            > cnpm install --save-dev babel-preset-latest
　　            > cnpm install --sava-dev babel-preset-es2015
　　        
　　        3、创建配置文件
　　            .babelrc
　　            {
　　                "presets":"latest"
　　            }
　　        
　　        4、新建js文件 src/a.js
　　            1) 将a.js文件中es6代码转换为es5,并将转换结果打印在控制台
　　                > babel a.js
　　            2) 将a.js文件中es6语法转换为es5,并将转换结果放在b.js中
　　                > babel a.js --out-file b.js
　　            3) 将src目录(es6语法)中的文件转码，转成dist目录(es5语法)【类似于vue项目的打包】
　　                > babel src --out-dir dist
　　
　　    2) 局部安装
　　        1、新建文件夹app01
　　        2、进入app01，并初始化模块
　　            > cd app01
　　            > npm init  （所有询问都直接回车即可）创建出一个package.json文件[项目的配置文件]
　　            或者
　　            > npm init -y  快速初始化，没有询问
　　
　　        3、本地安装babel
　　            > cnpm install --save babel-cli  产品依赖【项目上线后仍需要的依赖】
　　            > cnpm install --save-dev babel-cli  开发依赖【仅在开发阶段需要的依赖】
　　        
　　        4、安装预设（说明转换规则）
　　            > cnpm install --save-dev babel-preset-latest
　　        
　　        5、添加配置文件
　　            .babelrc
　　            {
　　                "prestes":["latest"]
　　            }
　　        
　　        6、新建src/a.js,并在a.js中编写es6语法代码
　　        
　　        7、转码操作
　　            1) 将a.js转码，打印到控制台
　　                > babel a.js
　　
　　            2) 将a.js转码，转码后代码存到b.js中
　　                > babel a.js --out-file b.js
　　            
　　            3) 将src目录中所有文件进行转码，另存为dist
　　                > babel src --out-dir dist
　　            
　　            拓展：
　　                可以使用npm run 命令进行转码操作
　　                方法：
　　                    在package.json文件的script中添加
　　                    "build":"babel src --out-dir dist"
　　                使用：
　　                    npm run build
　　            
　　            注意：当我们将项目上传到gitee上时，不要把node_modeules一起上传，应当将node_modeules删掉，然后上传；所以当我们从gitee上克隆下来项目的时候，需要重新安装依赖
　　                > cnpm install
　　
　　4.模块化
　　    1) es5中模块化
　　        1、第三方插件
　　            1、安装依赖包
　　                npm install moment
　　            2、导入
　　                var moment = require('moment') [第三方插件]
　　            3、使用
　　                var date = new Date();
　　                console.log(moment(date).formate('YYYY-MM-DD'))
　　        2、本地文件
　　            1、导入
　　                var test = require("./a")   [文件]
　　            2、使用
　　                console.log(test)
　　
　　    2) es6模块化[文件]
　　        注意：nodejs 13.X之前不支持模块化
　　        导出  export / export default
　　        导入  import
　　
　　        1.基本导入导出
　　            src/a.js
　　                let a = 1;
　　                console.log(a)
　　                let foo = () => {
　　                    console.log(2)
　　                }
　　                export {a,foo}
　　            src/b.js
　　                import {a,foo} from './a'
　　                console.log(a,foo)
　　            =>
　　            将src转换为es5语法
　　                > babel src --out-dir dist
　　            =>
　　            > node dist/b.js
　　
　　        2.重命名
　　            src/a.js
　　                let a = 1;
　　                console.log(a)
　　                let foo = () => {
　　                    console.log(2)
　　                }
　　                export {a,foo}
　　            src/b.js
　　                import {a as aa,foo as foo1} from './a'
　　                console.log(aa,foo1)
　　            =>
　　            将src转换为es5语法
　　                > babel src --out-dir dist
　　            =>
　　            > node dist/b.js
　　  
　　        3.全部导入
　　            src/a.js
　　                let a = 1;
　　                console.log(a)
　　                let foo = () => {
　　                    console.log(2)
　　                }
　　                export {a,foo}
　　            src/b.js
　　                import {* as aa} from './a'
　　                console.log(aa)
　　                console.log(aa.a)
　　                console.log(aa.foo)
　　            =>
　　            将src转换为es5语法
　　                > babel src --out-dir dist
　　            =>
　　            > node dist/b.js
　　
　　        4. 默认导出
　　            export default 值
　　            a.js
　　                function get(){
　　                    console.log('调用了get发送请求')
　　                }
　　                function post(){
　　                    console.log('调用了post发送请求')
　　                }
　　                export default {
　　                    get:get,
　　                    post:post
　　                }
　　
　　            b.js
　　                import test from './1-module1.js'
　　                let b = 'hello ES6';
　　                test.get()
　　                test.post()
　　            
　　        5. export 与 export default的区别
　　            export {}
　　                1. 可以在同一个文件中导出多次
　　                    export {a}
　　                    export {b}
　　                    ==>等价于
　　                    export {a,b}
　　                2. 在导入的时候变量名必须和导出时一致
　　
　　            export default {}
　　                1. {}是一个空对象
　　                2. 在同一个文件中只能导出一次
　　                3. 导入时可以使用任意的变量接收
　　
　　5.变量声明
　　    es5
　　        var 
　　            1) var 声明的变量会挂载在window上，是全局变量，没有块级作用域
　　            2) var 变量声明可以提升
　　            3) var 变量可以重复声明
　　
　　    es6
　　        let 
　　            1) let 声明的变量是局部变量，拥有块级作用域
　　                测试：
　　                    if(true) {
　　                        let a = 1
　　                    }
　　                    console.log(a) //报错
　　            2) let 变量声明不可以提升
　　                测试：
　　                    console.log(a)
　　                    let a = 1
　　            3) let 变量不可以重复声明
　　                测试：
　　                    let a = 1
　　                    let a = 2
　　                    console.log(a)
　　        
　　        const
　　            1) const 声明一个常量，拥有块级作用域，只能在当前代码块中使用
　　                测试：
　　                    if(true) {
　　                        const a = "hello"
　　                    }
　　                    console.log(a)
　　            2) const 常量声明不可以提升
　　                测试：
　　                    console.log(a)
　　                    const a = "hello"
　　            3) const 常量不可以重复声明
　　                测试：
　　                    const a = "hello"
　　                    const a = 1
　　                    console.log(a)
　　            4) const 常量声明和初始化必须同时进行
　　                测试：
　　                    const a
　　                    a = 1
　　                    console.log(a)
　　
　　6.解构
　　    解构的本质属于"模式匹配"，只要等号两边的模式相同，右边的值就会被赋予左边的变量。es6按照一定的模式，从数组和对象中提取值，对等号左边的变量进行赋值，叫做解构。如果解构不成功，变量的值等于undefined
　　
　　    1) 数组解构
　　        等号两边模式按照顺序依次匹配
　　        1、等号左边的模式等于右边
　　            let [a,b,c] = [1,2,[3,4]]
　　            console.log(a,b,c)    // 1 2 [ 3, 4 ]
　　            或者
　　            let [a,b,[c]] = [1,2,[3,4]]
　　            console.log(a,b,c)      // 1 2 3
　　            或者
　　            let [,,age] = ['小李','男',13]
　　            console.log(,,age)
　　        
　　        2、等号左边模式小于右边
　　            let [gender] = ['小李','男',13]
　　            console.log(gender)
　　            
　　        3、等号左边模式大于右边
　　            let [name,gender] = ['小李']
　　            console.log(name,gender)  //小李 undefiend
　　        
　　        4、等号两边模式不匹配
　　            let [gender] = 'hello';
　　            console.log(gender);    // h
　　
　　            let [gender] = true;
　　            console.log(gender);    //true is not iterable
　　        
　　        5) 数组解构默认值
　　            let [a=1] = []
　　            console.log(a)  //1
　　
　　            let [a=1] = [2]
　　            console.log(a)  //2
　　
　　            注意：
　　                1.只有当数组对应位置上的值为undefined时，默认值才会生效
　　                    let [a=1] = ['undefiend']
　　                    console.log(a)  //undefiend
　　                    
　　                    let [a=1] = [undefiend]
　　                    console.log(a)  //1
　　                
　　                2、默认值可以引用解构赋值的其他变量，但是这个变量必须已经声明过，否则会报错
　　                    let [name,age,gender=name] = ['tom',25];
　　                    console.log(name,age,gender); // tom 25 tom
　　
　　                    let [name='tom',name2=name] = [];
　　                    console.log(name,name2); // tom tom
　　
　　                    let [name=name2,name2='tom'] = [];
　　                    console.log(name,name2); // 报错，name2未定义，无法在初始化之前访问到name2
　　
　　    2) 对象解构
　　        var obj = {
　　            name:'tom',
　　            age:25,
　　            gender:'male'
　　        }
　　        1.在等号右边找到跟左边变量同名的属性名，将右边属性值赋给左侧变量
　　            let {name,age,gender} = obj;
　　            console.log(name,age,gender)  //tom age male
　　            或者
　　            let {age,name,gender} = obj;
　　            console.log(name,age,gender)  //tom age male
　　
　　        2.变量与属性名不同名
　　            let {age,name,address} = obj;
　　            console.log(name,age,address)  //tom age undefined
　　
　　        3.对象解构的内部机制[采用了对象的简写形式]
　　            let {name,age,gender:address} = obj;
　　            console.log(name,age,address); // tom 25 male
　　            ==>等价于
　　            let {name:name,age:age,gender:address} = obj;
　　            console.log(name,age,address); // tom 25 male
　　            
　　            let {name:name,age:age,gender:address} = obj;
　　            console.log(name,age,gender); // 报错，gender is not defined
　　
　　        4.对象默认解构
　　            当对象的属性值为undefined时，默认值才生效
　　            var obj = {
　　                name:'tom',
　　                age:25,
　　            }
　　            let {name,age,gender='male'} = obj
　　            console.log(name,age,gender)    // tom 25 male
　　            =>等价于
　　            var obj = {
　　                name:'tom',
　　                age:25,
　　                gender:undefined
　　            }
　　            let {name,age,gender='male'} = obj;
　　            console.log(name,age,gender); // tom 25 male
　　
　　    3) 字符串解构
　　        let [a,b,c] = 'today'
　　        console.log(a,b,c)  //t o d
　　
　　        let {length:len} = 'today'
　　        console.log(len)  //5
　　
　　    4) 数值，布尔类型解构
　　        可以获到包装器构造函数原型中指定的方法
　　        let {valueOf} = 12
　　        console.log(valueOf)
　　
　　        let {valueOf} = true
　　        console.log(valueOf)
　　    
　　7.对象扩展
　　    es6允许将变量和函数直接写在对象中，作为对象的属性和方法
　　    1) 对象属性和方法的简写
　　        es5中
　　            var name = "znn"
　　            var obj = {
　　                name:name,
　　                foo:function() {
　　                    console.log("my name is "+name)
　　                },
　　            }
　　            obj.foo()    //my name is znn
　　        
　　        es6中
　　            var name = "znn"
　　            var obj = {
　　                name,
　　                foo() {
　　                    console.log("my name is "+name)
　　                },
　　            }
　　            obj.foo()    //my name is znn
　　    2) 对象API的扩展(静态方法)
　　        1. Object.is(value1,value2)
　　            判断两个值是否相等
　　            测试：
　　                var res1 = Object.is(1,1);
　　                var res2 = Object.is(1,'1');
　　                var res3 = Object.is('1','1');
　　                var res4 = Object.is({},{});
　　                var res5 = Object.is(+0,-0);
　　                var res6 = Object.is(NaN,NaN);
　　
　　                console.log(res1); // true
　　                console.log(res2); // false
　　                console.log(res3); // true
　　                console.log(res4); // false
　　                console.log(res5); // false
　　                console.log(res6); // true
　　            
　　        2. Object.assign(target,source1,source2...)
　　            将所有可枚举属性从一个或多个源对象中复制到目标对象中，并返回目标对象
　　            可枚举属性：一般指的是用户自己写的属性，不包括继承的
　　            源对象：source1,source2...
　　            目标对象：target
　　            测试：
　　                1.合并对象
　　                    let obj1 = {
　　                        id:1
　　                    }
　　                    let obj2 = {
　　                        name:'xiaoli'
　　                    }
　　                    let obj = Object.assign(obj1,obj2);
　　                    console.log('obj',obj); // { id: 1, name: 'xiaoli'}
　　                    console.log('obj1',obj1); // { id: 1, name: 'xiaoli'}
　　                    注意：当合并的对象具有相同的属性名时，属性会被源对象当中具有相同属性名的值覆盖掉
　　
　　                2.克隆对象
　　                    let obj1 = {
　　                        name:'tom',
　　                        age:13,
　　                        gender:'male'
　　                    }
　　
　　                    let obj = Object.assign({},obj1);
　　
　　                    console.log(obj); // { name: 'tom', age: 13, gender: 'male' }
　　                    console.log(obj1); // { name: 'tom', age: 13, gender: 'male' }
　　                    console.log(obj == obj1); // false
　　
　　        3. Object.setPrototypeOf(obj,prototype)
　　            将一个对象的原型设置到另一个对象obj中去
　　            var obj1 = {
　　                name:'tom',
　　                age:13
　　            }
　　            obj1.__proto__.test = function(){
　　                console.log(111)
　　            }
　　            var obj2 = {}
　　
　　            Object.setPrototypeOf(obj2,obj1.__proto__)
　　            console.log(obj2.__proto__)
　　
　　        4. Object.getPrototypeOf(obj)
　　            获取一个对象的原型
　　        
　　        5. Object.keys(obj)
　　            键
　　            返回一个对象obj的可枚举属性名组成的数组
　　        6. Object.values(obj)
　　            值
　　            返回一个对象obj的可枚举属性值组成的数组
　　        7. Object.entries(obj)
　　            键值对
　　            返回一个对象obj的可枚举属性的键值对数组
　　        
　　            let obj = {
　　                name:'tom',
　　                age:13
　　            }
　　
　　            console.log(Object.keys(obj)); // [ 'name', 'age' ]
　　            console.log(Object.values(obj)); // [ 'tom', 13 ]
　　            console.log(Object.entries(obj)); // [ [ 'name', 'tom' ], [ 'age', 13 ] ]
　　
　　8.数组扩展
　　    1) 拓展运算符
　　        将值数组或对象中取出
　　        let arr1 = [1,2]
　　        let arr2 = [3,4]
　　        let arr = [...arr1,...arr2]
　　        console.log(arr)  //[1,2,3,4]
　　
　　        let obj1 = {
　　            name:"tom"
　　        }
　　        let obj2 = {
　　            age:"12"
　　        }
　　        let obj = {...obj1,...obj2}
　　        console.log(obj)    //{ name: 'tom', age: '12' }
　　    
　　    2) 数组API 
　　        1.Array.from(v)
　　            将类数组对象以及可遍历对象转换为数组
　　            类数组对象：
　　                测试：
　　                    let arr_like = {
　　                        0:"1",
　　                        1:"2",
　　                        2:"3",
　　                        length:3
　　                    }
　　                    console.log(Array.from(arr_like))  //[ '1', '2', '3' ]
　　            可遍历对象
　　                Array、String、Map、Set、函数的arguments
　　                测试：
　　                    let arr_like = 'hello'
　　                    console.log(Array.from(arr_like)) //[ 'h', 'e', 'l', 'l', 'o' ]
　　
　　            注意：如果v是一个数组，那么Array.from将返回一个一模一样的新数组
　　        
　　        2.Array.of(v)
　　            将参数v转换为数组
　　            测试：
　　                let arr3 = Array.of(1,3); // [1,3]
　　                let arr4 = Array.of(3); // [3]
　　                let arr5 = Array.of('hello')
　　            
　　        3.Array.prototype.find()
　　            返回满足条件的第一个元素，如果没有满足条件的元素时，返回undefined
　　            参数：箭头函数
　　            let arr = [1,2,3,4,5,6]
　　            let res = arr.find(item=>{
　　                return item > 3
　　            })
　　            console.log(res)
　　
　　        4.Array.prototype.findIndex()
　　            返回第一个满足条件的元素的索引，如果没有满足条件的元素，返回-1
　　            let arr = [1,2,3,4,5,6]
　　            let res = arr.findIndex(item=>{
　　                return item > 3
　　            })
　　            console.log(res)
　　        
　　        5. fill()
　　            Array.prototype.fill()
　　            使用给定值，填充数组
　　
　　            一个参数
　　                let arr = [1,2,3,4,5,6]
　　                let res = arr.fill(4)
　　                console.log(res) // [ 4, 4, 4, 4, 4, 4 ]
　　                数组中原本已存在的元素，会被全部替换掉
　　
　　            三个参数
　　                第一个参数 ：填充的数
　　                第二个参数 ：填充的起始位置
　　                第三个参数 ：填充的结束位置(不包含)
　　                let arr = [1,2,3,4,5,6]
　　                let res = arr.fill(8,2,5)
　　                console.log(res) // [ 1, 2, 8, 8, 8, 6 ]
　　
　　            注意：
　　                1、如果被填充的数组为空，被填充后仍然是空数组
　　                    let arr = [];
　　                    arr.fill(1);
　　                    console.log(arr); // []
　　                2、如果填充的为对象，被赋值的只是同一个内存的指针
　　                    let arr = new Array(3);
　　                    arr.fill({name:'larry'});
　　                    console.log(arr); // [ { name: 'larry' }, { name: 'larry' }, { name: 'larry' } ]
　　                    arr[0].name = 'tom';
　　                    console.log(arr); // [ { name: 'tom' }, { name: 'tom' }, { name: 'tom' } ]
　　
　　        6. keys、values、entries
　　            这三个方法都用于数组的遍历，返回的都是一个遍历器对象(迭代器对象)，该遍历器对象可用于for-of循环
　　            Array.prototype.keys()
　　                对键名的遍历
　　            Array.prototype.values()
　　                对键值的遍历
　　            Array.prototype.entries()
　　                对键值对的遍历
　　
　　            let arr = ['tom','larry','jack'];
　　            console.log(arr.keys()); // Object [Array Iterator] {}
　　            console.log(arr.values()); // Object [Array Iterator] {}
　　            console.log(arr.entries()); // Object [Array Iterator] {}
　　
　　9.函数扩展
　　    1) 函数简写
　　        1、函数声明在对象中
　　            let obj = {
　　                foo() {
　　                    console.log(1)
　　                }
　　            }
　　            obj.foo()
　　        
　　        2、函数作为参数
　　            es6中允许使用箭头函数
　　                function() {}
　　                =>
　　                ()=>{}
　　            
　　            let foo1 = function(item) {
　　                return item
　　            }
　　
　　            let foo2 = (item) => {return item} 
　　            console.log(foo1(1))
　　            console.log(foo2(1))
　　
　　            箭头函数可以根据参数个数来省略()，可以根据函数体内部代码的行数来省略{}
　　                一个参数时，可以省略()
　　                    item => {}
　　                不要参数或者多个参数时，不可以省略()
　　                    () => {}
　　                    (item,index) => {}
　　
　　                函数体内部只有一行代码的时候，可以省略{}
　　                多行代码时，不可以省略{}
　　            案例一：
　　                let arr = [{
　　                    name:'jack',
　　                    gender:'male'
　　                },{
　　                    name:'tom',
　　                    gender:'male'
　　                },{
　　                    name:'xiaohong',
　　                    gender:'female'
　　                }]
　　
　　                let res1 = arr.filter(function(item){
　　                    return item.gender == 'female';
　　                })
　　
　　                let res2 = arr.filter( (item)=>{
　　                    return item.gender == 'female';
　　                } )
　　                console.log(res1);
　　                console.log(res2);
　　
　　            案例二：
　　                    let obj = {name:'jack',age:25,
　　                        sayName:()=>{
　　                            console.log(this.name);
　　                        },
　　                        sayAge:function(){
　　                            console.log(this.age);
　　                        }
　　                    }
　　                obj.sayName(); // undefined
　　                obj.sayAge(); // 25
　　
　　                注意：箭头函数中的this指向该箭头函数的外部函数
　　                    如果箭头函数外部没有函数，那么这个this就指向全局对象
　　
　　            案例三：
　　                let obj = {
　　                    list:[1,2,3,4],
　　                    add(){
　　                        this.list.forEach(function(){
　　                            console.log(this.list); // undefined
　　                        })
　　                    }
　　                }
　　                obj.add();
　　
　　                解决方案一：手动更改this
　　                    let obj = {
　　                        list:[1,2,3,4],
　　                        add(){
　　                            var that = this;
　　                            this.list.forEach(function(){
　　                                console.log(that.list)
　　                            })
　　                        }
　　                    }
　　                    obj.add();
　　
　　                解决方案二：使用箭头函数
　　                    let obj = {
　　                        list:[1,2,3,4],
　　                        add(){
　　                            this.list.forEach(()=>{
　　                                console.log(this.list)
　　                            })
　　                        }
　　                    }
　　                    obj.add();
　　
　　                    箭头函数的this先指向了外部的add函数，由于add函数被obj对象调用，所有add方法中的this指向了obj
　　                    最终，箭头函数中的this指向了obj
　　
　　    2) 函数rest参数
　　        把值放到数组中
　　        function sayName(...obj){
　　            obj // [1,2,3]
　　            console.log(obj)
　　            //  console.log(arguments)
　　        }
　　        sayName(1,2,3)
　　
　　10.Set集合
　　    类似于数组，但是每个成员值都是唯一的，不可以重复
　　    1) 定义方式，Set构造函数
　　        let set = new Set()
　　        console.log(set)  //Set {},但在浏览器中是Set []
　　    
　　    2) 初始化
　　        Set构造函数的参数必须为可遍历的对象
　　        let set = new Set([1,2,3])
　　        console.log(set)  //Set { 1, 2, 3 }
　　
　　        let set = new Set('hello')
　　        console.log(set)  //Set { 'h', 'e', 'l', 'o' }
　　
　　        function foo() {
　　            let set = new Set(arguments)
　　            console.log(set)
　　        }
　　        foo(1,2)   //Set { 1, 2 }
　　
　　    3) 特点
　　        1.Set构造函数的参数必须为可遍历的对象
　　        2.Set集合的值不会有重复
　　            let set = new Set([1,2,2,3,4,4,5,5,5])
　　            console.log(set)    //Set { 1, 2, 3, 4, 5 }
　　    
　　    4) Set API
　　        1、Set实例的属性
　　            Set.prototype.size
　　                返回Set集合所有成员的总数
　　                举例：
　　                    let set = new Set([1,2,3,4])
　　                    console.log(set.size)   //4
　　
　　        2、Set实例的方法
　　            Set.prototype.add(value)
　　                向Set集合添加某个值，返回添加后的Set集合
　　                举例：
　　                    let set = new Set([1,2,3,4])
　　                    console.log(set.add(6)) //Set { 1, 2, 3, 4, 6 }
　　
　　            Set.prototype.delete(value)
　　                从Set集合中删除某个值，返回值为true/flase,改变原Set集合的值
　　                测试：
　　                    let set = new Set([1,2,3,4])
　　                    console.log(set.delete(3))  //true
　　                    console.log(set)  //Set { 1, 2, 4 }
　　                    console.log(set.delete(6))  //false
　　
　　            Set.prototype.has(value)
　　                检测某个值是否属于Set集合，属于返回true，否则返回false
　　                测试：
　　                    let set = new Set([1,2,3,4])
　　                    console.log(set.has(3))  //true
　　
　　            Set.prototype.clear()
　　                清空Set集合中的所有成员
　　                测试：
　　                    let set = new Set([1,2,3,4])
　　                    console.log(set.clear())  //undefined
　　                    console.log(set)     // Set{}
　　
　　            Set.prototype.keys()
　　                对键名的遍历
　　            Set.prototype.values()
　　                对键值的遍历
　　            Set.prototype.entries()
　　                对键值对的遍历  
　　            注意：Set集合中没有键名，只有键值（键名键值是同行一个值），所以keys()和values()方法完全一致
　　                let set = new Set([1,2,3,4])
　　                console.log(set.keys()) //[Set Iterator] { 1, 2, 3, 4 }
　　                console.log(set.values()) //[Set Iterator] { 1, 2, 3, 4 }
　　                console.log(set.entries())
　　                // [Set Entries] { [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ] }
　　            
　　            Set.prototype.forEach()
　　                使用回调函数遍历每个成员
　　                测试：
　　                    let set = new Set([1,2,3,4])
　　                    set.forEach((item) => {
　　                        console.log(item)   //1 2 3 4
　　                    })
　　
　　11.Map集合
　　    Map类似于对象，也是键值对的集合。Object中的键值对只能以字符串-值的形式出现，而Map集和的键值对以值-值的形式出现。
　　    1) 定义方式，Map构造函数
　　        let map = new Map()
　　        console.log(map)   //  Map {}
　　
　　    2) 初始化
　　        接受一个数组作为参数，该数组的每个成员表示一个个的键值对数组
　　        let map = new Map([['name','tom'],['age','12']])
　　        console.log(map)  //Map { 'name' => 'tom', 'age' => '12' }
　　
　　    3)Map API
　　        1.Map集合属性
　　            Map.prototype.size  
　　            返回Map集合所有成员的总数
　　            let map = new Map([['name','tom'],['age','12']])
　　            console.log(map.size)  // 2
　　
　　        2.Map集合方法
　　            Map.prototype.set(key,value)
　　                设置键值对，key为键，value为值，返回Map集合
　　                举例：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.set('gender','male'))  
　　                    //Map { 'name' => 'tom', 'age' => '12', 'gender' => 'male' }
　　
　　                    注意：如果键名已存在，则键值会更新，否则就会就会生成新的键
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.set('name','jack'))
　　                    //Map { 'name' => 'jack', 'age' => '12' }
　　            
　　            Map.prototype.get(key)
　　                获取key对应的键值，如果没有就返回undefined
　　                举例：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.get('name')) //tom
　　            
　　            Map.prototype.has(key)
　　                表示某个键是否属于Map集合，属于时返回true
　　                举例：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.has('name'))  //true
　　            
　　            Map.prototype.delete(key)
　　                删除某个键，删除成功时返回true
　　                测试：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.delete('name'))   //true
　　                    console.log(map)        // Map { 'age' => '12' }
　　
　　            Map.prototype.clear()
　　                清空Map集合
　　                测试：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.clear())   //undefiend
　　                    console.log(map)        // Map{}
　　            
　　            Map.prototype.keys()
　　                举例：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.keys())  //[Map Iterator] { 'name', 'age' }
　　            Map.prototype.values()
　　                举例：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.values())   //[Map Iterator] { 'tom', '12' }
　　            Map.prototype.entries()
　　                举例：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    console.log(map.entries())
　　                    // [Map Entries] { [ 'name', 'tom' ], [ 'age', '12' ] }
　　            
　　            Map.prototype.forEach()
　　                遍历Map集合中的所有成员值
　　                测试：
　　                    let map = new Map([['name','tom'],['age','12']])
　　                    map.forEach(item => {
　　                        console.log(item)  //tom 12
　　                    })
　　
　　12.Iterator
　　    1) 介绍
　　        遍历器是一种接口，为不同的数据类型提供统一的访问机制，不管什么数据类型只要部署了Iterator接口，都可以完成遍历操作。
　　    
　　    2) 作用
　　        1. 为各种数据结构，提供统一的访问接口
　　        2. 使得各种数据结构成员能够按照某种次序排列
　　        3. Iterator接口可以用于for-of循环
　　
　　    3) next()方法
　　        在遍历器对象Iterator中，有一个next方法，该方法会返回一个对象，对象中由两个属性value、done(当前数据是否遍历完)
　　
　　        let arr = [1,2,3]
　　        let iterator = arr.values()
　　        console.log(iterator.next())    //{ value: 1, done: false }
　　        console.log(iterator.next())    //{ value: 2, done: false }
　　        console.log(iterator.next())   //{ value: 3, done: false }
　　        console.log(iterator.next())  //{ value: undefined, done: true }
　　
　　    4) 添加迭代器
　　        获取数组中的values方法
　　            console.log(Array.prototype[Symbol.iterator])
　　            console.log([][Symbol.iterator])
　　
　　        let arr_like = {
　　            "0":"tom",
　　            "1":"25",
　　            "2":"male",
　　            length:3,
　　            [Symbol.iterator]:[][Symbol.iterator]
　　        }
　　        console.log(arr_like);
　　        for(let val of arr_like){
　　            console.log(val);
　　        }
　　
　　13.for-of循环 
　　    只有拥有迭代器的对象才能使用的循环
　　    拥有迭代器的对象：Array,String,Set,Map,arguments
　　    举例：
　　        let map = new Map([['name','tom']])
　　        for(let res of map) {
　　            console.log(res)
　　        }
　　
　　        let set = new Set([1,2,3,4,5])
　　        for(let res of set) {
　　            console.log(res)
　　        }
　　
　　14.class
　　    class是es5构造函数的语法糖
　　    1、构造函数
　　        es5中
　　            // 构造函数
　　            function Person(name,age) {
　　                this.name = name;
　　                this.age = age;
　　            }
　　            // 构造函数原型中添加方法
　　            Person.prototype.pay = function() {
　　                console.log(123)
　　            }
　　            // 创建实例per1
　　            let per1 = new Person('tom',12)
　　            console.log(per1)
　　            // 实例可以调用原型中方法
　　            per1.pay()
　　
　　        es6中
　　            class Person {
　　                // 构造函数中的方法
　　                static sayHello() {
　　                    console.log('静态方法')
　　                }
　　                constructor(name,age) {
　　                    this.name = name;
　　                    this.age = age;
　　                }
　　                pay() {
　　                    console.log('原型中方法')
　　                }
　　            }
　　            var per = new Person('tom',12)
　　            per.pay()
　　
　　    2、继承
　　        es5
　　            function Person1(name) {
　　                this.name = name
　　            }
　　            Person1.prototype.pay = function() {
　　                console.log("my name is "+this.name)
　　            }
　　            let per1 = new Person1('tom')
　　            // 子构造函数原型指向父构造函数的实例
　　            Person2.prototype = new Person1()
　　            Person2.prototype.constructor = Person2
　　
　　            function Person2(name) {
　　                this.name = name
　　            }
　　            let per2 = new Person2('jerry')
　　            per2.pay()
　　    
　　        es6 
　　            class Person1 {
　　                constructor(name) {
　　                    this.name = name;
　　                }
　　                pay() {
　　                    console.log('my name is '+this.name)
　　                }
　　            }
　　            let per1 = new Person1('tom')
　　
　　            class Person2 extends Person1{
　　                constructor(name) {
　　                    super(name)
　　                }
　　            }
　　            let per2 = new Person2('jerry')
　　            console.log(per2)
　　            per2.pay()
　　
　　15.Symbol
　　    1) 介绍
　　        1. Symbol是一种新的基本数据类型，作为第七种数据类型；
　　        2. Symbol函数不可以使用new关键字创建；
　　            举例：
　　                let symbol = Symbol('hello')
　　                console.log(symbol)  //Symbol(hello)
　　        3. 通过symbol创建出来的变量是独一无二的，可以通过这个变量向对象中添加属性，并且不会影响其他意见存在的属性，也不会出现覆盖的情况。
　　            举例：
　　                console.log(Symbol(12) == Symbol(12))  //false
　　            
　　            举例：
　　                let obj = {
　　                    name:'tom',
　　                    age:12
　　                }
　　                
　　                let symbol1 = Symbol('gender')
　　                obj[symbol1] = 'male'
　　                console.log(obj)
　　                console.log(obj.gender)
　　
　　                let symbol2 = Symbol('age')
　　                obj[symbol2] = 13
　　                console.log(obj)
　　                // 用于获取对象中多有通过symbol添加的属性名
　　                console.log(Object.getOwnPropertySymbols(obj));
　　
　　    2) Symbol API 
　　        Symbol.for(key)
　　            根据给定的键key，从symbol注册表中找到symbol，如果找到则返回改值，如果没找到，新建一个与该键关联的symbol，并将其放入全局注册表
　　            举例：  
　　                // 创建一个symbol并把其放入全局注册表中，键为hello
　　                let s1 = Symbol.for('hello')
　　                // 从symbol注册表中取出键为hello的symbol
　　                let s2 = Symbol.for('hello')
　　
　　                console.log(s1 == s2)  //true
　　        
　　        Symbol.keyFor(sym)
　　            用来获取symbol注册表中与某个symbol关联的键
　　            举例：
　　                // 创建一个symbol，将其放入注册表中，key为hello
　　                let s1 = Symbol.for('hello')
　　                // 获取s1的键
　　                console.log(Symbol.keyFor(s1)) //hello
　　
　　                // 创建一个symbol，没有放入注册表中，key为hello
　　                let s1 = Symbol('hello')
　　                // 注册表中没有s1，所以在注册表中获取不到s1的键
　　                console.log(Symbol.keyFor(s1)) //undefined
　　
　　16.Promise
　　    在js中所有的所有的代码都是单线程的，为了避免代码阻塞，js中网络请求、浏览器操作都需要异步执行
　　    0) 实现异步编程的方法
　　        1、回调函数
　　            function foo2() {
　　                console.log('foo2')
　　            }
　　            function foo1(foo2) {
　　                setTimeout(() => {
　　                    console.log('foo1')
　　                    foo2()
　　                },500)
　　            }
　　            foo1(foo2)
　　        
　　        2、Promise
　　    
　　    1) 实例化
　　        Promise是一个容器，里面保存着未来才会返回的结果，通常是一个异步操作
　　        let promise = new Promise((reslove,reject) => {})
　　        console.log(promise)
　　
　　        Promise构造函数接受一个匿名函数作为参数，而匿名函数又接受两个参数，分别是resolve，reject
　　        let promise = new Promise((reslove,reject) => {
　　            异步操作成功的时候 -> resolve() -> Promise对象的状态由pending -> reslove
　　            异步操作失败的时候 -> reject() -> Promise对象的状态由pending -> reject
　　        })
　　    
　　    2) 实例方法
　　        Promise.prototype.then() 
　　            指定请求成功时的回调函数
　　
　　        Promise.prototype.catch()
　　            指定请求失败时的回调函数
　　            promise
　　            .then((res1)=>{
　　                console.log('res1',res1)
　　                console.log(a);
　　            })
　　            .catch((err)=>{
　　                console.log(err)
　　            })
　　            catch不仅可以捕捉到promise对象的错，也可以拿到then方法中的错误
　　        
　　        Promise.prototype.finally()
　　            不管promise对象的状态为失败还是成功，最终都会执行该方法
　　                
　　        举例：
　　            生成一个随机数，判断是否小于0.5
　　            let promise = new Promise((reslove,reject) => {
　　                var math = Math.random()
　　                console.log(math)
　　                if(math < 0.5) {
　　                    reslove(true)
　　                } else if(math >= 0.5) {
　　                    reject(false)
　　                }
　　            })
　　            promise.then((res)=> {
　　                console.log(res)
　　            })
　　            .catch((err) => {
　　                console.log(err)
　　            })
　　
　　17.Generator函数
　　    es6提供解决异步编程的一种方法，语法跟传统函数不同。可以把generator理解成为一个状态机，里边封装了多个状态，执行generator函数，会返回一个遍历器对象，能够依次遍历generator中的每个状态。
　　    1) 特点
　　        1、function关键字与函数名之间有*
　　        2、函数内部使用yield表达式 
　　
　　    2)声明
　　        function * foo() {
　　            yield 'hello';
　　            yield 'world';
　　            return 'ending';
　　        }
　　    
　　    3) 调用
　　        跟普通函数一样，也是使用函数名() 的方式调用，不同的是，该调用方法返回的是generator迭代器对象，而不是结果
　　        function * foo() {
　　            yield 'hello';
　　            yield 'world';
　　            return 'ending'
　　        }
　　        var res = foo()
　　        console.log(res)  //Object [Generator] {}
　　        //调用遍历器对象的next方法，使得指针指向下一个状态
　　        console.log(res.next())
　　        console.log(res.next())
　　        console.log(res.next())
　　    
　　    4) yield表达式
　　        1.yield表达式只能在generator函数中使用
　　        2.yield表达式后面变量可以是值，也可以是函数的调用
　　        3.yield表达式默认没有返回值
　　    
　　    5) 异步函数同步化
　　        参考generator.html
　　
　　18.async函数
　　    是Generator函数的语法糖，使得异步操作变的简单
　　    1) async函数的形式
　　        async function foo() {
　　            let categories = await $.get('xxx');
　　            console.log(categories)
　　        }
　　
　　        对比generator函数
　　            * ->  async
　　            yield -> await
　　
　　    2) 对generator函数的优化
　　        1.更加语义化
　　            async表示函数里有异步操作，await表示紧跟在后边的表达式需要等待结果
　　        
　　        2.返回值是Promise
　　            比Generator函数的返回值是Iterator对象方便多了，可以使用.then方法制定下一步操作
　　
　　        3.不需要手动调用
　　            async函数自带执行器，也就是说，async函数的执行跟普通函数一样
　　
　　    3) 具体应用
　　        参考async.html