es6学习笔记

自执行函数里面的this指向的是window  
let，const
    1.声明的变量只在命令所在的代码块内有效
    2.let申明的变量不会变量提升（域解析）
    3，不允许在同一个作用域下声明已经声明的变量
    4，const申明后必须赋值

数据结构
    set :集合，由一组无序而且唯一的项组成的，特点key跟value相同，没有重复的value
          let s = new set([1,2,3])
        属性 .size
        方法 .add（）  添加一个数据
             .delete(value) 删除指定数据，返回布尔值
             .has(value) 判断是否有这个值 返回布尔值
             .clear() 清除所有的数据
             .keys()  返回键名的遍历器
             .values()  返回值的遍历器
             .entries() 返回键值对的遍历器
             .forEach(function(value,key,set/数据本身){})

     map :字典型数据结构，是用来存储不重复的key的hash结构，不同set 字典使用的是【键，值】的形式来存储的数据的
            键可以是字符串，也可以是对象   const map = new map([ ['a',1],['b':2]])
          map.set(键，值)  设置键值
          map.get(键)  获取键对应的值
          map.delete(键)  删除
          map.has(键)  返回布尔值
          map.clear()  清除所有的键值
          map结构中  认为NaN是同一个键


iterator跟for-of
    遍历器（Iterator）是一种接口，为各种不同的数据结构提供统一的访问机制。任何数据结构只要部署Iterator接口，就可以完成遍历操作
    for–in 用于遍历对象的属性。
    for-of 用于遍历数据 — 就像数组中的元素。
    for-of 不仅仅是为数组设计，还可以用于类数组的对象，比如 DOM 对象的集合

...扩展运算符  var str='abc';  arr=[...str] => [q,b,c]


class语法
    通过class关键字申明一个类
    class Miav{
        conshis.a=a;
            tructor（a,b）{
                        tthis.b=b;
            return this
        }
        print1(){
            console.log(this.a+'-'+this.b)
        }
        print2(){
            console.log(this.a+'-'+this.b)
        }
     }
     Miav下面的constructor是构造函数，方法直接写在构造函数后面，不需要逗号隔开，原型继续存在，方法都在原型上，定义在类的方法不能被枚举


    继承 extends   a extends b   a类继承b类
    继承格式class A  extends B { }
    static 如果在一个方法前， 加上static关键字， 就表示该方法不会被@@@@@@实例@@@@@继承， 而是直接通过类来调用， 这就称为“ 静态方法”
           父类的静态方法， 可以被子类继承。

    super（）  调用父类的构造函数 没调用super之前，子类没有this///  super当函数只能在构造 函数constructor里面调用
    super.方法（）  这里super其实就是父类的原型对象
      class B {
           constructor(a,b){
               this.a=a;
               this.b=b;
               return this
           }
           static add(){
               console.log(this)
           }
       }
        class A  extends B {
            constructor(a,b,c){
                super(a,b)
                this.c=c
            }
            addm(){
                console.log(this.a+this.b+this.c)
            }
        }
        var a =new A(1,2,3); a.addm() a.add()

symbol 表示独一无二值
        基本数据类型  null undefined number boolean string symobl
        定义symbol   let s1 = Symbol（'key'）  这个key只是描述，不会影响s1的值
        symbol不能做任何运输，判断为真

字符串的扩展
    1.模板字符串 ``  ${变量}
    var str ='a'
    2 str.repeat(2)  => 'aa'

    3 str.includes('a')  查找str中有没有a  返回布尔值

    4 str.endWith('a')  str.startWith('a')  查找str开头/结尾是否包含a
数组扩展
    Array.from()  把类数组转换成真正的数组
    Array.of()   方法用于将一组值，转换为数组。
    arr.find()   查找数组中的符合条件的，返回第一个符合条件的,没有找到符合条件的返回-1
            arr.find(function(a){ return a>2})
    arr.findIndex()   查找数组中的符合条件的，返回第一个符合条件的下标;没找到返回undefined
    arr.fill(填充的值，开始位置，结束位置不包括结束位置)
对象的扩展
    Object.is() 判断两个数据是否一样 返回布尔值
        Object.is(NaN，NaN)   true    Object.is(+0，-0)  false
    Object.assign(目标对象，源对象，源对象。。。。)  用于对象的合并，将源对象的所有可枚举的属性复制到目标对象上

rest参数（...变量名）  用于获取函数多余的参数，rest实质是一个数组，该变量将多余的参数放入数组中


箭头函数
    格式 ：函数名=（参数）=> {函数体}
    体内没有自己的this对象，使用的时候，其内部的this就是定义时候所在的环境的对象，而不是使用时所在的环境对象
    没有arguments对象  用...rest代替


generator函数   生成器
   普通函数 用function声明
   generator函数用  function* 声明
   在生成器函数内部，有一种类似return的语法：关键字yield。
   二者的区别是，普通函数只可以return一次，
   而生成器函数可以yield多次（当然也可以只yield一次）。
   在生成器的执行过程中，遇到yield表达式立即暂停，后续可恢复执行状态。


async函数
    函数声明
    async function foo() {}
    // 函数表达式
    const foo = async function () {};
    async表示函数里有异步操作
    await表示紧跟在后面的表达式需要等待结果。
    async函数的返回值是 Promise 对象，你可以用then方法指定下一步的操作。
    async函数内部return语句返回的值，会成then为方法回调函数的参数
    async函数内部抛出错误，会导致返回的 Promise 对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。
    await命令后面是一个 Promise 对象。如果不是，会被转成一个立即resolve的 Promise 对象。
        如   async function f() {                                    async function f() {
               return await 123;               ====》》                   return await Promise.resolve(123);
             }                                                        }
    只要一个await语句后面的 Promise 变为reject，那么整个async函数都会中断执行。
    即使前一个异步操作失败，也不要中断后面的异步操作。这时可以将第一个await放在try...catch结构里面
    另一种方法是await后面的 Promise 对象再跟一个catch方法，处理前面可能出现的错误。
        如 async function f() {
            await Promise.reject('出错了')
              .catch(e => console.log(e));
            return await Promise.resolve('hello world');
          }


promise 对象



traceur.js 前台把es6编译成es5
   1.引入tranceur.js
   2.引入引导程序 bootstrap.js （是引导程序不是bootstrap库）
   3.插入js  <script type='module'>要写的es6代码</script>

   map 打散
   reduce  汇总

转载于:https://www.cnblogs.com/chengyuanblog/p/9089124.html