ES6 读书笔记

一、let和const命令

二、变量的解构赋值

三、字符串的扩展

四、数值的扩展

五、正则的扩展

六、数组的扩展

七、函数的扩展

八、对象的扩展

九、symbol

十、proxy和reflect

十一、二进制数组

十二、set和map数据结构

十三、iterator和for...of循环

十四、generator函数

十五、promise对象

十六、异步操作和async函数

十七、Class

十八、修饰器 （ES7 但babel支持）

十九、module

二十、编程风格［可参阅jscs.info］

 

一、let和const命令

    1.1、let

            {

                let a = 10;

            }

        仅在代码块中使用有效；

        不存在变量提升：需要在声明后使用；

        暂时性死区：只要块级作用域内存在let，其变量便绑定了该区域，不受外部影响；

        不允许重复声明：不允许相同作用域声明同一个变量；

 

    1.2、块级作用域

        由于不存在变量提升，块级作用域之间的元素互不影响。

 

    1.3、const命令

        声明常量，一旦声明，其值不能改变；

        只有声明所在的块级作用域有效；

        不存在变量提升，有暂时性死区；

        对于对象、数组等指针型变量，不能改变的是指针，而非内部内容，如果需要防止内容的改变，使用object.freeze方法。

 

    1.4、跨模块的常量

    // constants.js 模块

        export const A = 1; 

        export const B = 2;

        export const C = 3;

    // test1.js  模块

        import * as constants from ‘./constants’;

        console.log(constants.A);

     // test2.js  模块    

        import {A, B} from ‘./constatns’;

        console.log(A);

 

    1.5 全局对象属性

        window下，全局对象为window；nodejs环境下指的global对象。

        ES6下，var、function命令声明的仍为全局变量；let、const、class命令不属于全局对象属性。

 

二、变量的解构赋值

    2.1 数组的解构赋值

        [a, b, c, d] = [1, 2, 3, 4]，这种属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。

        [head, …tail] = [1, 2, 3, 4] // head == 1; tail == [2, 3, 4]

        如果解构不成功，则会赋值undefined

        默认值：[x = 1, y] = [2, 3] or [x = f(), y] = [2, 3];如果默认值为表达式，仅在使用时，才会执行表达式。

 

    2.2 对象的解构赋值

        对象按照属性名取值，数组按照次序取值。

        var {foo: baz, bar: tr} = {foo:’aaa’, bar: ‘bbb’};真正被复制的是baz，而非foo；

        {x} = {x:1} //容易出错，一般会解析成代码块，最佳方式：（{x}={x:1}）

 

    2.3 字符串的解构赋值

        const [a, b, c, d, e] = ‘hello’;// a=‘h’,b=‘e’…

        let {length: len} = ‘hello’;// len = 5;

 

    2.4 数值与布尔值的解构赋值

        如果右边是数值或布尔值，会先转换成对象。

 

    2.5 函数参数的解构赋值

         undefined会触发函数参数的默认值。

        [1, undefined, 3].map((x = ‘yes’) => x) // [1, ‘yes’, 3]

 

    2.6 圆括号问题

        解析结构是表达式还是模式不容易，所以不要在模式中放置圆括号。

 

    2.7 用途

        a、交换变量

        b、函数返回多个值

        c、函数参数的定义

        d、提取json数据

        e、函数参数的默认值

        f、遍历map结构

 

三、字符串的扩展

    ES6加强了对Unicode的支持，并且扩展了字符串对象。

    javascript允许采用\uxxxx形式表示一个字符，其中xxxx表示字符的码点。

    3.1 字符的Unicode表示法

 

    3.2 codePointAt() 可以判断字符是否为4个字节，返回字符对应的码点

 

    3.3 string.fromCodePoint()  参数为码点，可返回字符值

 

    3.4 字符串的遍历器接口

        for (let codePoint of ‘foo’) {

            // ‘f’, ‘o’, ‘o’    其可自动识别四个字节的字符

        }

 

    3.5 at() 可返回四个字节的字符（汉字） 等价两字节的charAt()。

 

    3.6 normalize() 将字符的不同表示方法统一为同样的形式。

 

    3.7 includes(), startsWith(), endsWidth() 表示是否找到参数字符串，返回布尔值

 

    3.8 string.repeat(n) 表示将原字符串重复n次

 

    3.9 padStart, padEnd，用来补全字符串

        ‘x’.padStart(5, ‘ab’) //ababx  接受两个参数，第一个为总长，第二个为重复的字符。

 

    3.10 模板字符串

        使用反引号标识，嵌入变量${}

        $(‘#result’).append(’there are <b>${count}</b>items.’);

 

    3.11 模板编译

 

    3.12 标签模板

        可使用其嵌入其他语言，如jsx。

         函数调用的一种特殊形式，标签指函数，紧跟其后的模版字符串是参数。

        tag`hello ${a + b} world ${a * b}` => function tag([‘hello’, ‘ world’, ‘’], 15, 50)

 

    3.13 string.raw() 充当模板字符串的处理函数，返回一个反斜线都被转移的字符串。

        

四、正则的扩展

    4.1 RegExp构造函数 new RegExp(/abc/ig, ‘i’).flag // ‘i’

 

    4.2 将四个正则方法：match、replace、search、split四个方法都定义在了RegExp的对象上

 

    4.3 u修饰符 为正则添加了u修饰符，含义为’unicode模式’

        a、点字符 .表示任意字符，对于四字节字符，无法匹配，配合修饰符u，可正确判断。

        b、unicode字符表示法 新增了大括号表示Unicode字符 /u{61}/u.test(‘a’)

        c、量词 /接{2}/u.test('接’) //true

        e、预定义模式/^\S$/u.test(‘接’) // true

        f、i修饰符

 

    4.4 y修饰符 ‘粘连’修饰符 与g功能相同，不同之处y默认带^，下一位置就必须能够匹配上。

 

    4.5 sticky属性 表示是否设置了y修饰符 var r = /hello/y;  r.sticky // true

 

    4.6 flags属性 返回正则的修饰符

 

    4.7 RegExp.escape() 还未通过审核

 

五、数值的扩展

    5.1 二进制和八进制数值表示法

        0b || 0B 为二进制； 0o || 0O表示八进制

 

    5.2 Number.isFinite(), Number.isNaN() 分别用来检查 Infinite 和 NaN这两个特殊值。

        传统的这两个方法，会先调用Number()转为数字，在判断；而新方法不转换，直接判断。

 

    5.3 Number.parseInt(), Number.parseFloat() 其行为不变，只是移植到了Number对象上。

 

    5.4 Number.isInteger()用来判断是否为整数，3和3.0视为同一值。

 

    5.5 Number.EPSILON 一个极小的常量，为了减小浮点数相减的误差而设，如果误差小于这个常量，则正确。

        5.5545656563e-17 < Number.EPSILON

 

    5.6 安全整数和Number.isSafeInteger()  

        ES6提供了两个常量，Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER

 

    5.7 Math对象的扩展

        增加了17个与数学相关的方法。

        a、Math.trunc() 去除数字的小数部分，返回整数部分。

        b、Math.sign() 判断一个数是正数、负数还是零，+1正数；-1负数；+0; -0; NaN

        c、Math.cbrt() 计算一个数的立方根

        d、Math.clz32() 返回一个32位无符号整数形式（使用二进制表示的）有多少个前导0

        e、Math.imul() 返回两个数以32位带符号整数相乘的结果

        f、Math.fround() 返回一个数的单精度浮点数形式

        g、Math.hypot() 返回所有参数的平方和的平方根

        对数方法：

        h、Math.epm1(x) 返回e^x-1

        i、Math.log1p(x) 返回 1/ln(1+x)

        j、Math.log10(x) 返回10为底的x的对数 Math.log10(10000) //4

        k、Math.log2(x) 返回以2为底x的对数

        三角函数方法：

        l、Math.sinh(x)   返回x的双曲正弦

        m、Math.cosh(x) 返回x的双曲余弦

        n、Math.tanh(x)    返回x的双曲正切

        o、Math.asinh(x)    返回x的反双曲正弦

        p、Math.acosh(x)    返回x的反双曲余弦

        q、Math.atanh(x)    返回x的反双曲正切

　　5.8 指数运算符 **

　　　2 ** 3 = 8

 

六、数组的扩展

    6.1、Array.from() 将两类对象转换成真正的数组：类数组的对象及可遍历的对象（即必须有length属性）

        如dom操作的nodeloost集合、函数内部arguments对象及ES6的Set和Map方法

        document.querySelectorAll(‘p’)

        tips: 运算符...也可将某些结构转换成数组；from能正确的识别unicode字符

        Array.from(spans, s => s.textContent);其转换数组的同时，具备map的功能。

 

    6.2、Array.of()

        用于将一组值转换为数组。Array.of(3, 11, 8) // [3, 11, 8]

 

    6.3、copyWithin(target, start = 0, end = this.length)

        将数组内部指定位置的成员复制到其他位置上

 

    6.4、find()和findIndex()

        find找出第一个符合条件的数组成员，返回成员或者undefined

        [1, 4, -5, 10].find((n) => n<0) //－5

        findIndex()与上同，返回成员位置，否则返回－1

 

    6.5、fill(x, start, end)

        填充数组[‘a’, ‘b’].fill(7, 1, 2) // [‘a', 7]

 

    6.6、 entries()、keys()、values() 

        用于遍历数组，返回一个遍历器对象，可用for..of遍历

        entries为遍历键值对；keys为遍历键值；values为遍历值

        for (let [index, elem] of [‘a’, ‘b’].entries()) // 0 ‘a’

 

    6.7、includes(x, start, end)

        返回一个布尔值，表示某个数组是否包含给定的值

 

    6.8、数组的空位

        [, , ,]空位不代表undefined

        ES5对空位的处理不一致，而ES6进行统一，将空位都转换为undefined，空位不会被忽略掉。尽量避免空位出现。

 

    6.9、数组推导

        var a1 = [1, 2, 3,4];

        var a2 = [for (i of a1) i* 2]; //[2, 4, 6, 8]

        var a3 = [for (i of a1) if (i > 2) i]; //[3, 4]

        其可替代map()及filter()方法

 

七、函数的扩展

    7.1、函数参数的默认值

         function log(x, y = ‘hello’){}

        a、参数的解构赋值：重点区分参数的默认值与解构赋值的默认值。

        b、默认参数：非显示的输入undefined，触发该参数等于默认值，null没有这个效果。

        c、length属性：指定默认值的参数，不计入length，导致length失真。

        d、作用域：当前函数作用域与全局作用域

            try catch err throw

 

    7.2、rest参数 “…变量名”

        rest参数搭配的变量是一个数组，将多余的参数放入其中；rest参数之后不能再有参数。

 

    7.3、扩展运算符

        ‘…’，将一个数组转为用逗号分隔的参数序列。

        a、替代apply()

        b、合并数组：[1, 2, …more]

        c、与解构赋值结合：[1, 2, …rest] = list;     

            tips:扩展运算符用于数组赋值时，只能放在末尾。

        d、字符串：[…’hello’] //[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]

            可正确返回字符的长度(可识别unicode字符)；[...string].length

        e、类数组对象：可转变成数组.

 

    7.4、name属性

        function foo(){} foo.name // “foo"

 

    7.5、箭头函数

        使用箭头定义函数；

        a、var f = v => v;  等同于 var f = function(v) {return v};

        b、函数不需要参数或者需要多个参数，就用()代替：

             var f = () => v;  等同于 var f = function(a, b) {…… return v};

        c、由于大括号被解析成代码块，如果需要返回对象，需要加上括号：

            var fun = id => ({id: id, name: ‘hity’});

        d、如果代码块多余一条语句，就需要用大括号包起来。

        e、嵌套箭头函数

        tips：

            a、函数体内的this，是定义时的对象，而非运行时；

            b、不可当构造函数；

            c、arguments对象不存在，可用rest参数代替；

            d、不可使用yield命令，无法用作generator函数；

            e、箭头函数无自己的this作用域，this指向父级this；所以无法使用apply、call、bind改变this指向

            f、无arguments、super、new.target；

 

    7.6、函数绑定

            ‘::’可以将左边对象作为上下文绑定到右边的函数上。可以采用链式的写法，返回的还是原对象。

 

    7.7、尾调用优化

            概念：指某个函数的最后一步是调用另外一个函数：function f(x){ return g(x);}

            尾调用优化，去掉外层的调用帧。

                tips：仅当内部函数不需要使用外部函数的变量时，优化才会进行。

            尾递归：递归非常消耗内存，将其转变为尾递归将只有o(1)的复杂度。

                tips：尾递归仅严格模式下可用：“use strict”，这种情况下函数的信息都将移除～

  

八、对象的扩展

    8.1、属性的简洁表示法

        {x, y} == {x: x, y: y};

        var obj = {

            birth,

            method() {

                return ‘hello';

            }

        }

 

    8.2、属性名表达式

        let obj = {

            [prop]: true,

            [‘a’ + ‘b’]: 123

        }

 

    8.3、方法的name属性

        (new Function()).name //anonymous

        bind创造的方法，name属性返回“bound”加原函数名。

 

    8.4、Object.is()

        比较两个值是否严格相等。与 === 基本一致。(+0, -0)//false  (NaN, NaN)// true

 

    8.5、Object.assign(targetObj, srcObj)

        作用：将srcObj的所有可枚举对象复制到targetObj上；其只复制自身属性，不可枚举的和继承的不会被复制。

 

    8.6、属性的可枚举性

        object.getOwnPropertyDescriptor(obj, ‘foo’)；

        // {value: 123, writable: true, enumerable: true, configurable: true}

        有三个操作会忽略enumerable为false的属性：

            a、for…in：遍历自身和继承的可枚举属性；

            b、Object.keys()：返回对象自身的可枚举属性键名；

            c、JSON.stringify()：串行化对象自身的可枚举属性；

            d、Object.assign()：复制自身可枚举的属性；

            e、Reflect.enumerate():返回所有for...in循环会遍历的属性

        tips：所有Class的原型的方法都不可枚举。

 

    8.7、属性的遍历

        ES6共6种方法遍历对象的属性：

        for…in：（无symbol）

        Object.keys()：（无symbol）

        Object.getOwnPropertyNames(obj)：返回数组，包含对象自身所有属性（无symbol）

        Object.getOwnPropertySymbols(obj)：返回数组，包含对象自身的所有symbol属性

        Reflect.ownKeys(obj)：返回数组，包含对象自身所有的属性

        Reflect.enumerate(obj)：返回一个Iterator对象，遍历对象自身和继承所有可枚举属性（无symbol）

 

    8.8、__proto__属性、Object.setPrototypeOf()、Object.getPrototypeOf()

        __proto__属性用来设置、读取当前对象的prototype对象；但最好不用，而是使用object.setPrototypeOf(object, prototype)、object.getPrototypeOf()、object.create()代替。

 

    8.9、对象的扩展运算符

        rest亦可用于对象，使用方法相同。

        tips：

            a、其为浅复制，如果一个键的值为复合类型，则复制这个值的引用。

            b、不能复制继承自原型对象的属性。

            c、rest对象中存在取值函数get，这个函数会立即执行。

 

九、symbol

    9.1、概述

        引入的原因：解决扩展他人对象属性时的命名冲突。

        javascript的第7种数据类型为：symbol，属性名属于symbol就是独一无二的。

        tips：symbol值不能与其他值运算，它不能添加属性，类似字符串。

             symbol值可转为字符串、布尔值；

 

    9.2、作为属性名的symbol

        a {[mySymbol]:  ‘hello’}

 

    9.3、消除魔术字符串

        指在代码之中多次出现、与代码形成强耦合的某一个具体的字符串或者数字。

 

    9.4、属性名的遍历

        可以设置一些非私有又希望仅内部使用的方法。

 

    9.5、symbol.for(), symbol.keyFor()

        symbol.for(name)：查找对应的symbol，查到则返回，并登记在全局中，否则创建一个新的symbol。

        symbol.keyFor(s1)：返回已登记的symbol key（即name）。

 

    9.6、内置的symbol值

        

十、Proxy和Reflect

    proxy代理，可以理解成目标对象前架设一“拦截”层，外界访问必须先通过该拦截。

    new Proxy(target, handle);

    10.1、实例方法

        a、get()：用于拦截某个属性的读取操作；

        b、set()：用于拦截某个属性的赋值操作；

        c、apply(): 用于拦截函数的调用、call和apply操作；

        d、has(): 用于隐藏某些操作，不被in操作符发现；

        e、construct(): 用于拦截new命令；

        f、deleteProperty: 用于拦截delete操作，使得属性不被delete；

        g、defineProperty：用于拦截object.defineProperty(添加新属性)操作；

        h、enumerate()：用于拦截for...in循环；

        i、getOwnPropertyDescriptor()：用于拦截object.getOwnPropertyDescriptor;

        j、getPrototypeof()：用于拦截其运算，以及其他一些操作；

        k、isExtensible()：用于拦截其操作；[如果对象是可扩展的（这表示可向对象添加新属性），则为 true；否则为 false。]

        l、ownKeys()：用于拦截object.keys操作；

        m、preventExtensions()：用于拦截其操作，必须返回布尔值；

        n、setPrototypeOf()：用于拦截其方法。

 

    10.2、proxy.revocable()

        返回一个可取消的proxy实例。

 

    10.3、reflect概述

        其设计目的：

        a、将object上明显属于语法层面的方法放到reflect上；

        b、修改某些object的返回结果，让其变得更合理；

        c、让object操作都变成函数行为；

        d、reflect对象的方法与proxy对象的方法一一对应，这样可以直接让proxy对象调用reflect对象完成默认行为。

 

十一、二进制数组（大略的过，需要理解内存之类的计算机原理等）

    设计目的：为了让开发者能够通过javascript与操作系统的原生接口进行二进制通信。

    二进制数组分三类：

    a、arrayBuffer对象：代表原始的二进制数据；

    b、typedArray视图：用于读写简单类型的二进制数据；

    c、dataView视图：用于读写复杂类型的二进制数据。

    typedArray有九种类型数据：int8、uint8、uint8C、int16、uint16、int32、uint32、float32、float64

    dataView有除uint8C外的八种数据类型。

    API用到了二进制数组操作二进制数据的有一下浏览器：

        File API、XMLHttpRequest、Fetch API、Canvas、WebSocket

 

    11.1、arrayBuffer对象

        var buf = new ArrayBuffer(32);

        arrayBuffer.prototype.byteLenth：由于分配内存的操作不一定成功，所以需要通过该字段来判断是否成功；

        arrayBuffer.prototype.slice()：允许将内存区域的一部分复制生成一个新的arrayBuffer对象；

        arrayBuffer.isView()：返回布尔值，表示参数是否为arrayBuffer的一个试图实例。

 

    11.2、typedArray视图

        其有九个构造函数，对应不同的数据类型；

        形成的数组成员都是一种类型；

        成员都是连续的，不会有空位；

        默认值为0。

 

    11.3、dataView视图

 

    11.4、二进制数组的应用

        a、ajax 返回的类型可以为二进制，设置为arraybuffer or blob;

        b、canvas 类型值为uint8clampedarray

        c、websocket 通过arraybuffer发送或者接收二进制数据；

        d、fetch API 取回的数据为arrayBuffer对象；

        e、file API 如果知道文件为二进制数据类型，也可以将其读取为arrayBuffer对象。

 

十二、set和map数据结构

    12.1、set

    set是一种新的数据结构，其与数组的区别是，没有重复值，成员值都唯一。set本身为构造函数。

    set接受一个数组作为参数，var set ＝new Set([1, 2, 3, 4, 4]); // [1, 2, 3, 4]。

    set加入的值，不会进行类型转换，判断相等使用的是 ===。 

    set实例的属性和方法：

        set.prototype.size: 返回set成员的总数；

        add(value): 添加某个值，返回set结构本身；

        delete(value)：删除某个值，返回一个布尔值；

        has(value): 返回一个布尔值；

        clear()：清除所有成员，没有返回值。

    遍历方法：keys()、values()、entries()、forEach()

 

    12.2、weakSet

        为不重复的值的集合，与set的区别：

            a、其成员只能是对象；

            b、其对象为弱对象，垃圾回收机制不考虑它的引用，因此，它是不可遍历的。

        方法：add()、delete()、has()；

        其用处为：储存DOM节点，而不用担心这个节点从文档中移除时会发生内存泄漏。

 

    12.3、map

        map类似对象，区别在于键不同，对象的键限制只允许字符串，map的键不受限：

            对象为“字符串－值”的对应，map为“值－值”的对应。

        需要堤防一种情况，键为引用地址的情况：如

            map.set([‘a’], 123);

            map.get([‘a’]); // undefined

            由于数组作为键时，标记的是数组所在的引用地址。

            var k1 = [‘a’];

            map.set(k1, 1234);

            map.get(k1) // 1234

        map的键是跟内存绑在一起的，只要内存地址不一样，就视为两个键。如此解决了同名属性碰撞的问题。

        map的属性和方法：

            size属性：返回成员总数；

            set(key, value)：设置键值，并返回整个map的结构；

            get(key)：读取key对应的值，找不到则返回undefined；

            has(key)：返回布尔值，确认键是否存在；

            delete(key)：删除某个键，返回布尔值；

            clear()：清除所有成员，没有返回值。

        遍历方法：keys()、values()、entries()、forEach()。

        可使用运算符（...）转换成数组。

        转换：

            a、map转数组（…）

            b、数组转map；

            c、map转对象；

            d、对象转为map；

            e、map转为son（键名为字符串）；

            f、json转为map（键名为字符串）。

 

    12.4、weakmap

        weakmap与map类似，但其只接受对象作为键名，键名指向的对象不计入垃圾回收机制。其有助于内存泄漏。

 

十三、iterator和for...of循环

    iterator接口为各种不同的数据提供统一的访问机制。只要部署iterator接口，就可完成遍历操作。

    作用：

        a、为各种数据结构提供统一的、简便的访问接口；

        b、使得数据结构的成员能够按照某种次序排列；

        c、es6创造了一种新的遍历命令for...of循环，iterator接口主要供其消费。

    遍历过程：

        step1、创建指针对象，指向当前数据结构的起始位置；

        step2、第一次调用指针对象的next方法，指向第一个成员；

        step3、第二次调用next方法，指向第二个成员；

        step4、不断调用，直到结束。

    step2时，会返回数据结构当前的成员信息；具体是返回一个包含value和done的对象，value为成员值，done为布尔值，表示遍历是否结束。

    iterator接口需要通过symbol.iterator来部署。

 

    13.3、调用iterator接口的场合

        解构赋值、扩展运算符、其他场合：for...of、array.from()、map()、set()、weakmap()、weakest()、promise.all()、promise.race()。

 

    13.4、字符串的iterator接口

        var string = “lala”;

        var iterator = string[Symbol.iterator]();

        修改遍历器对象。

 

    13.5、iterator接口与generator函数

        Symbol.iterator方法最简单的实现还是generator函数。

 

    13.6、遍历器对象的return()、throw()

        next方法是必须部署的方法，return方法用于for...of循环提前退出时（break、continue或者出错），调用。return方法必须返回一个对象。throw方法配合generator使用。

 

    13.7、for...of循环

        一个数据结构只要部署了Symbol.iterator属性，就可以用for...of循环遍历其成员。

        for… in、for…of

        数组、set、类数组对象［string］：for (let v of arr)

        map:for (var [name, value] of  es6)

 

十四、generator函数

    14.1、简介

        基本概念：Generator函数为ES6提供的一种异步编程解决方案，语法行为与传统函数完全不同。

        Generator是状态机，也是遍历器对象生成器，返回一个遍历器对象。它的两个特征：a、function命令与函数名之间有一个星号；b、内部使用yield定义内部状态。最大特点，暂缓执行函数；通过next做暂缓和停顿。

        其调用后，不执行，而是返回一个iterator对象，需用next方法调用，才执行。

        yield语句无法用在普通函数中，否则出错；且用于表达式中时，需要放在圆括号内。

 

    14.2、next方法的参数

        next方法的参数为yield的执行结果，可向函数体内注入值。

        yield返回值通常为undefined；如果next带有参数，则返回该参数。next传递的参数往往为上一次yield的返回值。

 

    14.3、for…of循环

 

    14.4、Generator.prototype.throw()，可在函数体外抛出错误，函数体内执行。

 

    14.5、Generator.prototype.return()

        可返回给定的值，并终结Generator函数的遍历。

        g.return(“foo”) //{value: “foo”, done:true}

        如果函数内部有try...finally代码块，那么return方法会推迟到finally代码执行完再执行。

 

    14.6、yield语句

        如果Generator函数内部调用另一个Generator函数，默认情况下无效；使用yield*，则生效。yield*表示在函数内部部署了一个for...of循环。

 

    14.7、作为对象属性的Generator函数

        let obj = {

            * myGeneratorMethod() {}

        }

 

    14.8、Generator函数的this

        构造函数返回的是一个内部的指针，可通过bind一个对象，赋予作用域，将this绑定在对象上。

 

    14.9、Generator函数推导

        let squard = (for (n of generator()) n * n);

 

    14.10、含义

        Generator与状态机，其本身包含状态机，不需要额外的外部变量保存状态。

 

    14.11、应用

        a、异步操作的同步表达

            function* main() {

                var result = yield request(url);

                var resp = JSON.parse(result);

            }

 

            function request(url) {

                makeAjaxCall(url, function(response) {

                    it.next(response);

                });

            }

 

            var it = main();

            it.next();

        b、控制流管理

        c、部署iterator接口

                利用Generator函数可以在任意对象上部署Iterator接口。

        d、作为数据结构

            其可以返回一系列的值。

 

十五、promise对象

    15.1、promise的含义

        所谓promise就是一个对象，用来传递异步操作的消息。其有两个特点：

            a、其状态不受外界影响；其有三种状态：pending（进行中）、resolved (已完成，又称”fulfilled”)、rejected（已失败）；

            b、一旦状态改变就不会再变，任何时候都可以得到这个结果；

        有了promise对象就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调。

        缺点：

            无法取消promise；如果不设置回调，promise内部抛出的错误不会反应到外部；一般说来，如果事件不断发生，使用stream模式比部署promise更好。

 

    15.2、基本用法

            两个异步之间的调用：

                var p1 = new Promise(function (resolve, reject){})

                var p2 = new Promise(function (resolve, reject){

                    resolve(p1);

                })

            p2的状态为(p1 与 p2)的并集。只要一个为rejected，则为rejected；全部为resolved则为resolved。

 

    15.3、Promise.prototype.then()

        then方法返回一个promise实例（并非前一个实例），此时可以链式的调用then。

 

    15.4、Promise.prototype.catch()

        其是.then(null, rejection)的别名，用于指定发生错误的回调函数；promise在resolve后再抛出错误，并不会被捕获。

        promise的错误具有“冒泡”性质，会一直向后传递，直到捕获为止。最好不在then的第二个参数定义rejected状态的回调，而应使用catch方法。

        catch方法也是返回一个promise实例。

 

    15.5、promise.all()

        promise.all方法用于将多个promise实例包装成一个新的promise实例。

        var p = Promise.all([p1, p2, p3]);其参数必须具有iterator接口，且返回的每个成员都是Promise实例。

        p的状态为：

            a、三者都为resolved，则它为resolved；

            b、只要一个为rejected，则它为rejected；此时第一个被rejected的实例的返回值会传递给回调函数。

 

    15.6、promise.race()

        亦是将多个promise实例包装成一个新的promise实例。只要其中有一个实例改变状态，p的状态也跟着改变。

 

    15.7、promise.resolve()

        其可将现有对象转为promise对象；

        promise.resolve(‘foo’) 等价于 new Promise(resolve => resolve('foo’));

 

    15.8、promise.reject()

        返回一个promise的实例，状态为rejected。

 

    15.9、两个附加方法

        done()：为了最终捕获任何可能出现的错误；

        finally()：指定不管promise对象最后状态如何都会执行的操作。

 

    15.10、应用

        a、加载图片

        b、Generator与Promise（管理 流程＋异步 混合操作）

 

    15.11、async函数（亦是用于取代回调函数解决异步操作）

 

十六、异步操作和async函数

    在ES6诞生前，异步编程的方法大概有4种：

        a、回调函数；

        b、事件监听；

        c、发布、订阅；

        d、promise对象。

        

    16.1、Generator函数

        协程，类似线程，执行到一半转移执行权。yield命令将执行权交给其他协程。

        其数据交换及错误处理：next(x);try{}catch{}.

        fetch返回promise对象。

 

    16.2、thunk函数（结合generator函数进行自动流程管理）

        编译器的“传名调用”，将参数放到一个临时函数中，再将临时函数传入函数体内。这个临时函数就叫thunk函数。

 

    16.3、co模块

        co模块用于Generator函数的自动执行。

        var co = require(‘co’);

        co(gen);

        co(gen).then(function() {

            console.log(‘generator函数执行完毕');

        });

        如何交回generator的执行权：

            a、回调函数。将异步包装成thunk函数，在回调函数中交回执行权。

            b、promise对象。将异步操作包装成promise对象，用then 方法交回执行权。

        co模块是将两种自动执行器包装成了一个模块，使用co的前提条件是，yield命令后面只能是thunk函数活着promise对象。

 

    16.4、async函数（属于es7）

        async函数：

            a、内置执行器；

            b、更好的语义；

            c、更广的适应性，async函数的await命令后面可以使promise对象和原始类型值；

            d、返回值为promise对象。

 

十七、Class

    17.1、基本语法

        定义类：

            class Point {

                constructor(x, y) {

                    this.x = x;

                    this.y = y;

                }

 

                toString() {

                    return ‘(‘ + this.x + ‘, ‘ + this.y + ‘)’;

                }

            }

    类的数据类型就是函数，类本身就指向构造函数。

    类的内部定义的所有方法都是不可枚举的。

    不存在变量提升。

 

    17.2、class的继承

        class之间通过extends关键字实现继承；通过super方法，指向父类的this对象。

        class ColorPoint extends Point {

            constructor(x, y, color) {

                super(x, y); //调用父类的constructor(x, y)

                this.color = color;            

            }

        }

    es5的继承实质上是先创造子类的实例对象this，然后再将父类的方法添加到this上（parent.apply(this)）;

    es6的继承实质上是先创建父类的实例对象this（调用super方法），然后再用子类的构造函数修改this。

    类的prototype属性和__proto__属性：

        a、子类的__proto__属性表示构造函数的继承，指向父类；

        b、子类的prototype的__proto__属性表示方法的继承，指向父类的prototype属性。

    extends的继承目标：

        只要具有prototype属性，就能被继承。

        object.getPrototypeOf()方法从子类上获取父类。

        super关键字代表父类的实例。

 

    17.3、原生构造函数的继承

        es5无法继承，es6可以。

 

    17.4、class的取值函数(getter)和存值函数(setter)

        与es5一样，在class内部可以使用get和set关键字对某个属性设置存值函数和取值函数，拦截该属性的存取行为。

 

    17.5、class的generator方法

        class Foo {

            constructor(…args) {

                this.args = args;

            }

            *[Symbol.iterator]() {

                for (let arg of this.args) {

                    yield arg;

                }

            }

        }

    

        for (let x of new Foo(‘hello’, ‘world’)) {

            console.log(‘x');

        }

 

        // hello //world

 

    17.6、class的静态方法

        定义：在一个方法上加static关键字，就表示该方法不会被实例继承，而是直接通过类调用，成为“静态方法”。

        通过使用extends，可以让实例继承。

 

    17.7、class的静态属性

        定义：指class本身的属性，而不是定义在实例对象（this）上的属性。

 

    17.8、new.target属性

        new是从构造函数生成实例的命令。该属性可以确定构造函数是怎么调用的。

        function Person(name) {

            if (new.target === Person) {

                this.name = name;

            } else {

                throw new Error('必须使用new生成实例’)；

            }

        }

        var person = new Person(‘hit') //正确

        var notAPerson = Person.call(person, ‘张三’); // 报错

 

    17.9、mixin模式的实现

        定义：将多个类的接口“混入”另一个类：

        

十八、修饰器 （ES7 但babel支持）

    18.1、类的修饰器

        @testable

        class MyTestableClass {}

        其中的@testable为修饰器，修改了类的行为，增加了一个静态属性。

 

    18.2、方法的修饰

        class Person {

            @readonly

            name() {

                return `${this.first} ${this.last}`

            }

        }

        修饰器函数共接受3个参数，修饰的目标对象；修饰的属性名；属性的描述对象。

        function readonly(target, name, descriptor) {

            descriptor.writable = false;

            return descriptor;

        }

 

        Object.definePrototype(Person.prototype, ’name’, descriptor);

 

    18.3、为何修饰器不能用于函数

        修饰器职能用于类及类的方法，因为其存在函数提升。

 

    18.4、core-decorators.js

        其是一个第三方模块，提供了几个常见的修饰器。

        a、@autobind 使得方法中的this对象绑定原始对象。

        b、@readonly使得属性或者方法不可写；

        c、@override检查子类方法是否正确覆盖父类的同名方法；

        d、@deprecate在控制台显示一条警告，表示该方法将废除；

        e、@suppressWarnings 修饰器抑制decorated修饰器导致的console.warn调用。

 

    18.5、使用修饰器实现自动发布事件

        “发布／订阅”库postal.js

 

    18.6、mixin

        在修饰器的基础上可以实现mixin模式，就是对象继承的一种替代方案，在对象中混入另一个对象的方法。

 

    18.7、trait

        效果与mixin类似，但提供更多的功能，比如防止同名方法的冲突、排除混入某些方法、为混入的方法起别名等。第三方模块：traits-decorator。

 

十九、module

    ES6的class只是面向对象编程的语法汤，升级了ES5构造函数的原型链继承的写法，并没有解决模块化问题。

    commonjs模块是对象，输入时必须查找对象属性，其实质是整体加载模块，然后使用方法，这种为“运行时加载”。

    es6模块不是对象，而是通过export命令显示的制定输出的代码，输入时采用静态命令的形式。

    import{ start, exists, readFile} from ‘fs’;

    以上实质是从fs模块加载3个方法，其他方法不加载。这种加载称为“编译时加载”

    效率比commonjs高。

    ES6模块化的其他优点：

        a、不再需要UMD模块格式；

        b、将来浏览器的新API可以用模块格式提供，不再需要做成全局变量或者navigator对象的属性；

        c、不再需要对象作为命名空间，未来这些功能可通过模块实现。

    19.1、严格模式 ［lottery插件完成后做详细了解］

        模块化自动采用严格模式，限制如下：

            a、变量必须声明后使用；

            b、函数的参数不能有同名属性，否则报错；

            c、不能使用with语句；

            d、不能对只读属性赋值，负责报错；

            e、不能使用前缀0表示八进制，否则报错；

            f、不能删除不可删除的属性，否则报错；

            g、不能删除变量(delete prop)，会报错，职能删除属性(delete global[prop])；

            h、eval不会再外层作用域引入变量；

            i、eval和arguments不能被重新赋值；

            j、arguments不会自动反映函数参数的变化；

            k、不能使用arguments.callee;

            l、不能使用arguments.caller；

            m、禁止this指向全局变量；

            n、不能使用fn.caller和fn.arguments获取函数调用的堆栈；

            o、增加保留字段（protected、static和interface）。

 

    19.2、export命令

        模块功能主要由两个命令构成：export和import；export用于规定模块的对外接口；import命令用于输入其他模块提供的功能。

        // profile.js

        export { f1 as firstName, lastName, year};

 

    19.3、import命令

        import {firstName as f1, lastName, year} from ‘./profile’;

 

    19.4、模块的整体加载

        除了指定加载某个输出值，还可以使用整体加载，即用（*）指定一个对象，所有输出值都加载在这个对象上。

        import * as circle from ‘./circle’。

 

    19.5、module命令

        module可取代import命令，达到整体输入模块的作用。

        module circle from ‘./circle’。

 

    19.6、export default命令

        export default function() {};

        import cc32 from ‘crc32’;

    vs

        export function cc32() {};

        import {crc32} from ‘crc32’;

        留意大括号的区别(“{}”)。

 

    19.7、模块的继承

        export * from ‘circle’

        表示输出circle模块的所有属性和方法。

 

    19.8、ES6模块加载的实质

        ES6模块加载机制与commonjs模块完全不同。commons模块输出的是一个值的拷贝，而ES6模块输出的是值的引用。

 

    19.9、循环加载

        commonjs模块的加载原理：加载时执行，即代码在require 时就会全部执行；一旦出现“循环加载”，就只输出已经执行的部分，还未执行的部分不输出。

        ES6模块是动态引用，遇到模块加载命令import时不会去执行模块，只是生成饮用，开发者自己保证取值时能够真正取到值。

 

    19.10、ES6模块的转码

        除babel可以转外，一下两种方法也可以：

        a、ES6 module transpiler

        b、systemJS 

 

二十、编程风格［可参阅jscs.info］

    20.1、块级作用域

        let 取代 var；

        全局常量和线程安全：建议使用const而非let；

 

    20.2、字符串

        一律使用单引号或者反引号；const b = `foo${a}bar`;

 

    20.3、解构赋值

        数组成员对变量赋值，优先解构赋值。

 

    20.4、对象

        a、单行定义的对象，最后一个成员不以逗号结尾。多行定义的对象需要。

        b、对象尽量静态化，一旦定义，就不得随意添加新的属性。

            const a = {x: null};

            a.x = 3;

        c、如果对象属性名是动态的，在创建时，使用属性表达式定义。

            const obj ＝ {

                id: 5,

                [getKey(‘enabled’)]: true

            }

        d、对象的属性和方法尽量采用简洁表达法，易于描述和书写：

            const atom = {

                ref, //ref: ref

                addValue(value) {

                    return atom.value + value;

                }

            }

 

    20.5、数组

        使用扩展运算符（...）复制数组。

        const itemsCopy = […list];

 

    20.6、函数

        a、立即执行函数使用箭头函数

            (() => {

                console.log(‘Welecome to the Internet.');

            })();

        b、使用函数表达式的场合，使用箭头函数

            [1, 2, 3].map([x] => {

                return x*x;

            })

        c、箭头函数代替Function.prototype.bind，不应再用self/_this/that绑定this.

            const boundMethod = (…params) => method.apply(this, params);

        d、简单的、单行的、不会复用的函数，建议采用箭头函数。

        e、所有配置项都应该集中在一个对象，放在最后一个参数，布尔值不可以直接作为参数：

            function divide(a, b, {option = false} = {})

        f、不再函数体内使用arguments变量，使用(…)代替：

            function all(…args) {

                return args.join('');

            }

        g、默认值语法设置函数参数的默认值：

            function handle(opts = {}){}

 

    20.7、map结构

        注意区分object和map，如果只是需要key:value的数据结构，则使用map。

 

    20.8、class    

        a、用class取代需要prototype的操作。

        b、使用extends实现继承

 

    20.9、模块

        a、module语法是javascript模块的标准写法，使用import取代require；

        b、使用export取代module.exports;

        c、export default不要与普通export同时使用；

        d、不要再模块输入中使用通配符*;

 

    20.10、eslint的使用

        其是一个语法规则和代码风格检查工具，可以确保语法正确、风格统一。