ES6笔记

作者: 78f40c91f815 | 来源:发表于2018-06-27 16:29 被阅读2098次

    ES6

    http://es6.ruanyifeng.com

    目录

    <a href = "#let 和 const 命令">1 let 和 const 命令</a>

    <a href = "#变量的解构赋值">2 变量的解构赋值</a>

    <a href = "#字符串的扩展">3 字符串的扩展</a>

    <a href = "#正则的扩展">4 正则的扩展</a>

    <a href = "#数值的扩展">5 数值的扩展</a>

    <a href = "#函数的扩展">6 函数的扩展</a>

    <a href = "#数组的扩展">7 数组的扩展</a>

    <a href = "#对象的扩展">8 对象的扩展</a>

    <a href = "#Symbol">9 Symbol</a>

    <a href = "#Set 和 Map 数据结构">10 Set 和 Map 数据结构</a>

    <a href = "#Proxy">11 Proxy</a>

    <a href = "#Reflect">12 Reflect</a>

    <a href = "#Promise 对象">13 Promise 对象</a>

    <a href = "#Iterator 和 for……of 循环">14 Iterator 和 for……of 循环</a>

    <a href = "#Generator 函数的语法">15 Generator 函数的语法</a>

    <a href = "#Generator 函数的异步应用">16 Generator 函数的异步应用</a>

    <a href = "#async 函数">17 async 函数</a>

    <a href = "#Class 的基本语法">18 Class 的基本语法</a>

    <a href = "#Class 的继承">19 Class 的继承</a>

    <a href = "#Decorator">20 Decorator</a>

    <a href = "#Module 的语法">21 Module 的语法</a>

    <a href = "#Module 的加载实现">22 Module 的加载实现</a>

    <a href = "#编程风格">23 编程风格</a>

    <a href = "#读懂规格">24 读懂规格</a>

    <a href = "#ArrayBuffer">25 ArrayBuffer</a>

    1 let 和 const 命令 <a id = "let 和 const 命令"></a>

    1.1 let 命令

    基本用法

    • let 声明块级作用域变量。
    var a = [];
    for (let i = 0; i < 10; i++) {
      a[i] = function () {
        console.log(i);
      };
    }
    a[6](); // 6
    
    • for 循环有一个特别之处,就是设置循环变量的那部分是一个父作用域,而循环体内部是一个单独的子作用域。

    不存在变量提升

    • let 声明的变量一定要在声明后使用。

    暂时性死区

    • ES6 明确规定,如果区块中存在let和const命令,这个区块对这些命令声明的变量,从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量,就会报错。全局变量不对其产生影响。

    • 在代码块内,使用let命令声明变量之前,该变量都是不可用的。这在语法上,称为“暂时性死区”(temporal dead zone,简称 TDZ)。

    不允许重复声明

    • let不允许在相同作用域内,重复声明同一个变量。

    1.2 块级作用域

    1.3 const 命令

    基本用法

    • const 声明一个只读的常量,所以,在声明的时候就应该赋值。

    本质

    • const实际上保证的,并不是变量的值不得改动,而是变量指向的那个内存地址不得改动。对于简单类型的数据(数值、字符串、布尔值),值就保存在变量指向的那个内存地址,因此等同于常量。但对于复合类型的数据(主要是对象和数组),变量指向的内存地址,保存的只是一个指针,const只能保证这个指针是固定的,至于它指向的数据结构是不是可变的,就完全不能控制了。

    • 如果真的想将对象冻结,应该使用Object.freeze方法。

    • 除了将对象本身冻结,对象的属性也应该冻结。下面是一个将对象彻底冻结的函数。

    var constantize = (obj) => {
      Object.freeze(obj);
      Object.keys(obj).forEach( (key, i) => {
        if ( typeof obj[key] === 'object' ) {
          constantize( obj[key] );
        }
      });
    };
    

    ES6 声明变量的六种方法

    • ES5:var、function

    • ES6:var、function、let、const、import、class

    1.4 顶层对象的属性

    • 顶层对象,在浏览器环境指的是window对象,在 Node 指的是global对象。ES5 之中,顶层对象的属性与全局变量是等价的。

    • ES6 为了改变这一点,一方面规定,为了保持兼容性,var命令和function命令声明的全局变量,依旧是顶层对象的属性;另一方面规定,let命令、const命令、class命令声明的全局变量,不属于顶层对象的属性。也就是说,从 ES6 开始,全局变量将逐步与顶层对象的属性脱钩。

    1.5 global 对象

    • ES5 的顶层对象,本身也是一个问题,因为它在各种实现里面是不统一的。

    • 垫片库 system.global 可以在所有环境拿到global。

    2 变量的解构赋值 <a id = "变量的解构赋值"></a>

    2.1 数组的解构赋值

    基本用法

    • ES6 允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)。
    let [a, b, c] = [1, 2, 3];
    

    默认值

    • 注意,ES6 内部使用严格相等运算符(===),判断一个位置是否有值。所以,只有当一个数组成员严格等于undefined,默认值才会生效。

    2.2 对象的解构赋值

    • 对象的解构与数组有一个重要的不同。数组的元素是按次序排列的,变量的取值由它的位置决定;而对象的属性没有次序,变量必须与属性同名,才能取到正确的值。

    • 对象的解构也可以指定默认值。默认值生效的条件是,对象的属性值严格等于undefined。

    • 如果将一个已经声明的变量用于解构赋值,需要注意,要用小括号将整个赋值语句包围起来。防止 JavaScript 引擎碰到行首的大括号将其解释为代码块。

    • 由于数组本质是特殊的对象,因此可以对数组进行对象属性的解构。

    let arr = [1, 2, 3];
    let {0 : first, [arr.length - 1] : last} = arr;
    first // 1
    last // 3
    

    2.3 字符串的解构赋值

    • 字符串也可以解构赋值。这是因为此时,字符串被转换成了一个类似数组的对象。
    const [a, b, c, d, e] = 'hello';
    a // "h"
    b // "e"
    c // "l"
    d // "l"
    e // "o"
    
    • 类似数组的对象都有一个length属性,因此还可以对这个属性解构赋值。
    let {length : len} = 'hello';
    len // 5
    

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

    • 解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。
    let {toString: s} = 123;
    s === Number.prototype.toString // true
    
    let {toString: s} = true;
    s === Boolean.prototype.toString // true
    

    上面代码中,数值和布尔值的包装对象都有toString属性,因此变量s都能取到值。

    • 解构赋值的规则是,只要等号右边的值不是对象或数组,就先将其转为对象。由于undefined和null无法转为对象,所以对它们进行解构赋值,都会报错。
    let { prop: x } = undefined; // TypeError
    let { prop: y } = null; // TypeError
    

    2.5 函数参数的解构赋值

    2.6 圆括号问题

    不能使用圆括号的情况

    • 变量声明语句
    // 全部报错
    let [(a)] = [1];
    
    let {x: (c)} = {};
    let ({x: c}) = {};
    let {(x: c)} = {};
    let {(x): c} = {};
    
    let { o: ({ p: p }) } = { o: { p: 2 } };
    

    上面 6 个语句都会报错,因为它们都是变量声明语句,模式不能使用圆括号。

    • 函数参数

    函数参数也属于变量声明,因此不能带有圆括号。

    // 报错
    function f([(z)]) { return z; }
    // 报错
    function f([z,(x)]) { return x; }
    
    • 赋值语句的模式
    // 全部报错
    ({ p: a }) = { p: 42 };
    ([a]) = [5];
    

    上面代码将整个模式放在圆括号之中,导致报错。

    // 报错
    [({ p: a }), { x: c }] = [{}, {}];
    

    上面代码将一部分模式放在圆括号之中,导致报错。

    可以使用圆括号的情况

    • 赋值语句的非模式部分可以使用圆括号。

    2.7 用途

    交换变量的值

    let x = 1;
    let y = 2;
    
    [x, y] = [y, x];
    

    从函数返回多个值

    • 函数只能返回一个值,如果要返回多个值,只能将它们放在数组或对象里返回。有了解构赋值,取出这些值就非常方便。
    // 返回一个数组
    
    function example() {
      return [1, 2, 3];
    }
    let [a, b, c] = example();
    
    // 返回一个对象
    
    function example() {
      return {
        foo: 1,
        bar: 2
      };
    }
    let { foo, bar } = example();
    

    函数参数的定义

    提取 json 数据

    函数参数的默认值

    jQuery.ajax = function (url, {
      async = true,
      beforeSend = function () {},
      cache = true,
      complete = function () {},
      crossDomain = false,
      global = true,
      // ... more config
    } = {}) {
      // ... do stuff
    };
    

    指定参数的默认值,就避免了在函数体内部再写var foo = config.foo || 'default foo';这样的语句。

    遍历 Map 结构

    • 任何部署了 Iterator 接口的对象,都可以用for...of循环遍历。Map 结构原生支持 Iterator 接口,配合变量的解构赋值,获取键名和键值就非常方便。
    const map = new Map();
    map.set('first', 'hello');
    map.set('second', 'world');
    
    for (let [key, value] of map) {
      console.log(key + " is " + value);
    }
    // first is hello
    // second is world
    

    如果只想获取键名,或者只想获取键值,可以写成下面这样。

    // 获取键名
    for (let [key] of map) {
      // ...
    }
    
    // 获取键值
    for (let [,value] of map) {
      // ...
    }
    

    输入模块的指定方法

    • 加载模块时,往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰。
    const { SourceMapConsumer, SourceNode } = require("source-map");
    

    3 字符串的扩展 <a id = "字符串的扩展"></a>

    3.1 字符的 Unicode 表示法

    • JavaScript 允许采用 \uxxx 形式表示一个字符。但是,超过 \u0000 ~ \uFFFF 之间的字符必须用两个双字节的形式表示。

    • ES6 对这一点做出了改进,只需要将码点放入大括号。

    "\u{20BB7}"
    // "𠮷"
    
    "\u{41}\u{42}\u{43}"
    // "ABC"
    
    let hello = 123;
    hell\u{6F} // 123
    
    '\u{1F680}' === '\uD83D\uDE80'
    // true
    

    3.2 codePointAt()

    • JavaScript 内部,字符以 UTF-16 的格式储存,每个字符固定为2个字节。对于那些需要4个字节储存的字符(Unicode 码点大于0xFFFF的字符),JavaScript 会认为它们是两个字符。
    var s = "𠮷";
    
    s.length // 2
    s.charAt(0) // ''
    s.charAt(1) // ''
    s.charCodeAt(0) // 55362
    s.charCodeAt(1) // 57271
    
    • ES6 提供了codePointAt方法,能够正确处理 4 个字节储存的字符,返回一个字符的码点。
    let s = '𠮷a';
    
    s.codePointAt(0) // 134071
    s.codePointAt(1) // 57271
    
    s.codePointAt(2) // 97
    
    • 为了正确遍历字符串,可以使用 for……of 循环。因为它会正确识别 32 位的 UFT-16 字符。
    let s = '𠮷a';
    for (let ch of s) {
      console.log(ch.codePointAt(0).toString(16));
    }
    // 20bb7
    // 61
    
    • codePointAt方法是测试一个字符由两个字节还是由四个字节组成的最简单方法。
    function is32Bit(c) {
      return c.codePointAt(0) > 0xFFFF;
    }
    
    is32Bit("𠮷") // true
    is32Bit("a") // false
    

    3.3 String.fromCodePoint()

    • ES5 提供String.fromCharCode方法,用于从码点返回对应字符,但是这个方法不能识别 32 位的 UTF-16 字符(Unicode 编号大于0xFFFF)。

    • ES6 提供了String.fromCodePoint方法,可以识别大于0xFFFF的字符,弥补了String.fromCharCode方法的不足。在作用上,正好与codePointAt方法相反。

    String.fromCodePoint(0x20BB7)
    // "𠮷"
    String.fromCodePoint(0x78, 0x1f680, 0x79) === 'x\uD83D\uDE80y'
    // true
    

    上面代码中,如果String.fromCodePoint方法有多个参数,则它们会被合并成一个字符串返回。

    • 注意,fromCodePoint方法定义在String对象上,而codePointAt方法定义在字符串的实例对象上。

    3.4 字符串的遍历器接口

    • ES6 为字符串添加了遍历器接口(详见《Iterator》一章),使得字符串可以被 for……of 循环遍历。

    3.5 at()

    • 为了解决 charAt 无法识别码点大于 0xFFFF 的字符的问题,目前有一个提案,提出字符串实例的 at 方法,可以识别 Unicode 编码大于 0xFFFF 的字符,返回正确的字符。——这个方法可以通过垫片库实现。

    3.6 normalize()

    • normalize方法可以接受一个参数来指定normalize的方式,参数的四个可选值如下。

      - NFC,默认参数,表示“标准等价合成”(Normalization Form Canonical Composition),返回多个简单字符的合成字符。所谓“标准等价”指的是视觉和语义上的等价。

      - NFD,表示“标准等价分解”(Normalization Form Canonical Decomposition),即在标准等价的前提下,返回合成字符分解的多个简单字符。

      - NFKC,表示“兼容等价合成”(Normalization Form Compatibility Composition),返回合成字符。所谓“兼容等价”指的是语义上存在等价,但视觉上不等价,比如“囍”和“喜喜”。(这只是用来举例,normalize方法不能识别中文。)

      - NFKD,表示“兼容等价分解”(Normalization Form Compatibility Decomposition),即在兼容等价的前提下,返回合成字符分解的多个简单字符。

    '\u004F\u030C'.normalize('NFC').length // 1
    '\u004F\u030C'.normalize('NFD').length // 2
    

    3.7 includes(),startsWith(),endsWith()

    • 传统上,JavaScript 只有indexOf方法,可以用来确定一个字符串是否包含在另一个字符串中。ES6 又提供了三种新方法。

      - includes():返回布尔值,表示是否找到了参数字符串。

      - startsWith():返回布尔值,表示参数字符串是否在原字符串的头部。

      - endsWith():返回布尔值,表示参数字符串是否在原字符串的尾部。

    let s = 'Hello world!';
    
    s.startsWith('Hello') // true
    s.endsWith('!') // true
    s.includes('o') // true
    
    • 这三个方法都支持第二个参数,表示开始搜索的位置。
    let s = 'Hello world!';
    
    s.startsWith('world', 6) // true
    s.endsWith('Hello', 5) // true
    s.includes('Hello', 6) // false
    

    上面代码表示,使用第二个参数n时,endsWith的行为与其他两个方法有所不同。它针对前n个字符,而其他两个方法针对从第n个位置直到字符串结束。

    3.8 repeat()

    • repeat 方法返回一个新字符串,表示将原字符串重复 n 次。

    3.9 padStart(),padEnd()

    • ES2017 引入了字符串补全长度的功能。如果某个字符串不够指定长度,会在头部或尾部补全。padStart()用于头部补全,padEnd()用于尾部补全。
    'x'.padStart(5, 'ab') // 'ababx'
    'x'.padStart(4, 'ab') // 'abax'
    
    'x'.padEnd(5, 'ab') // 'xabab'
    'x'.padEnd(4, 'ab') // 'xaba'
    

    上面代码中,padStart和padEnd一共接受两个参数,第一个参数用来指定字符串的最小长度,第二个参数是用来补全的字符串。

    • padStart 的常见用途是为数值补全指定位数。
    '1'.padStart(10, '0') // "0000000001"
    '12'.padStart(10, '0') // "0000000012"
    '123456'.padStart(10, '0') // "0000123456"
    
    • 另一个用途是提示字符串格式
    '12'.padStart(10, 'YYYY-MM-DD') // "YYYY-MM-12"
    '09-12'.padStart(10, 'YYYY-MM-DD') // "YYYY-09-12"
    

    3.10 matchAll()

    • matchall 方法返回一个正则表达式在当前字符串的所有匹配,详见《正则的扩展》的一章。

    3.11 模板字符串

    • 模板字符串(template string)是增强版的字符串,用反引号(`)标识。

    • 模板字符串中嵌入变量,需要将变量名写在 ${} 之中。

    • 大括号内部可以放入任意的 JavaScript 表达式,可以进行运算,以及引用对象属性。

    • 模板字符串之中还能调用函数。

    • 模板字符串甚至还能嵌套

    const tmpl = addrs => `
      <table>
      ${addrs.map(addr => `
        <tr><td>${addr.first}</td></tr>
        <tr><td>${addr.last}</td></tr>
      `).join('')}
      </table>
    `;
    

    上面代码中,模板字符串的变量之中,又嵌入了另一个模板字符串,使用方法如下。

    const data = [
        { first: '<Jane>', last: 'Bond' },
        { first: 'Lars', last: '<Croft>' },
    ];
    
    console.log(tmpl(data));
    // <table>
    //
    //   <tr><td><Jane></td></tr>
    //   <tr><td>Bond</td></tr>
    //
    //   <tr><td>Lars</td></tr>
    //   <tr><td><Croft></td></tr>
    //
    // </table>
    

    3.12 实例:模板编译

    3.13 标签模板

    • 模板字符串可以紧跟在一个函数名后面,该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能(tagged template)。
    alert`123`
    // 等同于
    alert(123)
    

    标签模板其实不是模板,而是函数调用的一种特殊形式。“标签”指的就是函数,紧跟在后面的模板字符串就是它的参数。

    • 但是,如果模板字符里面有变量,就不是简单的调用了,而是会将模板字符串先处理成多个参数,再调用函数。

    • 模板处理函数的第一个参数(模板字符串数组),还有一个raw属性,保存的是转义后的原字符串。

    3.14 String.raw()

    • ES6 还为原生的 String 对象,提供了一个 raw 方法。

    • String.raw 方法,往往用来充当模板字符串的处理函数,返回一个斜杠都被转义(即斜杠前面再加一个斜杠)的字符串,对应于替换变量后的模板字符串。

    String.raw`Hi\n${2+3}!`;
    // 返回 "Hi\\n5!"
    
    String.raw`Hi\u000A!`;
    // 返回 "Hi\\u000A!"
    
    • String.raw 方法也可以作为正常的函数使用。这时,它的第一个参数,应该是一个具有raw属性的对象,且raw属性的值应该是一个数组。
    String.raw({ raw: 'test' }, 0, 1, 2);
    // 't0e1s2t'
    
    // 等同于
    String.raw({ raw: ['t','e','s','t'] }, 0, 1, 2);
    

    3.15 模板字符串

    • 前面提到标签模板里面,可以内嵌其他语言。但是,模板字符串默认会将字符串转义,导致无法嵌入其他语言。

    • 为了解决这个问题,ES2018 放松了对标签模板里面的字符串转义的限制。如果遇到不合法的字符串转义,就返回undefined,而不是报错,并且从raw属性上面可以得到原始字符串。

    4 正则的扩展 <a id = "正则的扩展"></a>

    4.1 RegExp 构造函数

    • 在 ES5 中,RegExp 构造函数的参数为正则表达式时,不允许使用第二个参数添加修饰符。ES6 改变了这种行为——可以使用第二个参数,返回的正则表达式会忽略原有的正则表达式的修饰符。

    4.2 字符串的正则方法

    • 字符串对象共有 4 个方法,可以使用正则表达式:match()、replace()、search()和split()。

    ES6 将这 4 个方法,在语言内部全部调用RegExp的实例方法,从而做到所有与正则相关的方法,全都定义在RegExp对象上。

      - String.prototype.match 调用 RegExp.prototype[Symbol.match]

      - String.prototype.replace 调用 RegExp.prototype[Symbol.replace]

      - String.prototype.search 调用 RegExp.prototype[Symbol.search]

      - String.prototype.split 调用 RegExp.prototype[Symbol.split]

    4.3 u 修饰符

    • ES6 对正则表达式添加了u修饰符,含义为“Unicode 模式”,用来正确处理大于\uFFFF的 Unicode 字符。也就是说,会正确处理四个字节的 UTF-16 编码。
    /^\uD83D/u.test('\uD83D\uDC2A') // false
    /^\uD83D/.test('\uD83D\uDC2A') // true
    

    4.4 RegExp.prototype.unicode 属性

    • 正则实例对象新增unicode属性,表示是否设置了u修饰符。
    const r1 = /hello/;
    const r2 = /hello/u;
    
    r1.unicode // false
    r2.unicode // true
    

    4.5 y 修饰符

    • 除了 u 修饰符,ES6 还为正则表达式添加了 y 修饰符,叫做 “粘连” (sticky)修饰符。

    y修饰符的作用与g修饰符类似,也是全局匹配,后一次匹配都从上一次匹配成功的下一个位置开始。不同之处在于,g修饰符只要剩余位置中存在匹配就可,而y修饰符确保匹配必须从剩余的第一个位置开始,这也就是“粘连”的涵义。

    • 实际上,y修饰符号隐含了头部匹配的标志^。

    4.6 RegExp.prototype.sticky 属性

    • 与y修饰符相匹配,ES6 的正则实例对象多了sticky属性,表示是否设置了y修饰符。

    4.7 RegExp.prototype.flags 属性

    • ES6 为正则表达式新增了flags属性,会返回正则表达式的修饰符。
    // ES5 的 source 属性
    // 返回正则表达式的正文
    /abc/ig.source
    // "abc"
    
    // ES6 的 flags 属性
    // 返回正则表达式的修饰符
    /abc/ig.flags
    // 'gi'
    

    4.8 s 修饰符:dotAll 模式

    • 正则表达式中,点(.)是一个特殊字符,代表任意的单个字符,但是有两个例外。一个是四个字节的 UTF-16 字符,这个可以用u修饰符解决;另一个是行终止符(line terminator character)。

    所谓行终止符,就是该字符表示一行的终结。以下四个字符属于”行终止符“。

      - U+000A 换行符(\n)

      - U+000D 回车符(\r)

      - U+2028 行分隔符(line separator)

      - U+2029 段分隔符(paragraph separator)

    • 很多时候我们希望匹配的是任意单个字符,这时有一种变通的写法。
    /foo[^]bar/.test('foo\nbar')
    // true
    
    • ES2018 引入s修饰符,使得.可以匹配任意单个字符。
    /foo.bar/s.test('foo\nbar') // true
    

    这被称为dotAll模式,即点(dot)代表一切字符。所以,正则表达式还引入了一个dotAll属性,返回一个布尔值,表示该正则表达式是否处在dotAll模式。

    4.9 后行断言

    http://es6.ruanyifeng.com/#docs/regex#后行断言

    4.10 Unicode 属性类

    • ES2018 引入了一种新的类的写法\p{...}和\P{...},允许正则表达式匹配符合 Unicode 某种属性的所有字符。
    const regexGreekSymbol = /\p{Script=Greek}/u;
    regexGreekSymbol.test('π') // true
    

    上面代码中,\p{Script=Greek}指定匹配一个希腊文字母,所以匹配π成功。

    • Unicode 属性类要指定属性名和属性值。
    \p{UnicodePropertyName=UnicodePropertyValue}
    
    • 对于某些属性,可以只写属性名,或者只写属性值。
    \p{UnicodePropertyName}
    \p{UnicodePropertyValue}
    
    • \P{…}是\p{…}的反向匹配,即匹配不满足条件的字符。

    • 注意,这两种类只对 Unicode 有效,所以使用的时候一定要加上u修饰符。如果不加u修饰符,正则表达式使用\p和\P会报错,ECMAScript 预留了这两个类。

    4.11 具名组匹配

    简介

    • ES2018 引入了具名组匹配(Named Capture Groups),允许为每一个组匹配指定一个名字,既便于阅读代码,又便于引用。
    const RE_DATE = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
    
    const matchObj = RE_DATE.exec('1999-12-31');
    const year = matchObj.groups.year; // 1999
    const month = matchObj.groups.month; // 12
    const day = matchObj.groups.day; // 31
    

    解构赋值和替换

    引用

    • 如果要在正则表达式内部引用某个“具名组匹配”,可用使用 \k<组名> 的写法。

    • 数字引用 (\1) 依然有效。

    4.12 String.prototype.matchAll

    5 数值的扩展 <a id = "数值的扩展"></a>

    5.1 二进制和八进制表示法

    • ES6 提供了二进制和八进制数值的新的写法,分别用前缀 0b(或 0B)和 0o(或 0O)表示。

    • 从 ES5 开始,在严格模式之中,八进制就不再允许使用前缀0表示,ES6 进一步明确,要使用前缀0o表示。

    5.2 Number.isFinite(),Number.isNaN()

    • Number.isFinite()用来检查一个数值是否为有限的(finite),即不是Infinity。

    • 注意,如果参数类型不是数值,Number.isFinite一律返回false。

    • Number.isNaN()用来检查一个值是否为NaN。

    • 如果参数类型不是NaN,Number.isNaN一律返回false。

    • 它们与传统的全局方法isFinite()和isNaN()的区别在于,传统方法先调用Number()将非数值的值转为数值,再进行判断,而这两个新方法只对数值有效,Number.isFinite()对于非数值一律返回false, Number.isNaN()只有对于NaN才返回true,非NaN一律返回false。

    5.3 Number.parseInt(),Number.parseFloat()

    • ES6 将全局方法parseInt()和parseFloat(),移植到Number对象上面,行为完全保持不变。

    5.4 Number.isInteger()

    • Number.isInteger()用来判断一个数值是否为整数。

    JavaScript 内部,整数和浮点数采用的是同样的储存方法,所以 25 和 25.0 被视为同一个值。

    • 注意,由于 JavaScript 采用 IEEE 754 标准,数值存储为64位双精度格式,数值精度最多可以达到 53 个二进制位(1 个隐藏位与 52 个有效位)。如果数值的精度超过这个限度,第54位及后面的位就会被丢弃,这种情况下,Number.isInteger可能会误判。
    Number.isInteger(3.0000000000000002) // true
    

    上面代码中,Number.isInteger的参数明明不是整数,但是会返回true。原因就是这个小数的精度达到了小数点后16个十进制位,转成二进制位超过了53个二进制位,导致最后的那个2被丢弃了。

    • 类似的情况还有,如果一个数值的绝对值小于Number.MIN_VALUE(5E-324),即小于 JavaScript 能够分辨的最小值,会被自动转为 0。这时,Number.isInteger也会误判。

    5.5 Number.EPSILON

    • ES6 在Number对象上面,新增一个极小的常量Number.EPSILON。根据规格,它表示 1 与大于 1 的最小浮点数之间的差。

    • Number.EPSILON实际上是 JavaScript 能够表示的最小精度。误差如果小于这个值,就可以认为已经没有意义了,即不存在误差了。

    • 因此,Number.EPSILON的实质是一个可以接受的最小误差范围。

    5.6 安全整数和 Number.isSafeInteger()

    • JavaScript 能够准确表示的整数范围在-253到253之间(不含两个端点),超过这个范围,无法精确表示这个值。

    • ES6 引入了 Number.MAX_SAFE_INTEGERNumber.MIN_SAFE_INTEGER 这两个常量,用来表示这个范围的上下限。

    • Number.isSafeInteger()则是用来判断一个整数是否落在这个范围之内。

    5.7 Math 对象的扩展

    • ES6 在 Math 对象上新增了 17 个与数学相关的方法。所有这些方法都是静态方法,只能在 Math 对象上调用。

    Math.trunc()

    • Math.trunc 方法用于去除一个数的小数部分,返回整数部分。

    • 对于非数值,Math.trunc内部使用Number方法将其先转为数值。

    • 对于空值和无法截取整数的值,返回NaN。

    • 对于没有部署这个方法的环境,可以用下面的代码模拟。

    Math.trunc = Math.trunc || function(x) {
      return x < 0 ? Math.ceil(x) : Math.floor(x);
    };
    

    Math.sign()

    • Math.sign方法用来判断一个数到底是正数、负数、还是零。对于非数值,会先将其转换为数值。

    它会返回五种值。

      - 参数为正数,返回+1;

      - 参数为负数,返回-1;

      - 参数为 0,返回0;

      - 参数为-0,返回-0;

      - 其他值,返回NaN。

    • 对于没有部署这个方法的环境,可以用下面的代码模拟。
    Math.sign = Math.sign || function(x) {
      x = +x; // convert to a number
      if (x === 0 || isNaN(x)) {
        return x;
      }
      return x > 0 ? 1 : -1;
    };
    

    Math.cbrt()

    • Math.cbrt 方法用于计算一个数的立方根。

    • 对于非数值,Math.cbrt方法内部也是先使用Number方法将其转为数值。

    • 对于没有部署这个方法的环境,可以用下面的代码模拟。

    Math.cbrt = Math.cbrt || function(x) {
      var y = Math.pow(Math.abs(x), 1/3);
      return x < 0 ? -y : y;
    };
    

    Math.clz32()

    • JavaScript 的整数使用 32 位二进制形式表示,Math.clz32方法返回一个数的 32 位无符号整数形式有多少个前导 0。
    Math.clz32(0) // 32
    Math.clz32(1) // 31
    Math.clz32(1000) // 22
    Math.clz32(0b01000000000000000000000000000000) // 1
    Math.clz32(0b00100000000000000000000000000000) // 2
    
    • 左移运算符(<<)与Math.clz32方法直接相关。
    Math.clz32(0) // 32
    Math.clz32(1) // 31
    Math.clz32(1 << 1) // 30
    Math.clz32(1 << 2) // 29
    Math.clz32(1 << 29) // 2
    
    • 对于小数,Math.clz32方法只考虑整数部分。
    Math.clz32(3.2) // 30
    Math.clz32(3.9) // 30
    
    • 对于空值或其他类型的值,Math.clz32方法会将它们先转为数值,然后再计算。
    Math.clz32() // 32
    Math.clz32(NaN) // 32
    Math.clz32(Infinity) // 32
    Math.clz32(null) // 32
    Math.clz32('foo') // 32
    Math.clz32([]) // 32
    Math.clz32({}) // 32
    Math.clz32(true) // 31
    

    Math.imul()

    • Math.imul 方法返回两个数以 32 位带符号整数形式相乘的结果,返回的也是一个 32 位的带符号整数。

    • 一般情况下,Math.imul 和 * 号的结果相同,但在数值很大,超过 JavaScript 的精度限制的情况下,Math.imul 可以返回正确的值。

    Math.fround()

    • Math.fround方法返回一个数的32位单精度浮点数形式。

    • 对于32位单精度格式来说,数值精度是24个二进制位(1 位隐藏位与 23 位有效位),所以对于 -224 至 224 之间的整数(不含两个端点),返回结果与参数本身一致。

    • Math.fround方法的主要作用,是将64位双精度浮点数转为32位单精度浮点数。如果小数的精度超过24个二进制位,返回值就会不同于原值,否则返回值不变(即与64位双精度值一致)。

    • 对于没有部署这个方法的环境,可以用下面的代码模拟。

    Math.fround = Math.fround || function (x) {
      return new Float32Array([x])[0];
    };
    

    Math.hypot()

    • Math.hypot方法返回所有参数的平方和的平方根。

    对数方法

    • ES6 新增了 4 个对数相关方法
    Math.expm1()
    • Math.expm1(x)返回 ex - 1,即Math.exp(x) - 1。
    Math.log1p()
    • Math.log1p(x)方法返回1 + x的自然对数,即Math.log(1 + x)。如果x小于-1,返回NaN。
    Math.log10()
    • Math.log10(x) 返回以 10 为底的x的对数。如果x小于 0,则返回 NaN。
    Math.log2()
    • Math.log2(x) 返回以 2 为底的x的对数。如果x小于 0,则返回 NaN。

    双曲函数方法

    • ES6 新增了 6 个双曲函数方法。

      - Math.sinh(x) 返回x的双曲正弦(hyperbolic sine)

      - Math.cosh(x) 返回x的双曲余弦(hyperbolic cosine)

      - Math.tanh(x) 返回x的双曲正切(hyperbolic tangent)

      - Math.asinh(x) 返回x的反双曲正弦(inverse hyperbolic sine)

      - Math.acosh(x) 返回x的反双曲余弦(inverse hyperbolic cosine)

      - Math.atanh(x) 返回x的反双曲正切(inverse hyperbolic tangent)

    5.8 指数运算符

    • ES6 新增了一个指数运算符(**)。

    • 注意,在 V8 引擎中,指数运算符与Math.pow的实现不相同,对于特别大的运算结果,两者会有细微的差异。

    6 函数的扩展 <a id = "函数的扩展"></a>

    6.1 函数参数的默认值

    基本用法

    • ES6 允许为函数的参数设置默认值,即直接写在参数定义的后面。
    function log(x, y = 'World') {
      console.log(x, y);
    }
    
    log('Hello') // Hello World
    log('Hello', 'China') // Hello China
    log('Hello', '') // Hello
    
    • 参数变量是默认声明的,所以不能用 let 或 const 再次声明。
    function foo(x = 5) {
      let x = 1; // error
      const x = 2; // error
    }
    

    与解构赋值默认值结合使用

    • 参数默认值可以与解构赋值的默认值结合起来使用。
    function foo({x, y = 5}) {
      console.log(x, y);
    }
    
    foo({}) // undefined 5
    foo({x: 1}) // 1 5
    foo({x: 1, y: 2}) // 1 2
    foo() // TypeError: Cannot read property 'x' of undefined
    

    如果函数foo调用时没提供参数,变量x和y就不会生成,从而报错。通过提供函数参数的默认值,就可以避免这种情况。

    function foo({x, y = 5} = {}) {
      console.log(x, y);
    }
    
    foo() // undefined 5
    
    • 作为练习,请问下面两种写法有什么差别?
    // 写法一
    function m1({x = 0, y = 0} = {}) {
      return [x, y];
    }
    
    // 写法二
    function m2({x, y} = { x: 0, y: 0 }) {
      return [x, y];
    }
    

    上面两种写法都对函数的参数设定了默认值,区别是写法一函数参数的默认值是空对象,但是设置了对象解构赋值的默认值;写法二函数参数的默认值是一个有具体属性的对象,但是没有设置对象解构赋值的默认值。

    // 函数没有参数的情况
    m1() // [0, 0]
    m2() // [0, 0]
    
    // x 和 y 都有值的情况
    m1({x: 3, y: 8}) // [3, 8]
    m2({x: 3, y: 8}) // [3, 8]
    
    // x 有值,y 无值的情况
    m1({x: 3}) // [3, 0]
    m2({x: 3}) // [3, undefined]
    
    // x 和 y 都无值的情况
    m1({}) // [0, 0];
    m2({}) // [undefined, undefined]
    
    m1({z: 3}) // [0, 0]
    m2({z: 3}) // [undefined, undefined]
    

    参数默认值的位置

    • 通常情况下,定义了默认值的参数,应该是函数的尾参数。因为这样比较容易看出来,到底省略了哪些参数。如果非尾部的参数设置默认值,实际上这个参数是没法省略的。

    函数的 length 属性

    • 指定了默认值以后,函数 length 属性将返回指定默认值的参数前面的参数的个数。

    • 后文的 rest 参数也不计入 length 属性。

    作用域

    • 一旦设置了参数的默认值,函数进行声明初始化时,参数会形成一个单独的作用域(context)。等到初始化结束,这个作用域就会消失。这种语法行为,在不设置参数默认值时,是不会出现的。
    var x = 1;
    
    function f(x, y = x) {
      console.log(y);
    }
    
    f(2) // 2
    

    上面代码中,参数y的默认值等于变量x。调用函数f时,参数形成一个单独的作用域。在这个作用域里面,默认值变量x指向第一个参数x,而不是全局变量x,所以输出是2。

    再看下面的例子。

    let x = 1;
    
    function f(y = x) {
      let x = 2;
      console.log(y);
    }
    
    f() // 1
    

    上面代码中,函数f调用时,参数y = x形成一个单独的作用域。这个作用域里面,变量x本身没有定义,所以指向外层的全局变量x。函数调用时,函数体内部的局部变量x影响不到默认值变量x。

    如果此时,全局变量x不存在,就会报错。

    function f(y = x) {
      let x = 2;
      console.log(y);
    }
    
    f() // ReferenceError: x is not defined
    下面这样写,也会报错。
    
    var x = 1;
    
    function foo(x = x) {
      // ...
    }
    
    foo() // ReferenceError: x is not defined
    

    上面代码中,参数x = x形成一个单独作用域。实际执行的是let x = x,由于暂时性死区的原因,这行代码会报错”x 未定义“。

    如果参数的默认值是一个函数,该函数的作用域也遵守这个规则。请看下面的例子。

    let foo = 'outer';
    
    function bar(func = () => foo) {
      let foo = 'inner';
      console.log(func());
    }
    
    bar(); // outer
    

    上面代码中,函数bar的参数func的默认值是一个匿名函数,返回值为变量foo。函数参数形成的单独作用域里面,并没有定义变量foo,所以foo指向外层的全局变量foo,因此输出outer。

    如果写成下面这样,就会报错。

    function bar(func = () => foo) {
      let foo = 'inner';
      console.log(func());
    }
    
    bar() // ReferenceError: foo is not defined
    

    上面代码中,匿名函数里面的foo指向函数外层,但是函数外层并没有声明变量foo,所以就报错了。

    下面是一个更复杂的例子。

    var x = 1;
    function foo(x, y = function() { x = 2; }) {
      var x = 3;
      y();
      console.log(x);
    }
    
    foo() // 3
    x // 1
    

    上面代码中,函数foo的参数形成一个单独作用域。这个作用域里面,首先声明了变量x,然后声明了变量y,y的默认值是一个匿名函数。这个匿名函数内部的变量x,指向同一个作用域的第一个参数x。函数foo内部又声明了一个内部变量x,该变量与第一个参数x由于不是同一个作用域,所以不是同一个变量,因此执行y后,内部变量x和外部全局变量x的值都没变。

    如果将var x = 3的var去除,函数foo的内部变量x就指向第一个参数x,与匿名函数内部的x是一致的,所以最后输出的就是2,而外层的全局变量x依然不受影响。

    var x = 1;
    function foo(x, y = function() { x = 2; }) {
      x = 3;
      y();
      console.log(x);
    }
    
    foo() // 2
    x // 1
    

    应用

    • 利用参数默认值,可以指定某一个参数不得省略,如果省略就抛出一个错误。
    function throwIfMissing() {
      throw new Error('Missing parameter');
    }
    
    function foo(mustBeProvided = throwIfMissing()) {
      return mustBeProvided;
    }
    
    foo()
    // Error: Missing parameter
    
    • 另外,可以将参数默认值设为 undefined,表明这个参数时可以省略的。
    function foo(optional = undefined) { ··· }
    

    6.2 rest 参数

    • ES6 引入 rest 参数(形式为...变量名),用于获取函数的多余参数,这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组,该变量将多余的参数放入数组中。

    • 注意,rest 参数之后不能再有其他参数,否则会报错。

    // 报错
    function f(a, ...b, c) {
      // ...
    }
    

    6.3 严格模式

    • 从 ES5 开始,函数内部可以设定为严格模式。
    function doSomething(a, b) {
      'use strict';
      // code
    }
    
    • ES2016 做了一点修改,规定只要函数参数使用了默认值、解构赋值、或者扩展运算符,那么函数内部就不能显式设定为严格模式,否则会报错。

    • 这样规定的原因是,函数内部的严格模式,同时适用于函数体和函数参数。但是,函数执行的时候,先执行函数参数,然后再执行函数体。这样就有一个不合理的地方,只有从函数体之中,才能知道参数是否应该以严格模式执行,但是参数却应该先于函数体执行。

    • 两种方法可以规避这种限制。第一种是设定全局性的严格模式,这是合法的。

    • 第二种是把函数包在一个无参数的立即执行函数里面。

    6.4 name 属性

    • 函数的 name 属性,返回该函数的函数名。

    • 如果将一个匿名函数赋值给一个变量,ES5 的 name 属性会返回空字符串,而 ES6 的 name 属性会返回实际的函数名。

    var f = function () {};
    
    // ES5
    f.name // ""
    
    // ES6
    f.name // "f"
    
    • 如果将一个具名函数赋值给一个变量,则 ES5 和 ES6 的 name 属性都返回这个具名函数原本的名字。

    • Function 构造函数返回的函数实例,name 属性的值为 anonymous。

    (new Function).name // "anonymous"
    
    • bind 返回的函数,name 属性值会加上 bound 前缀。
    function foo() {};
    foo.bind({}).name // "bound foo"
    
    (function(){}).bind({}).name // "bound "
    

    6.5 箭头函数

    基本用法

    • ES6 允许使用“箭头”(=>)定义函数。
    var f = v => v;
    
    // 等同于
    var f = function (v) {
      return v;
    };
    
    • 如果箭头函数不需要参数或需要多个参数,就使用一个圆括号代表参数部分。
    var f = () => 5;
    // 等同于
    var f = function () { return 5 };
    
    var sum = (num1, num2) => num1 + num2;
    // 等同于
    var sum = function(num1, num2) {
      return num1 + num2;
    };
    
    • 由于大括号被解释为代码块,所以如果箭头函数直接返回一个对象,必须在对象外面加上括号,否则会报错。
    // 报错
    let getTempItem = id => { id: id, name: "Temp" };
    
    // 不报错
    let getTempItem = id => ({ id: id, name: "Temp" });
    
    • 箭头函数的一个用处是简化回调函数
    // 正常函数写法
    [1,2,3].map(function (x) {
      return x * x;
    });
    
    // 箭头函数写法
    [1,2,3].map(x => x * x);
    
    • 下面是 rest 参数与箭头函数结合的例子。
    const numbers = (...nums) => nums;
    
    numbers(1, 2, 3, 4, 5)
    // [1,2,3,4,5]
    
    const headAndTail = (head, ...tail) => [head, tail];
    
    headAndTail(1, 2, 3, 4, 5)
    // [1,[2,3,4,5]]
    

    使用注意点

    • (1)函数体内的this对象,就是定义时所在的对象,而不是使用时所在的对象。

    • (2)不可以当作构造函数,也就是说,不可以使用new命令,否则会抛出一个错误。

    • (3)不可以使用arguments对象,该对象在函数体内不存在。如果要用,可以用 rest 参数代替。

    • (4)不可以使用yield命令,因此箭头函数不能用作 Generator 函数。

    • this指向的固定化,并不是因为箭头函数内部有绑定this的机制,实际原因是箭头函数根本没有自己的this,导致内部的this就是外层代码块的this。正是因为它没有this,所以也就不能用作构造函数。

    • 除了this,以下三个变量在箭头函数之中也是不存在的,指向外层函数的对应变量:arguments、super、new.target。

    • 另外,由于箭头函数没有自己的this,所以当然也就不能用call()、apply()、bind()这些方法去改变this的指向。

    6.6 双冒号运算符

    • 箭头函数可以绑定this对象,大大减少了显式绑定this对象的写法(call、apply、bind)。但是,箭头函数并不适用于所有场合,所以现在有一个提案,提出了“函数绑定”(function bind)运算符,用来取代call、apply、bind调用。

    函数绑定运算符是并排的两个冒号(::),双冒号左边是一个对象,右边是一个函数。该运算符会自动将左边的对象,作为上下文环境(即this对象),绑定到右边的函数上面。

    6.7 尾调用优化

    什么是尾调用?

    • 尾调用(Tail Call)是函数式编程的一个重要概念,本身非常简单,一句话就能说清楚,就是指某个函数的最后一步是调用另一个函数。
    function f(x){
      return g(x);
    }
    

    上面代码中,函数f的最后一步是调用函数g,这就叫尾调用。

    • 以下三种情况,都不属于尾调用。
    // 情况一
    function f(x){
      let y = g(x);
      return y;
    }
    
    // 情况二
    function f(x){
      return g(x) + 1;
    }
    
    // 情况三
    function f(x){
      g(x);
    }
    

    上面代码中,情况一是调用函数g之后,还有赋值操作,所以不属于尾调用,即使语义完全一样。情况二也属于调用后还有操作,即使写在一行内。情况三等同于下面的代码。

    function f(x){
      g(x);
      return undefined;
    }
    

    尾调用不一定出现在函数尾部,只要是最后一步操作即可。

    function f(x) {
      if (x > 0) {
        return m(x)
      }
      return n(x);
    }
    

    上面代码中,函数m和n都属于尾调用,因为它们都是函数f的最后一步操作。

    尾调用优化

    • 我们知道,函数调用会在内存形成一个“调用记录”,又称“调用帧”(call frame),保存调用位置和内部变量等信息。如果在函数A的内部调用函数B,那么在A的调用帧上方,还会形成一个B的调用帧。等到B运行结束,将结果返回到A,B的调用帧才会消失。如果函数B内部还调用函数C,那就还有一个C的调用帧,以此类推。所有的调用帧,就形成一个“调用栈”(call stack)。

    尾调用由于是函数的最后一步操作,所以不需要保留外层函数的调用帧,因为调用位置、内部变量等信息都不会再用到了,只要直接用内层函数的调用帧,取代外层函数的调用帧就可以了。

    • 这就叫做“尾调用优化”(Tail call optimization),即只保留内层函数的调用帧。如果所有函数都是尾调用,那么完全可以做到每次执行时,调用帧只有一项,这将大大节省内存。这就是“尾调用优化”的意义。

    • 注意,只有不再用到外层函数的内部变量,内层函数的调用帧才会取代外层函数的调用帧,否则就无法进行“尾调用优化”。

    尾递归

    • 函数调用自身,称为递归。如果尾调用自身,就称为尾递归。

    • 递归非常耗费内存,因为需要同时保存成千上百个调用帧,很容易发生“栈溢出”错误(stack overflow)。但对于尾递归来说,由于只存在一个调用帧,所以永远不会发生“栈溢出”错误。

    function factorial(n) {
      if (n === 1) return 1;
      return n * factorial(n - 1);
    }
    
    factorial(5) // 120
    

    上面代码是一个阶乘函数,计算n的阶乘,最多需要保存n个调用记录,复杂度 O(n) 。

    如果改写成尾递归,只保留一个调用记录,复杂度 O(1) 。

    function factorial(n, total) {
      if (n === 1) return total;
      return factorial(n - 1, n * total);
    }
    
    factorial(5, 1) // 120
    

    还有一个比较著名的例子,就是计算 Fibonacci 数列,也能充分说明尾递归优化的重要性。

    非尾递归的 Fibonacci 数列实现如下。

    function Fibonacci (n) {
      if ( n <= 1 ) {return 1};
    
      return Fibonacci(n - 1) + Fibonacci(n - 2);
    }
    
    Fibonacci(10) // 89
    Fibonacci(100) // 堆栈溢出
    Fibonacci(500) // 堆栈溢出
    

    尾递归优化过的 Fibonacci 数列实现如下。

    function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {
      if( n <= 1 ) {return ac2};
    
      return Fibonacci2 (n - 1, ac2, ac1 + ac2);
    }
    
    Fibonacci2(100) // 573147844013817200000
    Fibonacci2(1000) // 7.0330367711422765e+208
    Fibonacci2(10000) // Infinity
    

    由此可见,“尾调用优化”对递归操作意义重大,所以一些函数式编程语言将其写入了语言规格。ES6 是如此,第一次明确规定,所有 ECMAScript 的实现,都必须部署“尾调用优化”。这就是说,ES6 中只要使用尾递归,就不会发生栈溢出,相对节省内存。

    递归函数的改写

    • 尾递归的实现,往往需要改写递归函数,确保最后一步只调用自身。做到这一点的方法,就是把所有用到的内部变量改写成函数的参数。但这样不是很直观。有两个方法可以解决这个问题。

    • 方法一是在尾递归函数之外,再提供一个正常形式的函数。

    function tailFactorial(n, total) {
      if (n === 1) return total;
      return tailFactorial(n - 1, n * total);
    }
    
    function factorial(n) {
      return tailFactorial(n, 1);
    }
    
    factorial(5) // 120
    
    • 函数式编程有一个概念,叫做柯里化(currying),意思是将多参数的函数转换成单参数的形式。这里也可以使用柯里化。
    function currying(fn, n) {
      return function (m) {
        return fn.call(this, m, n);
      };
    }
    
    function tailFactorial(n, total) {
      if (n === 1) return total;
      return tailFactorial(n - 1, n * total);
    }
    
    const factorial = currying(tailFactorial, 1);
    
    factorial(5) // 120
    
    • 第二种方法就简单多了,就是采用 ES6 的函数默认值。
    function factorial(n, total = 1) {
      if (n === 1) return total;
      return factorial(n - 1, n * total);
    }
    
    factorial(5) // 120
    
    • 总结一下,递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令,所有的循环都用递归实现,这就是为什么尾递归对这些语言极其重要。对于其他支持“尾调用优化”的语言(比如 Lua,ES6),只需要知道循环可以用递归代替,而一旦使用递归,就最好使用尾递归。

    严格模式

    • ES6 的尾调用优化只在严格模式下开启,正常模式是无效的。

    这是因为在正常模式下,函数内部有两个变量,可以跟踪函数的调用栈。

      - func.arguments:返回调用时函数的参数。

      - func.caller:返回调用当前函数的那个函数。

    尾调用优化发生时,函数的调用栈会改写,因此上面两个变量就会失真。严格模式禁用这两个变量,所以尾调用模式仅在严格模式下生效。

    function restricted() {
      'use strict';
      restricted.caller;    // 报错
      restricted.arguments; // 报错
    }
    restricted();
    

    6.8 函数参数的尾逗号

    • ES2017 允许函数的最后一个参数有尾逗号(trailing comma)。

    7 数组的扩展 <a id = "数组的扩展"></a>

    7.1 扩展运算符

    含义

    • 扩展运算符(spread)是三个点(...)。它好比 rest 参数的逆运算,将一个数组转为用逗号分隔的参数序列。
    console.log(...[1, 2, 3])
    // 1 2 3
    
    console.log(1, ...[2, 3, 4], 5)
    // 1 2 3 4 5
    
    [...document.querySelectorAll('div')]
    // [<div>, <div>, <div>]
    
    • 该运算符主要用于函数调用。
    function push(array, ...items) {
      array.push(...items);
    }
    
    function add(x, y) {
      return x + y;
    }
    
    const numbers = [4, 38];
    add(...numbers) // 42
    

    替代函数的 apply 方法

    • 由于扩展运算符可以展开数组,所以不再需要apply方法,将数组转为函数的参数了。
    // ES5 的写法
    function f(x, y, z) {
      // ...
    }
    var args = [0, 1, 2];
    f.apply(null, args);
    
    // ES6的写法
    function f(x, y, z) {
      // ...
    }
    let args = [0, 1, 2];
    f(...args);
    

    扩展运算符的应用

    (1)复制数组

    • ES5
    const a1 = [1, 2];
    const a2 = a1.concat();
    
    a2[0] = 2;
    a1 // [1, 2]
    
    • 扩展运算符
    const a1 = [1, 2];
    // 写法一
    const a2 = [...a1];
    // 写法二
    const [...a2] = a1;
    

    (2)合并数组

    • 扩展运算符提供了数组合并的新写法。
    const arr1 = ['a', 'b'];
    const arr2 = ['c'];
    const arr3 = ['d', 'e'];
    
    // ES5 的合并数组
    arr1.concat(arr2, arr3);
    // [ 'a', 'b', 'c', 'd', 'e' ]
    
    // ES6 的合并数组
    [...arr1, ...arr2, ...arr3]
    // [ 'a', 'b', 'c', 'd', 'e' ]
    

    不过,这两种方法都是浅拷贝,使用的时候需要注意。

    (3)与解构赋值结合

    • 扩展运算符可以与解构赋值结合起来,用于生成数组。
    // ES5
    a = list[0], rest = list.slice(1)
    // ES6
    [a, ...rest] = list
    
    • 下面是另外一些例子。
    const [first, ...rest] = [1, 2, 3, 4, 5];
    first // 1
    rest  // [2, 3, 4, 5]
    
    const [first, ...rest] = [];
    first // undefined
    rest  // []
    
    const [first, ...rest] = ["foo"];
    first  // "foo"
    rest   // []
    
    • 如果将扩展运算符用于数组赋值,只能放在参数的最后一位,否则会报错。
    const [...butLast, last] = [1, 2, 3, 4, 5];
    // 报错
    
    const [first, ...middle, last] = [1, 2, 3, 4, 5];
    // 报错
    

    (4)字符串

    • 扩展运算符还可以将字符串转为真正的数组。
    [...'hello']
    // [ "h", "e", "l", "l", "o" ]
    

    (5)实现了 Iterator 接口的对象

    • 任何 Iterator 接口的对象(参阅 Iterator 一章),都可以用扩展运算符转为真正的数组。

    (6) Map 和 Set 结构,Generator 函数

    7.2 Array.from()

    • Array.from 方法用于将两类对象转为真正的数组:类似数组的对象(array-like object)和可遍历(iterable)的对象(包括 ES6 新增的数据结构 Set 和 Map)。

    • Array.from 还可以接受第二个参数,作用类似于数组的map方法,用来对每个元素进行处理,将处理后的值放入返回的数组。

    • 如果map函数里面用到了this关键字,还可以传入Array.from的第三个参数,用来绑定this。

    • Array.from() 可以将各种值转为真正的数组,并且还提供map功能。这实际上意味着,只要有一个原始的数据结构,你就可以先对它的值进行处理,然后转成规范的数组结构,进而就可以使用数量众多的数组方法。

    Array.from({ length: 2 }, () => 'jack')
    // ['jack', 'jack']
    

    上面代码中,Array.from的第一个参数指定了第二个参数运行的次数。这种特性可以让该方法的用法变得非常灵活。

    • Array.from() 的另一个应用是,将字符串转为数组,然后返回字符串的长度。因为它能正确处理各种 Unicode 字符,可以避免 JavaScript 将大于\uFFFF的 Unicode 字符,算作两个字符的 bug。

    7.3 Array.of()

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

    这个方法的主要目的,是弥补数组构造函数Array()的不足。因为参数个数的不同,会导致Array()的行为有差异。

    Array() // []
    Array(3) // [, , ,]
    Array(3, 11, 8) // [3, 11, 8]
    
    • Array.of方法可以用下面的代码模拟实现。
    function ArrayOf(){
      return [].slice.call(arguments);
    }
    

    7.4 数组实例的 copyWithin()

    • 数组实例的 copyWithin 方法,在当前数组内部,将指定位置的成员复制到其他位置(会覆盖原有成员),然后返回当前数组。也就是说,使用这个方法,会修改当前数组。
    Array.prototype.copyWithin(target, start = 0, end = this.length)
    

    它接受三个参数。

      - target(必需):从该位置开始替换数据。如果为负值,表示倒数。

      - start(可选):从该位置开始读取数据,默认为 0。如果为负值,表示倒数。

      - end(可选):到该位置前停止读取数据,默认等于数组长度。如果为负值,表示倒数。

    这三个参数都应该是数值,如果不是,会自动转为数值。

    [1, 2, 3, 4, 5].copyWithin(0, 3)
    // [4, 5, 3, 4, 5]
    

    7.5 数组实例的 find() 和 findIndex()

    • 数组实例的find方法,用于找出第一个符合条件的数组成员。
    [1, 5, 10, 15].find(function(value, index, arr) {
      return value > 9;
    }) // 10
    

    上面代码中,find方法的回调函数可以接受三个参数,依次为当前的值、当前的位置和原数组。

    • 数组实例的findIndex方法的用法与find方法非常类似,返回第一个符合条件的数组成员的位置,如果所有成员都不符合条件,则返回-1。

    • 这两个方法都可以接受第二个参数,用来绑定回调函数的this对象。

    function f(v){
      return v > this.age;
    }
    let person = {name: 'John', age: 20};
    [10, 12, 26, 15].find(f, person);    // 26
    
    • 另外,这两个方法都可以发现NaN,弥补了数组的indexOf方法的不足。
    [NaN].indexOf(NaN)
    // -1
    
    [NaN].findIndex(y => Object.is(NaN, y))
    // 0
    
    • 上面代码中,indexOf方法无法识别数组的NaN成员,但是findIndex方法可以借助Object.is方法做到。

    7.6 数组实例的 fill()

    • fill方法使用给定值,填充一个数组。
    ['a', 'b', 'c'].fill(7)
    // [7, 7, 7]
    
    new Array(3).fill(7)
    // [7, 7, 7]
    
    • fill方法还可以接受第二个和第三个参数,用于指定填充的起始位置和结束位置。
    ['a', 'b', 'c'].fill(7, 1, 2)
    // ['a', 7, 'c']
    
    • 注意,如果填充的类型为对象,那么被赋值的是同一个内存地址的对象,而不是深拷贝对象。
    let arr = new Array(3).fill({name: "Mike"});
    arr[0].name = "Ben";
    arr
    // [{name: "Ben"}, {name: "Ben"}, {name: "Ben"}]
    
    let arr = new Array(3).fill([]);
    arr[0].push(5);
    arr
    // [[5], [5], [5]]
    

    数组中的成员指向同一个内存地址。

    7.7 数组实例的 entries(),keys() 和 values()

    • ES6 提供三个新的方法——entries(),keys()和values()——用于遍历数组。它们都返回一个遍历器对象(详见《Iterator》一章),可以用for...of循环进行遍历,唯一的区别是keys()是对键名的遍历、values()是对键值的遍历,entries()是对键值对的遍历。
    for (let index of ['a', 'b'].keys()) {
      console.log(index);
    }
    // 0
    // 1
    
    for (let elem of ['a', 'b'].values()) {
      console.log(elem);
    }
    // 'a'
    // 'b'
    
    for (let [index, elem] of ['a', 'b'].entries()) {
      console.log(index, elem);
    }
    // 0 "a"
    // 1 "b"
    

    如果不使用for...of循环,可以手动调用遍历器对象的next方法,进行遍历。

    let letter = ['a', 'b', 'c'];
    let entries = letter.entries();
    console.log(entries.next().value); // [0, 'a']
    console.log(entries.next().value); // [1, 'b']
    console.log(entries.next().value); // [2, 'c']
    

    7.8 数组实例的 includes()

    • Array.prototype.includes 方法返回一个布尔值,表示某个数组是否包含给定的值,与字符串的includes方法类似。ES2016 引入了该方法。

    • 该方法的第二个参数表示搜索的起始位置,默认为0。如果第二个参数为负数,则表示倒数的位置,如果这时它大于数组长度(比如第二个参数为-4,但数组长度为3),则会重置为从0开始。

    • 没有该方法之前,我们通常使用数组的indexOf方法,检查是否包含某个值。indexOf 方法有两个缺点,一是不够语义化,它的含义是找到参数值的第一个出现位置,所以要去比较是否不等于-1,表达起来不够直观。二是,它内部使用严格相等运算符(===)进行判断,这会导致对NaN的误判。

    • 下面代码用来检查当前环境是否支持该方法,如果不支持,部署一个简易的替代版本。

    const contains = (() =>
      Array.prototype.includes
        ? (arr, value) => arr.includes(value)
        : (arr, value) => arr.some(el => el === value)
    )();
    contains(['foo', 'bar'], 'baz'); // => false
    
    • 另外,Map 和 Set 数据结构有一个has方法,需要注意与includes区分。

      - Map 结构的has方法,是用来查找键名的,比如Map.prototype.has(key)、WeakMap.prototype.has(key)、Reflect.has(target, propertyKey)。

      - Set 结构的has方法,是用来查找值的,比如Set.prototype.has(value)、WeakSet.prototype.has(value)。

    7.9 数组的空位

    • 数组的空位指,数组的某一个位置没有任何值。比如,Array构造函数返回的数组都是空位。
    Array(3) // [, , ,]
    

    上面代码中,Array(3)返回一个具有 3 个空位的数组。

    • 注意,空位不是undefined,一个位置的值等于undefined,依然是有值的。空位是没有任何值,in运算符可以说明这一点。
    0 in [undefined, undefined, undefined] // true
    0 in [, , ,] // false
    

    上面代码说明,第一个数组的 0 号位置是有值的,第二个数组的 0 号位置没有值。

    • ES5 对空位的处理,已经很不一致了,大多数情况下会忽略空位。

      - forEach(), filter(), reduce(), every() 和some()都会跳过空位。

      - map()会跳过空位,但会保留这个值

      - join()和toString()会将空位视为undefined,而undefined和null会被处理成空字符串。

    • ES6 则是明确将空位转为undefined。

    • Array.from、扩展运算符(...)、entries()、keys()、values()、find()和findIndex()会将空位处理成 undefined。

    • copyWithin() 会连空位一起拷贝。fill() 会将空位视为正常的数组位置。for...of 循环也会遍历空位。

    • 由于空位的处理规则非常不统一,所以建议避免出现空位。

    8 对象的扩展 <a id = "对象的扩展"></a>

    8.1 属性的简洁表示法

    • ES6 允许直接写入变量和函数,作为对象的属性和方法。这样的书写更加简洁。
    let birth = '2000/01/01';
    
    const Person = {
    
      name: '张三',
    
      //等同于birth: birth
      birth,
    
      // 等同于hello: function ()...
      hello() { console.log('我的名字是', this.name); }
    
    };
    
    • 注意,简洁写法的属性名总是字符串,这会导致一些看上去比较奇怪的结果。
    const obj = {
      class () {}
    };
    
    // 等同于
    
    var obj = {
      'class': function() {}
    };
    

    上面代码中,class是字符串,所以不会因为它属于关键字,而导致语法解析报错。

    • 如果某个方法的值是一个 Generator 函数,前面需要加上星号。
    const obj = {
      * m() {
        yield 'hello world';
      }
    };
    

    8.2 属性名表达式

    • ES5 中只能使用标识符定义属性。ES6 允许字面量定义对象时,用表达式作为对象的属性名。
    let propKey = 'foo';
    
    let obj = {
      [propKey]: true,
      ['a' + 'bc']: 123
    };
    
    • 注意,属性名表达式与简洁表示法,不能同时使用,会报错。
    // 报错
    const foo = 'bar';
    const bar = 'abc';
    const baz = { [foo] };
    
    // 正确
    const foo = 'bar';
    const baz = { [foo]: 'abc'};
    
    • 注意,属性名表达式如果是一个对象,默认情况下会自动将对象转为字符串[object Object],这一点要特别小心。
    const keyA = {a: 1};
    const keyB = {b: 2};
    
    const myObject = {
      [keyA]: 'valueA',
      [keyB]: 'valueB'
    };
    
    myObject // Object {[object Object]: "valueB"}
    

    8.3 方法的 name 属性

    • 函数的name属性,返回函数名。对象方法也是函数,因此也有name属性。
    const person = {
      sayName() {
        console.log('hello!');
      },
    };
    
    person.sayName.name   // "sayName"
    
    • 如果对象的方法使用了取值函数(getter)和存值函数(setter),则name属性不是在该方法上面,而是该方法的属性的描述对象的get和set属性上面,返回值是方法名前加上get和set。
    const obj = {
      get foo() {},
      set foo(x) {}
    };
    
    obj.foo.name
    // TypeError: Cannot read property 'name' of undefined
    
    const descriptor = Object.getOwnPropertyDescriptor(obj, 'foo');
    
    descriptor.get.name // "get foo"
    descriptor.set.name // "set foo"
    
    • 有两种特殊情况:bind方法创造的函数,name属性返回bound加上原函数的名字;Function构造函数创造的函数,name属性返回anonymous。

    • 如果对象的方法是一个 Symbol 值,那么name属性返回的是这个 Symbol 值的描述。

    const key1 = Symbol('description');
    const key2 = Symbol();
    let obj = {
      [key1]() {},
      [key2]() {},
    };
    obj[key1].name // "[description]"
    obj[key2].name // ""
    

    8.4 Object.is()

    • 相等运算符(==)和严格相等运算符(===)存在缺陷。前者会自动转换数据类型,后者的 NaN 不等于自身,以及 +0 等于 -0 。Javascript 缺乏一种运算,只要两个值是一样的,它们就应该相等。

    • ES6 提出“Same-value equality”(同值相等)算法,用来解决这个问题。Object.is就是部署这个算法的新方法。它用来比较两个值是否严格相等,与严格比较运算符(===)的行为基本一致。不同之处只有两个:一是+0不等于-0,二是NaN等于自身。

    +0 === -0 //true
    NaN === NaN // false
    
    Object.is(+0, -0) // false
    Object.is(NaN, NaN) // true
    
    • ES5 可以通过下面的代码,部署Object.is。
    Object.defineProperty(Object, 'is', {
      value: function(x, y) {
        if (x === y) {
          // 针对+0 不等于 -0的情况
          return x !== 0 || 1 / x === 1 / y;
        }
        // 针对NaN的情况
        return x !== x && y !== y;
      },
      configurable: true,
      enumerable: false,
      writable: true
    });
    

    8.5 Object.assign()

    基本用法

    • Object.assign 方法用于对象的合并,将源对象(source)的所有可枚举属性,复制到目标对象(target)。Object.assign 方法的第一个参数是目标对象,后面的参数都是源对象。

    • 如果首参数不是对象,则会先转成对象,然后返回。

    typeof Object.assign(2) // "object"
    

    由于undefined和null无法转成对象,所以如果它们作为参数,就会报错。

    Object.assign(undefined) // 报错
    Object.assign(null) // 报错
    
    • 如果非对象参数出现在源对象的位置(即非首参数),那么处理规则有所不同。首先,这些参数都会转成对象,如果无法转成对象,就会跳过。这意味着,如果undefined和null不在首参数,就不会报错。
    let obj = {a: 1};
    Object.assign(obj, undefined) === obj // true
    Object.assign(obj, null) === obj // true
    

    其他类型的值(即数值、字符串和布尔值)不在首参数,也不会报错。但是,除了字符串会以数组形式,拷贝入目标对象,其他值都不会产生效果。

    const v1 = 'abc';
    const v2 = true;
    const v3 = 10;
    
    const obj = Object.assign({}, v1, v2, v3);
    console.log(obj); // { "0": "a", "1": "b", "2": "c" }
    

    上面代码中,v1、v2、v3分别是字符串、布尔值和数值,结果只有字符串合入目标对象(以字符数组的形式),数值和布尔值都会被忽略。这是因为只有字符串的包装对象,会产生可枚举属性。

    • Object.assign拷贝的属性是有限制的,只拷贝源对象的自身属性(不拷贝继承属性),也不拷贝不可枚举的属性(enumerable: false)。

    • 属性名为 Symbol 值的属性,也会被Object.assign拷贝。

    Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
    // { a: 'b', Symbol(c): 'd' }
    

    注意点

    (1)浅拷贝
    • Object.assign 方法实行的是浅拷贝,而不是深拷贝。也就是说,如果源对象某个属性的值是对象,那么目标对象拷贝得到的是这个对象的引用。
    (2)同名属性的替换
    • 对于这种嵌套的对象,一旦遇到同名属性,Object.assign的处理方法是替换,而不是添加。
    const target = { a: { b: 'c', d: 'e' } }
    const source = { a: { b: 'hello' } }
    Object.assign(target, source)
    // { a: { b: 'hello' } }
    

    上面代码中,target对象的a属性被source对象的a属性整个替换掉了,而不会得到{ a: { b: 'hello', d: 'e' } }的结果。这通常不是开发者想要的,需要特别小心。

    • 一些函数库提供Object.assign的定制版本(比如 Lodash 的_.defaultsDeep方法),可以得到深拷贝的合并。
    (3)数组的处理
    • Object.assign 可以用来处理数组,但是会把数组视为对象。
    Object.assign([1, 2, 3], [4, 5])
    // [4, 5, 3]
    

    上面代码中,Object.assign 把数组视为属性名为 0、1、2 的对象,因此源数组的 0 号属性4覆盖了目标数组的 0 号属性1。

    (4)取值函数的处理
    • Object.assign 只能进行值的复制,如果要复制的值是一个取值函数,那么将求值后再复制。
    const source = {
      get foo() { return 1 }
    };
    const target = {};
    
    Object.assign(target, source)
    // { foo: 1 }
    

    上面代码中,source 对象的 foo 属性是一个取值函数,Object.assign 不会复制这个取值函数,只会拿到值以后,将这个值复制过去。

    常见用途

    (1)为对象添加属性
    class Point {
      constructor(x, y) {
        Object.assign(this, {x, y});
      }
    }
    

    上面方法通过Object.assign方法,将x属性和y属性添加到Point类的对象实例。

    (2)为对象添加方法
    Object.assign(SomeClass.prototype, {
      someMethod(arg1, arg2) {
        ···
      },
      anotherMethod() {
        ···
      }
    });
    
    // 等同于下面的写法
    SomeClass.prototype.someMethod = function (arg1, arg2) {
      ···
    };
    SomeClass.prototype.anotherMethod = function () {
      ···
    };
    
    (3)克隆对象
    function clone(origin) {
      return Object.assign({}, origin);
    }
    

    上面代码将原始对象拷贝到一个空对象,就得到了原始对象的克隆。

    不过,采用这种方法克隆,只能克隆原始对象自身的值,不能克隆它继承的值。如果想要保持继承链,可以采用下面的代码。

    function clone(origin) {
      let originProto = Object.getPrototypeOf(origin);
      return Object.assign(Object.create(originProto), origin);
    }
    
    (4)合并多个对象
    • 将多个对象合并到某个对象。
    const merge =
      (target, ...sources) => Object.assign(target, ...sources);
    

    如果希望合并后返回一个新对象,可以改写上面函数,对一个空对象合并。

    const merge =
      (...sources) => Object.assign({}, ...sources);
    
    (5)为属性指定默认值
    const DEFAULTS = {
      logLevel: 0,
      outputFormat: 'html'
    };
    
    function processContent(options) {
      options = Object.assign({}, DEFAULTS, options);
      console.log(options);
      // ...
    }
    

    上面代码中,DEFAULTS对象是默认值,options对象是用户提供的参数。Object.assign 方法将DEFAULTS和options合并成一个新对象,如果两者有同名属性,则 option 的属性值会覆盖DEFAULTS的属性值。

    注意,由于存在浅拷贝的问题,DEFAULTS对象和options对象的所有属性的值,最好都是简单类型,不要指向另一个对象。否则,DEFAULTS对象的该属性很可能不起作用。

    const DEFAULTS = {
      url: {
        host: 'example.com',
        port: 7070
      },
    };
    
    processContent({ url: {port: 8000} })
    // {
    //   url: {port: 8000}
    // }
    

    上面代码的原意是将url.port改成 8000,url.host不变。实际结果却是options.url覆盖掉DEFAULTS.url,所以url.host就不存在了。

    8.6 属性的可枚举性和遍历

    可枚举性

    • 对象的每个属性都有一个描述对象(Descriptor),用来控制该属性的行为。Object.getOwnPropertyDescriptor方法可以获取该属性的描述对象。
    let obj = { foo: 123 };
    Object.getOwnPropertyDescriptor(obj, 'foo')
    //  {
    //    value: 123,
    //    writable: true,
    //    enumerable: true,
    //    configurable: true
    //  }
    

    描述对象的enumerable属性,称为”可枚举性“,如果该属性为false,就表示某些操作会忽略当前属性。

    • 目前,有四个操作会忽略enumerable为false的属性。

      - for...in循环:只遍历对象自身的和继承的可枚举的属性。

      - Object.keys():返回对象自身的所有可枚举的属性的键名。

      - JSON.stringify():只串行化对象自身的可枚举的属性。

      - Object.assign(): 忽略enumerable为false的属性,只拷贝对象自身的可枚举的属性。

    • 另外,ES6 规定,所有 Class 的原型的方法都是不可枚举的。
    Object.getOwnPropertyDescriptor(class {foo() {}}.prototype, 'foo').enumerable
    // false
    

    总的来说,操作中引入继承的属性会让问题复杂化,大多数时候,我们只关心对象自身的属性。所以,尽量不要用 for...in 循环,而用 Object.keys() 代替。

    属性的遍历

    • ES6 一共有 5 种方法可以遍历对象的属性。
    (1)for...in
    • for...in 循环遍历对象自身的和继承的可枚举属性(不含 Symbol 属性)。
    (2)Object.keys(obj)
    • Object.keys 返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含 Symbol 属性)的键名。
    (3)Object.getOwnPropertyNames(obj)
    • Object.getOwnPropertyNames 返回一个数组,包含对象自身的所有属性(不含 Symbol 属性,但是包括不可枚举属性)的键名。
    (4)Object.getOwnPropertySymbols(obj)
    • Object.getOwnPropertySymbols 返回一个数组,包含对象自身的所有 Symbol 属性的键名。
    (5)Reflect.ownKeys(obj)
    • Reflect.ownKeys 返回一个数组,包含对象自身的所有键名,不管键名是 Symbol 或字符串,也不管是否可枚举。

    • 以上的 5 种方法遍历对象的键名,都遵守同样的属性遍历的次序规则。

      - 首先遍历所有数值键,按照数值升序排列。
      - 其次遍历所有字符串键,按照加入时间升序排列。
      - 最后遍历所有 Symbol 键,按照加入时间升序排列。

    8.7 Object.getOwnPropertyDescriptors()

    • 前面说过,Object.getOwnPropertyDescriptor 方法会返回某个对象属性的描述对象(descriptor)。ES2017 引入了 Object.getOwnPropertyDescriptors 方法,返回指定对象所有自身属性(非继承属性)的描述对象。
    const obj = {
      foo: 123,
      get bar() { return 'abc' }
    };
    
    Object.getOwnPropertyDescriptors(obj)
    // { foo:
    //    { value: 123,
    //      writable: true,
    //      enumerable: true,
    //      configurable: true },
    //   bar:
    //    { get: [Function: get bar],
    //      set: undefined,
    //      enumerable: true,
    //      configurable: true } }
    

    上面代码中,Object.getOwnPropertyDescriptors方法返回一个对象,所有原对象的属性名都是该对象的属性名,对应的属性值就是该属性的描述对象。

    8.8 proto属性,Object.setPrototypeOf(),Object.getPrototypeOf()

    proto 属性

    • proto 属性(前后各两个下划线),用来读取或设置当前对象的 prototype 对象。目前,所有浏览器(包括 IE11)都部署了这个属性。

    • 标准明确规定,只有浏览器必须部署这个属性,其他运行环境不一定需要部署,而且新的代码最好认为这个属性是不存在的。因此,无论从语义的角度,还是从兼容性的角度,都不要使用这个属性,而是使用下面的Object.setPrototypeOf()(写操作)、Object.getPrototypeOf()(读操作)、Object.create()(生成操作)代替。

    Object.setPrototypeOf()

    • Object.setPrototypeOf 方法的作用与proto相同,用来设置一个对象的prototype对象,返回参数对象本身。它是 ES6 正式推荐的设置原型对象的方法。
    // 格式
    Object.setPrototypeOf(object, prototype)
    
    // 用法
    const o = Object.setPrototypeOf({}, null);
    
    • 如果第一个参数不是对象,会自动转为对象。但是由于返回的还是第一个参数,所以这个操作不会产生任何效果。
    Object.setPrototypeOf(1, {}) === 1 // true
    Object.setPrototypeOf('foo', {}) === 'foo' // true
    Object.setPrototypeOf(true, {}) === true // true
    
    • 由于undefined和null无法转为对象,所以如果第一个参数是undefined或null,就会报错。
    Object.setPrototypeOf(undefined, {})
    // TypeError: Object.setPrototypeOf called on null or undefined
    
    Object.setPrototypeOf(null, {})
    // TypeError: Object.setPrototypeOf called on null or undefined
    

    Object.getPrototypeOf()

    • 该方法与Object.setPrototypeOf方法配套,用于读取一个对象的原型对象。

    • 如果参数不是对象,会被自动转为对象。

    • 如果参数是undefined或null,它们无法转为对象,所以会报错。

    8.9 super 关键字

    • 我们知道,this关键字总是指向函数所在的当前对象,ES6 又新增了另一个类似的关键字super,指向当前对象的原型对象。

    • 注意,super关键字表示原型对象时,只能用在对象的方法之中(简写方法),用在其他地方都会报错。

    8.10 Object.keys(),Object.values(),Object.entries()

    Object.keys()

    • ES5 引入了Object.keys方法,返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键名。

    Object.values()

    • Object.values 方法返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键值。

    • Object.values 会过滤属性名为 Symbol 值的属性。

    • 如果 Object.values 方法的参数是一个字符串,会返回各个字符组成的一个数组。

    • 如果参数不是对象,Object.values会先将其转为对象。由于数值和布尔值的包装对象,都不会为实例添加非继承的属性。所以,Object.values会返回空数组。

    Object.values(42) // []
    Object.values(true) // []
    

    Object.entries()

    • Object.entries 方法返回一个数组,成员是参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键值对数组。除了返回值不一样,该方法的行为与Object.values 基本一致。

    • Object.entries的基本用途是遍历对象的属性。

    let obj = { one: 1, two: 2 };
    for (let [k, v] of Object.entries(obj)) {
      console.log(
        `${JSON.stringify(k)}: ${JSON.stringify(v)}`
      );
    }
    // "one": 1
    // "two": 2
    
    • Object.entries方法的另一个用处是,将对象转为真正的Map结构。
    const obj = { foo: 'bar', baz: 42 };
    const map = new Map(Object.entries(obj));
    map // Map { foo: "bar", baz: 42 }
    
    • 自己实现Object.entries方法,非常简单。
    // Generator函数的版本
    function* entries(obj) {
      for (let key of Object.keys(obj)) {
        yield [key, obj[key]];
      }
    }
    
    // 非Generator函数的版本
    function entries(obj) {
      let arr = [];
      for (let key of Object.keys(obj)) {
        arr.push([key, obj[key]]);
      }
      return arr;
    }
    

    8.11 对象的扩展运算符

    • ES2018 将(...)运算符引入了对象。

    解构赋值

    • 对象的解构赋值用于从一个对象取值,相当于将目标对象自身的所有可遍历的(enumerable)、但尚未被读取的属性,分配到指定的对象上面。所有的键和它们的值,都会拷贝到新对象上面。
    let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
    x // 1
    y // 2
    z // { a: 3, b: 4 }
    
    • 由于解构赋值要求等号右边是一个对象,所以如果等号右边是undefined或null,就会报错,因为它们无法转为对象。

    • 注意,解构赋值的拷贝是浅拷贝,即如果一个键的值是复合类型的值(数组、对象、函数)、那么解构赋值拷贝的是这个值的引用,而不是这个值的副本。

    • 另外,扩展运算符的解构赋值,不能复制继承自原型对象的属性。

    • 解构赋值的一个用处,是扩展某个函数的参数,引入其他操作。

    function baseFunction({ a, b }) {
      // ...
    }
    function wrapperFunction({ x, y, ...restConfig }) {
      // 使用 x 和 y 参数进行操作
      // 其余参数传给原始函数
      return baseFunction(restConfig);
    }
    

    上面代码中,原始函数baseFunction接受a和b作为参数,函数wrapperFunction在baseFunction的基础上进行了扩展,能够接受多余的参数,并且保留原始函数的行为。

    扩展运算符

    • 对象的扩展运算符(...)用于取出参数对象的所有可遍历属性,拷贝到当前对象之中。
    let aClone = { ...a };
    // 等同于
    let aClone = Object.assign({}, a);
    
    • 扩展运算符可以用于合并两个对象。
    let ab = { ...a, ...b };
    // 等同于
    let ab = Object.assign({}, a, b);
    
    • 与数组的扩展运算符一样,对象的扩展运算符后面可以跟表达式。
    const obj = {
      ...(x > 1 ? {a: 1} : {}),
      b: 2,
    };
    
    • 如果扩展运算符后面是一个空对象,则没有任何效果。
    {...{}, a: 1}
    // { a: 1 }
    
    • 如果扩展运算符的参数是null或undefined,这两个值会被忽略,不会报错。
    let emptyObject = { ...null, ...undefined }; // 不报错
    
    • 扩展运算符的参数对象之中,如果有取值函数get,这个函数是会执行的。
    // 并不会抛出错误,因为 x 属性只是被定义,但没执行
    let aWithXGetter = {
      ...a,
      get x() {
        throw new Error('not throw yet');
      }
    };
    
    // 会抛出错误,因为 x 属性被执行了
    let runtimeError = {
      ...a,
      ...{
        get x() {
          throw new Error('throw now');
        }
      }
    };
    

    9 Symbol <a id = "Symbol"></a>

    9.1 概述

    • ES6 引入了一种新的原始数据类型Symbol,表示独一无二的值。它是 JavaScript 语言的第七种数据类型,前六种是:undefined、null、布尔值(Boolean)、字符串(String)、数值(Number)、对象(Object)。

    • Symbol 值通过Symbol函数生成。这就是说,对象的属性名现在可以有两种类型,一种是原来就有的字符串,另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型,就都是独一无二的,可以保证不会与其他属性名产生冲突。

    let s = Symbol();
    
    typeof s
    // "symbol"
    

    上面代码中,变量s就是一个独一无二的值。typeof运算符的结果,表明变量s是 Symbol 数据类型,而不是字符串之类的其他类型。

    • 注意,Symbol函数前不能使用new命令,否则会报错。这是因为生成的 Symbol 是一个原始类型的值,不是对象。也就是说,由于 Symbol 值不是对象,所以不能添加属性。基本上,它是一种类似于字符串的数据类型。

    • Symbol函数可以接受一个字符串作为参数,表示对 Symbol 实例的描述,主要是为了在控制台显示,或者转为字符串时,比较容易区分。

    • 如果 Symbol 的参数是一个对象,就会调用该对象的toString方法,将其转为字符串,然后才生成一个 Symbol 值。

    • Symbol 值不能与其他类型的值进行运算,会报错。

    let sym = Symbol('My symbol');
    
    "your symbol is " + sym
    // TypeError: can't convert symbol to string
    `your symbol is ${sym}`
    // TypeError: can't convert symbol to string
    
    • 但是,Symbol 值可以显式转为字符串。
    let sym = Symbol('My symbol');
    
    String(sym) // 'Symbol(My symbol)'
    sym.toString() // 'Symbol(My symbol)'
    
    • 另外,Symbol 值也可以转为布尔值,但是不能转为数值。
    let sym = Symbol();
    Boolean(sym) // true
    !sym  // false
    
    if (sym) {
      // ...
    }
    
    Number(sym) // TypeError
    sym + 2 // TypeError
    

    9.2 作为属性名的 Symbol

    • 注意,Symbol 值作为对象属性名时,不能用点运算符。
    const mySymbol = Symbol();
    const a = {};
    
    a.mySymbol = 'Hello!';
    a[mySymbol] // undefined
    a['mySymbol'] // "Hello!"
    

    上面代码中,因为点运算符后面总是字符串,所以不会读取mySymbol作为标识名所指代的那个值,导致a的属性名实际上是一个字符串,而不是一个 Symbol 值。

    • 同理,在对象的内部,使用 Symbol 值定义属性时,Symbol 值必须放在方括号之中。
    let s = Symbol();
    
    let obj = {
      [s](arg) { ... }
    };
    
    obj[s](123);
    
    • Symbol 类型还可以用于定义一组常量,保证这组常量的值都是不相等的。
    const log = {};
    
    log.levels = {
      DEBUG: Symbol('debug'),
      INFO: Symbol('info'),
      WARN: Symbol('warn')
    };
    console.log(log.levels.DEBUG, 'debug message');
    console.log(log.levels.INFO, 'info message');
    

    9.3 实例:消除魔术字符串

    9.4 属性名的遍历

    • Symbol 作为属性名,该属性不会出现在for...in、for...of循环中,也不会被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。但是,它也不是私有属性,有一个Object.getOwnPropertySymbols方法,可以获取指定对象的所有 Symbol 属性名。

    • 另一个新的 API,Reflect.ownKeys方法可以返回所有类型的键名,包括常规键名和 Symbol 键名。

    • 由于以 Symbol 值作为名称的属性,不会被常规方法遍历得到。我们可以利用这个特性,为对象定义一些非私有的、但又希望只用于内部的方法。

    let size = Symbol('size');
    
    class Collection {
      constructor() {
        this[size] = 0;
      }
    
      add(item) {
        this[this[size]] = item;
        this[size]++;
      }
    
      static sizeOf(instance) {
        return instance[size];
      }
    }
    
    let x = new Collection();
    Collection.sizeOf(x) // 0
    
    x.add('foo');
    Collection.sizeOf(x) // 1
    
    Object.keys(x) // ['0']
    Object.getOwnPropertyNames(x) // ['0']
    Object.getOwnPropertySymbols(x) // [Symbol(size)]
    

    9.5 Symbol.for(),Symbol.keyFor()

    • 有时,我们希望重新使用同一个 Symbol 值,Symbol.for方法可以做到这一点。它接受一个字符串作为参数,然后搜索有没有以该参数作为名称的 Symbol 值。如果有,就返回这个 Symbol 值,否则就新建并返回一个以该字符串为名称的 Symbol 值。

    • Symbol.for()与Symbol()这两种写法,都会生成新的 Symbol。它们的区别是,前者会被登记在全局环境中供搜索,后者不会。Symbol.for()不会每次调用就返回一个新的 Symbol 类型的值,而是会先检查给定的key是否已经存在,如果不存在才会新建一个值。比如,如果你调用Symbol.for("cat")30 次,每次都会返回同一个 Symbol 值,但是调用Symbol("cat")30 次,会返回 30 个不同的 Symbol 值。

    Symbol.for("bar") === Symbol.for("bar")
    // true
    
    Symbol("bar") === Symbol("bar")
    // false
    
    • Symbol.keyFor方法返回一个已登记的 Symbol 类型值的key。
    let s1 = Symbol.for("foo");
    Symbol.keyFor(s1) // "foo"
    
    let s2 = Symbol("foo");
    Symbol.keyFor(s2) // undefined
    

    上面代码中,变量s2属于未登记的 Symbol 值,所以返回undefined。

    • 需要注意的是,Symbol.for为 Symbol 值登记的名字,是全局环境的,可以在不同的 iframe 或 service worker 中取到同一个值。
    iframe = document.createElement('iframe');
    iframe.src = String(window.location);
    document.body.appendChild(iframe);
    
    iframe.contentWindow.Symbol.for('foo') === Symbol.for('foo')
    // true
    

    上面代码中,iframe 窗口生成的 Symbol 值,可以在主页面得到。

    9.6 实例:模块的 Singleton 模式

    http://es6.ruanyifeng.com/#docs/symbol#实例:模块的-Singleton-模式

    9.7 内置的 Symbol 值

    • 除了定义自己使用的 Symbol 值以外,ES6 还提供了 11 个内置的 Symbol 值,指向语言内部使用的方法。

    Symbol.hasInstance

    • 对象的Symbol.hasInstance属性,指向一个内部方法。当其他对象使用instanceof运算符,判断是否为该对象的实例时,会调用这个方法。比如,foo instanceof Foo在语言内部,实际调用的是Foo[Symbol.hasInstance](foo)。
    class MyClass {
      [Symbol.hasInstance](foo) {
        return foo instanceof Array;
      }
    }
    
    [1, 2, 3] instanceof new MyClass() // true
    

    Symbol.isConcatSpreadable

    • 对象的 Symbol.isConcatSpreadable 属性等于一个布尔值,表示该对象用于 Array.prototype.concat() 时,是否可以展开。

    • 数组的默认行为是可以展开,类似数组的对象正好相反。

    Symbol.species

    • 对象的 Symbol.species 属性,指向一个构造函数。创建衍生对象时,会使用该属性。
    class MyArray extends Array {
      static get [Symbol.species]() { return Array };
    }
    

    上面代码中,由于定义了 Symbol.species 属性,创建衍生对象时就会使用这个属性返回的函数,作为构造函数。这个例子也说明,定义 Symbol.species 属性要采用get取值器。

    Symbol.match

    • 对象的Symbol.match属性,指向一个函数。当执行str.match(myObject)时,如果该属性存在,会调用它,返回该方法的返回值。
    String.prototype.match(regexp)
    // 等同于
    regexp[Symbol.match](this)
    
    class MyMatcher {
      [Symbol.match](string) {
        return 'hello world'.indexOf(string);
      }
    }
    
    'e'.match(new MyMatcher()) // 1
    

    Symbol.replace

    • 对象的Symbol.replace属性,指向一个方法,当该对象被String.prototype.replace 方法调用时,会返回该方法的返回值。
    String.prototype.replace(searchValue, replaceValue)
    // 等同于
    searchValue[Symbol.replace](this, replaceValue)
    下面是一个例子。
    
    const x = {};
    x[Symbol.replace] = (...s) => console.log(s);
    
    'Hello'.replace(x, 'World') // ["Hello", "World"]
    

    Symbol.replace 方法会收到两个参数,第一个参数是 replace 方法正在作用的对象,上面例子是 Hello,第二个参数是替换后的值,上面例子是 World。

    Symbol.search

    • 对象的Symbol.search属性,指向一个方法,当该对象被String.prototype.search方法调用时,会返回该方法的返回值。
    String.prototype.search(regexp)
    // 等同于
    regexp[Symbol.search](this)
    
    class MySearch {
      constructor(value) {
        this.value = value;
      }
      [Symbol.search](string) {
        return string.indexOf(this.value);
      }
    }
    'foobar'.search(new MySearch('foo')) // 0
    

    Symbol.split

    • 对象的 Symbol.split 属性,指向一个方法,当该对象被 String.prototype.split 方法调用时,会返回该方法的返回值。

    Symbol.iterator

    • 对象的 Symbol.iterator 属性,指向该对象的默认遍历器方法。

    Symbol.toPrimitive

    • 对象的 Symbol.toPrimitive 属性,指向一个方法。该对象被转为原始类型的值时,会调用这个方法,返回该对象对应的原始类型值。

    • Symbol.toPrimitive 被调用时,会接受一个字符串参数,表示当前运算的模式,一共有三种模式。

      - Number('number'):该场合需要转成数值

      - String('string'):该场合需要转成字符串

      - Default('default'):该场合可以转成数值,也可以转成字符串

    let obj = {
      [Symbol.toPrimitive](hint) {
        switch (hint) {
          case 'number':
            return 123;
          case 'string':
            return 'str';
          case 'default':
            return 'default';
          default:
            throw new Error();
         }
       }
    };
    
    2 * obj // 246
    3 + obj // '3default'
    obj == 'default' // true
    String(obj) // 'str'
    

    Symbol.toStringTag

    • 对象的Symbol.toStringTag属性,指向一个方法。在该对象上面调用Object.prototype.toString方法时,如果这个属性存在,它的返回值会出现在toString方法返回的字符串之中,表示对象的类型。也就是说,这个属性可以用来定制[object Object]或[object Array]中object后面的那个字符串。
    // 例一
    ({[Symbol.toStringTag]: 'Foo'}.toString())
    // "[object Foo]"
    
    // 例二
    class Collection {
      get [Symbol.toStringTag]() {
        return 'xxx';
      }
    }
    let x = new Collection();
    Object.prototype.toString.call(x) // "[object xxx]"
    
    • ES6 新增内置对象的Symbol.toStringTag属性值如下。

      - JSON[Symbol.toStringTag]:'JSON'

      - Math[Symbol.toStringTag]:'Math'

      - Module 对象M[Symbol.toStringTag]:'Module'

      - ArrayBuffer.prototype[Symbol.toStringTag]:'ArrayBuffer'

      - DataView.prototype[Symbol.toStringTag]:'DataView'

      - Map.prototype[Symbol.toStringTag]:'Map'

      - Promise.prototype[Symbol.toStringTag]:'Promise'

      - Set.prototype[Symbol.toStringTag]:'Set'

      - %TypedArray%.prototype[Symbol.toStringTag]:'Uint8Array'等

      - WeakMap.prototype[Symbol.toStringTag]:'WeakMap'

      - WeakSet.prototype[Symbol.toStringTag]:'WeakSet'

      - %MapIteratorPrototype%[Symbol.toStringTag]:'Map Iterator'

      - %SetIteratorPrototype%[Symbol.toStringTag]:'Set Iterator'

      - %StringIteratorPrototype%[Symbol.toStringTag]:'String Iterator'

      - Symbol.prototype[Symbol.toStringTag]:'Symbol'

      - Generator.prototype[Symbol.toStringTag]:'Generator'

      - GeneratorFunction.prototype[Symbol.toStringTag]:'GeneratorFunction'

    Symbol.unscopables

    • 对象的Symbol.unscopables属性,指向一个对象。该对象指定了使用with关键字时,哪些属性会被with环境排除。
    Array.prototype[Symbol.unscopables]
    // {
    //   copyWithin: true,
    //   entries: true,
    //   fill: true,
    //   find: true,
    //   findIndex: true,
    //   includes: true,
    //   keys: true
    // }
    
    Object.keys(Array.prototype[Symbol.unscopables])
    // ['copyWithin', 'entries', 'fill', 'find', 'findIndex', 'includes', 'keys']
    

    上面代码说明,数组有 7 个属性,会被with命令排除。

    // 没有 unscopables 时
    class MyClass {
      foo() { return 1; }
    }
    
    var foo = function () { return 2; };
    
    with (MyClass.prototype) {
      foo(); // 1
    }
    
    // 有 unscopables 时
    class MyClass {
      foo() { return 1; }
      get [Symbol.unscopables]() {
        return { foo: true };
      }
    }
    
    var foo = function () { return 2; };
    
    with (MyClass.prototype) {
      foo(); // 2
    }
    

    上面代码通过指定Symbol.unscopables属性,使得with语法块不会在当前作用域寻找foo属性,即foo将指向外层作用域的变量。

    10 Set 和 Map 数据结构 <a id = "Set 和 Map 数据结构"></a>

    10.1 Set

    基本用法

    • ES6 提供了新的数据结构 Set。它类似于数组,但是成员的值都是唯一的,没有重复的值。

    • Set 本身是一个构造函数,用来生成 Set 数据结构。

    • Set 函数可以接受一个数组(或者具有 iterable 接口的其他数据结构)作为参数,用来初始化。

    // 例一
    const set = new Set([1, 2, 3, 4, 4]);
    [...set]
    // [1, 2, 3, 4]
    
    // 例二
    const items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
    items.size // 5
    
    // 例三
    const set = new Set(document.querySelectorAll('div'));
    set.size // 56
    
    // 类似于
    const set = new Set();
    document
     .querySelectorAll('div')
     .forEach(div => set.add(div));
    set.size // 56
    
    • 上面代码也展示了一种去除数组重复成员的方法。
    // 去除数组的重复成员
    [...new Set(array)]
    

    Set 实例的属性和方法

    • Set 结构的实例有以下属性:

      - Set.prototype.constructor:构造函数,默认就是Set函数。

      - Set.prototype.size:返回Set实例的成员总数。

    • Set 实例的方法分为两大类:操作方法(用于操作数据)和遍历方法(用于遍历成员)。下面先介绍四个操作方法。

      - add(value):添加某个值,返回 Set 结构本身。

      - delete(value):删除某个值,返回一个布尔值,表示删除是否成功。

      - has(value):返回一个布尔值,表示该值是否为Set的成员。

      - clear():清除所有成员,没有返回值。

    • Array.from 方法可以将 Set 结构转为数组。
    const items = new Set([1, 2, 3, 4, 5]);
    const array = Array.from(items);
    

    这就提供了去除数组重复成员的另一种方法。

    function dedupe(array) {
      return Array.from(new Set(array));
    }
    
    dedupe([1, 1, 2, 3]) // [1, 2, 3]
    

    遍历操作

    • Set 结构的实例有四个遍历方法,可以用于遍历成员。

      - keys():返回键名的遍历器

      - values():返回键值的遍历器

      - entries():返回键值对的遍历器

      - forEach():使用回调函数遍历每个成员

    (1)keys(),values(),entries()
    • keys方法、values方法、entries方法返回的都是遍历器对象(详见《Iterator 对象》一章)。由于 Set 结构没有键名,只有键值(或者说键名和键值是同一个值),所以keys方法和values方法的行为完全一致。
    (2)forEach()
    • Set 结构的实例与数组一样,也拥有forEach方法,用于对每个成员执行某种操作,没有返回值。
    set = new Set([1, 4, 9]);
    set.forEach((value, key) => console.log(key + ' : ' + value))
    // 1 : 1
    // 4 : 4
    // 9 : 9
    

    上面代码说明,forEach方法的参数就是一个处理函数。该函数的参数与数组的forEach一致,依次为键值、键名、集合本身(上例省略了该参数)。这里需要注意,Set 结构的键名就是键值(两者是同一个值),因此第一个参数与第二个参数的值永远都是一样的。

    另外,forEach方法还可以有第二个参数,表示绑定处理函数内部的this对象。

    (3)遍历的应用
    • 使用 Set 可以很容易地实现并集(Union)、交集(Intersect)和差集(Difference)。
    let a = new Set([1, 2, 3]);
    let b = new Set([4, 3, 2]);
    
    // 并集
    let union = new Set([...a, ...b]);
    // Set {1, 2, 3, 4}
    
    // 交集
    let intersect = new Set([...a].filter(x => b.has(x)));
    // set {2, 3}
    
    // 差集
    let difference = new Set([...a].filter(x => !b.has(x)));
    // Set {1}
    
    • 如果想在遍历操作中,同步改变原来的 Set 结构,目前没有直接的方法,但有两种变通方法。一种是利用原 Set 结构映射出一个新的结构,然后赋值给原来的 Set 结构;另一种是利用Array.from方法。
    // 方法一
    let set = new Set([1, 2, 3]);
    set = new Set([...set].map(val => val * 2));
    // set的值是2, 4, 6
    
    // 方法二
    let set = new Set([1, 2, 3]);
    set = new Set(Array.from(set, val => val * 2));
    // set的值是2, 4, 6
    

    上面代码提供了两种方法,直接在遍历操作中改变原来的 Set 结构。

    10.2 WeakSet

    含义

    • WeakSet 结构与 Set 类似,也是不重复的值的集合。但是,它与 Set 有两个区别。

    • 首先,WeakSet 的成员只能是对象,而不能是其他类型的值。

    • 其次,WeakSet 中的对象都是弱引用,即垃圾回收机制不考虑 WeakSet 对该对象的引用,也就是说,如果其他对象都不再引用该对象,那么垃圾回收机制会自动回收该对象所占用的内存,不考虑该对象还存在于 WeakSet 之中。

    • 由于上面这个特点,WeakSet 的成员是不适合引用的,因为它会随时消失。另外,由于 WeakSet 内部有多少个成员,取决于垃圾回收机制有没有运行,运行前后很可能成员个数是不一样的,而垃圾回收机制何时运行是不可预测的,因此 ES6 规定 WeakSet 不可遍历。

    这些特点同样适用于本章后面要介绍的 WeakMap 结构。

    语法

    • WeakSet 是一个构造函数,可以使用new命令,创建 WeakSet 数据结构。
    const ws = new WeakSet();
    

    作为构造函数,WeakSet 可以接受一个数组或类似数组的对象作为参数。(实际上,任何具有 Iterable 接口的对象,都可以作为 WeakSet 的参数。)该数组的所有成员,都会自动成为 WeakSet 实例对象的成员。

    const a = [[1, 2], [3, 4]];
    const ws = new WeakSet(a);
    // WeakSet {[1, 2], [3, 4]}
    

    上面代码中,a是一个数组,它有两个成员,也都是数组。将a作为 WeakSet 构造函数的参数,a的成员会自动成为 WeakSet 的成员。

    • 注意,是a数组的成员成为 WeakSet 的成员,而不是a数组本身。这意味着,数组的成员只能是对象。
    const b = [3, 4];
    const ws = new WeakSet(b);
    // Uncaught TypeError: Invalid value used in weak set(…)
    

    上面代码中,数组b的成员不是对象,加入 WeaKSet 就会报错。

    • WeakSet 结构有以下三个方法。

      - WeakSet.prototype.add(value):向 WeakSet 实例添加一个新成员。

      - WeakSet.prototype.delete(value):清除 WeakSet 实例的指定成员。

      - WeakSet.prototype.has(value):返回一个布尔值,表示某个值是否在 WeakSet 实例之中。

    10.3 Map

    含义和基本用法

    • ES6 提供了 Map 数据结构。它类似于对象,也是键值对的集合,但是“键”的范围不限于字符串,各种类型的值(包括对象)都可以当作键。也就是说,Object 结构提供了“字符串—值”的对应,Map 结构提供了“值—值”的对应,是一种更完善的 Hash 结构实现。如果你需要“键值对”的数据结构,Map 比 Object 更合适。
    const m = new Map();
    const o = {p: 'Hello World'};
    
    m.set(o, 'content')
    m.get(o) // "content"
    
    m.has(o) // true
    m.delete(o) // true
    m.has(o) // false
    

    上面代码使用 Map 结构的set方法,将对象o当作m的一个键,然后又使用get方法读取这个键,接着使用delete方法删除了这个键。

    上面的例子展示了如何向 Map 添加成员。作为构造函数,Map 也可以接受一个数组作为参数。该数组的成员是一个个表示键值对的数组。

    const map = new Map([
      ['name', '张三'],
      ['title', 'Author']
    ]);
    
    map.size // 2
    map.has('name') // true
    map.get('name') // "张三"
    map.has('title') // true
    map.get('title') // "Author"
    

    上面代码在新建 Map 实例时,就指定了两个键name和title。

    • Map 的键实际上是跟内存地址绑定的,只要内存地址不一样,就视为两个键。这就解决了同名属性碰撞(clash)的问题,我们扩展别人的库的时候,如果使用对象作为键名,就不用担心自己的属性与原作者的属性同名。

    • 如果 Map 的键是一个简单类型的值(数字、字符串、布尔值),则只要两个值严格相等,Map 将其视为一个键,比如0和-0就是一个键,布尔值true和字符串true则是两个不同的键。另外,undefined和null也是两个不同的键。虽然NaN不严格相等于自身,但 Map 将其视为同一个键。

    实例的属性和操作方法

    (1)size 属性
    • size属性返回 Map 结构的成员总数。
    (2)set(key,value)
    (3)get(key)
    (4)has(key)
    (5)delete(key)
    (6)clear()

    遍历方法

    • Map 结构原生提供三个遍历器生成函数和一个遍历方法。

      - keys():返回键名的遍历器。

      - values():返回键值的遍历器。

      - entries():返回所有成员的遍历器。

      - forEach():遍历 Map 的所有成员。

    • Map 结构转为数组结构,比较快速的方法是使用扩展运算符(...)。

    • 结合数组的map方法、filter方法,可以实现 Map 的遍历和过滤(Map 本身没有map和filter方法)。

    const map0 = new Map()
      .set(1, 'a')
      .set(2, 'b')
      .set(3, 'c');
    
    const map1 = new Map(
      [...map0].filter(([k, v]) => k < 3)
    );
    // 产生 Map 结构 {1 => 'a', 2 => 'b'}
    
    const map2 = new Map(
      [...map0].map(([k, v]) => [k * 2, '_' + v])
        );
    // 产生 Map 结构 {2 => '_a', 4 => '_b', 6 => '_c'}
    
    • forEach 方法还可以接受第二个参数,用来绑定 this。

    与其他数据结构的互相转换

    (1)Map 转为数组
    • 前面已经提过,Map 转为数组最方便的方法,就是使用扩展运算符(...)。
    (2)数组转为 Map
    • 将数组传入 Map 构造函数,就可以转为 Map。
    (3)Map 转为对象
    • 如果所有 Map 的键都是字符串,它可以无损地转为对象。
    function strMapToObj(strMap) {
      let obj = Object.create(null);
      for (let [k,v] of strMap) {
        obj[k] = v;
      }
      return obj;
    }
    
    const myMap = new Map()
      .set('yes', true)
      .set('no', false);
    strMapToObj(myMap)
    // { yes: true, no: false }
    

    如果有非字符串的键名,那么这个键名会被转成字符串,再作为对象的键名。

    (4)对象转为 Map
    function objToStrMap(obj) {
      let strMap = new Map();
      for (let k of Object.keys(obj)) {
        strMap.set(k, obj[k]);
      }
      return strMap;
    }
    
    objToStrMap({yes: true, no: false})
    // Map {"yes" => true, "no" => false}
    
    (5)Map 转为 JSON
    • Map 转为 JSON 要区分两种情况。一种情况是,Map 的键名都是字符串,这时可以选择转为对象 JSON。
    function strMapToJson(strMap) {
      return JSON.stringify(strMapToObj(strMap));
    }
    
    let myMap = new Map().set('yes', true).set('no', false);
    strMapToJson(myMap)
    // '{"yes":true,"no":false}'
    
    • 另一种情况是,Map 的键名有非字符串,这时可以选择转为数组 JSON。
    function mapToArrayJson(map) {
      return JSON.stringify([...map]);
    }
    
    let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
    mapToArrayJson(myMap)
    // '[[true,7],[{"foo":3},["abc"]]]'
    
    (6)JSON 转为 Map
    • JSON 转为 Map,正常情况下,所有键名都是字符串。
    function jsonToStrMap(jsonStr) {
      return objToStrMap(JSON.parse(jsonStr));
    }
    
    jsonToStrMap('{"yes": true, "no": false}')
    // Map {'yes' => true, 'no' => false}
    
    • 但是,有一种特殊情况,整个 JSON 就是一个数组,且每个数组成员本身,又是一个有两个成员的数组。这时,它可以一一对应地转为 Map。这往往是 Map 转为数组 JSON 的逆操作。
    function jsonToMap(jsonStr) {
      return new Map(JSON.parse(jsonStr));
    }
    
    jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
    // Map {true => 7, Object {foo: 3} => ['abc']}
    

    10.4 WeakMap

    含义

    • WeakMap与Map的区别有两点。

    • 首先,WeakMap只接受对象作为键名(null除外),不接受其他类型的值作为键名。

    • 其次,WeakMap的键名所指向的对象,不计入垃圾回收机制。

    WeakMap 的语法

    • WeakMap 与 Map 在 API 上的区别主要是两个,一是没有遍历操作(即没有keys()、values()和entries()方法),也没有size属性。因为没有办法列出所有键名,某个键名是否存在完全不可预测,跟垃圾回收机制是否运行相关。这一刻可以取到键名,下一刻垃圾回收机制突然运行了,这个键名就没了,为了防止出现不确定性,就统一规定不能取到键名。二是无法清空,即不支持clear方法。因此,WeakMap只有四个方法可用:get()、set()、has()、delete()。

    WeakMap 的示例

    http://es6.ruanyifeng.com/#docs/set-map#WeakMap-的示例

    WeakMap 的用途

    • 前文说过,WeakMap 应用的典型场合就是 DOM 节点作为键名。下面是一个例子。
    let myElement = document.getElementById('logo');
    let myWeakmap = new WeakMap();
    
    myWeakmap.set(myElement, {timesClicked: 0});
    
    myElement.addEventListener('click', function() {
      let logoData = myWeakmap.get(myElement);
      logoData.timesClicked++;
    }, false);
    

    上面代码中,myElement是一个 DOM 节点,每当发生click事件,就更新一下状态。我们将这个状态作为键值放在 WeakMap 里,对应的键名就是myElement。一旦这个 DOM 节点删除,该状态就会自动消失,不存在内存泄漏风险。

    • WeakMap 的另一个用处是部署私有属性。
    const _counter = new WeakMap();
    const _action = new WeakMap();
    
    class Countdown {
      constructor(counter, action) {
        _counter.set(this, counter);
        _action.set(this, action);
      }
      dec() {
        let counter = _counter.get(this);
        if (counter < 1) return;
        counter--;
        _counter.set(this, counter);
        if (counter === 0) {
          _action.get(this)();
        }
      }
    }
    
    const c = new Countdown(2, () => console.log('DONE'));
    
    c.dec()
    c.dec()
    // DONE
    

    上面代码中,Countdown类的两个内部属性_counter和_action,是实例的弱引用,所以如果删除实例,它们也就随之消失,不会造成内存泄漏。

    11 Proxy <a id = "Proxy"></a>

    11.1 概述

    • Proxy 用于修改某些操作的默认行为,等同于在语言层面做出修改,所以属于一种“元编程”(meta programming),即对编程语言进行编程。

    • ES6 原生提供 Proxy 构造函数,用来生成 Proxy 实例。

    var proxy = new Proxy(target, handler);
    

    Proxy 对象的所有用法,都是上面这种形式,不同的只是handler参数的写法。其中,new Proxy()表示生成一个Proxy实例,target参数表示所要拦截的目标对象,handler参数也是一个对象,用来定制拦截行为。

    var obj = new Proxy({}, {
      get: function (target, key, receiver) {
        console.log(`getting ${key}!`);
        return Reflect.get(target, key, receiver);
      },
      set: function (target, key, value, receiver) {
        console.log(`setting ${key}!`);
        return Reflect.set(target, key, value, receiver);
      }
    });
    
    • 注意,要使得Proxy起作用,必须针对Proxy实例(上例是proxy对象)进行操作,而不是针对目标对象(上例是空对象)进行操作。

    • 如果handler没有设置任何拦截,那就等同于直接通向原对象。

    var target = {};
    var handler = {};
    var proxy = new Proxy(target, handler);
    proxy.a = 'b';
    target.a // "b"
    

    上面代码中,handler是一个空对象,没有任何拦截效果,访问proxy就等同于访问target。

    • 一个技巧是将 Proxy 对象,设置到object.proxy属性,从而可以在object对象上调用。
    var object = { proxy: new Proxy(target, handler) };
    
    • Proxy 实例也可以作为其他对象的原型对象。
    var proxy = new Proxy({}, {
      get: function(target, property) {
        return 35;
      }
    });
    
    let obj = Object.create(proxy);
    obj.time // 35
    

    上面代码中,proxy对象是obj对象的原型,obj对象本身并没有time属性,所以根据原型链,会在proxy对象上读取该属性,导致被拦截。

    • 下面是 Proxy 支持的拦截操作一览,一共 13 种。

      - get(target, propKey, receiver):拦截对象属性的读取,比如proxy.foo和proxy['foo']。

      - set(target, propKey, value, receiver):拦截对象属性的设置,比如proxy.foo = v或proxy['foo'] = v,返回一个布尔值。

      - has(target, propKey):拦截propKey in proxy的操作,返回一个布尔值。

      - deleteProperty(target, propKey):拦截delete proxy[propKey]的操作,返回一个布尔值。

      - ownKeys(target):拦截Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)、for...in循环,返回一个数组。该方法返回目标对象所有自身的属性的属性名,而Object.keys()的返回结果仅包括目标对象自身的可遍历属性。

      - getOwnPropertyDescriptor(target, propKey):拦截Object.getOwnPropertyDescriptor(proxy, propKey),返回属性的描述对象。

      - defineProperty(target, propKey, propDesc):拦截Object.defineProperty(proxy, propKey, propDesc)、Object.defineProperties(proxy, propDescs),返回一个布尔值。

      - preventExtensions(target):拦截Object.preventExtensions(proxy),返回一个布尔值。

      - getPrototypeOf(target):拦截Object.getPrototypeOf(proxy),返回一个对象。

      - isExtensible(target):拦截Object.isExtensible(proxy),返回一个布尔值。

      - setPrototypeOf(target, proto):拦截Object.setPrototypeOf(proxy, proto),返回一个布尔值。如果目标对象是函数,那么还有两种额外操作可以拦截。

      - apply(target, object, args):拦截 Proxy 实例作为函数调用的操作,比如proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)。

      - construct(target, args):拦截 Proxy 实例作为构造函数调用的操作,比如new proxy(...args)。

    11.2 Proxy 实例的方法

    get()

    • get方法用于拦截某个属性的读取操作,可以接受三个参数,依次为目标对象、属性名和 proxy 实例本身(严格地说,是操作行为所针对的对象),其中最后一个参数可选。

    • 如果一个属性不可配置(configurable)且不可写(writable),则 Proxy 不能修改该属性,否则通过 Proxy 对象访问该属性会报错。

    set()

    • set方法用来拦截某个属性的赋值操作,可以接受四个参数,依次为目标对象、属性名、属性值和 Proxy 实例本身,其中最后一个参数可选。

    apply()

    • apply方法拦截函数的调用、call和apply操作。

    • apply方法可以接受三个参数,分别是目标对象、目标对象的上下文对象(this)和目标对象的参数数组。

    has()

    • has方法用来拦截HasProperty操作,即判断对象是否具有某个属性时,这个方法会生效。典型的操作就是in运算符。

    • has方法可以接受两个参数,分别是目标对象、需查询的属性名。

    • 如果原对象不可配置或者禁止扩展,这时has拦截会报错。

    • 值得注意的是,has方法拦截的是HasProperty操作,而不是HasOwnProperty操作,即has方法不判断一个属性是对象自身的属性,还是继承的属性。

    • 另外,虽然for...in循环也用到了in运算符,但是has拦截对for...in循环不生效。

    construct()

    • construct方法用于拦截new命令,下面是拦截对象的写法。
    var handler = {
      construct (target, args, newTarget) {
        return new target(...args);
      }
    };
    
    • construct方法可以接受两个参数。

      - target:目标对象

      - args:构造函数的参数对象

      - newTarget:创造实例对象时,new命令作用的构造函数(下面例子的p)

    • construct方法返回的必须是一个对象,否则会报错。

    deleteProperty()

    • deleteProperty方法用于拦截delete操作,如果这个方法抛出错误或者返回false,当前属性就无法被delete命令删除。

    • 注意,目标对象自身的不可配置(configurable)的属性,不能被deleteProperty方法删除,否则报错。

    defineProperty()

    • defineProperty方法拦截了Object.defineProperty操作。
    var handler = {
      defineProperty (target, key, descriptor) {
        return false;
      }
    };
    var target = {};
    var proxy = new Proxy(target, handler);
    proxy.foo = 'bar' // 不会生效
    

    上面代码中,defineProperty方法返回false,导致添加新属性总是无效。

    • 注意,如果目标对象不可扩展(extensible),则defineProperty不能增加目标对象上不存在的属性,否则会报错。另外,如果目标对象的某个属性不可写(writable)或不可配置(configurable),则defineProperty方法不得改变这两个设置。

    getOwnPropertyDescriptor()

    • getOwnPropertyDescriptor方法拦截Object.getOwnPropertyDescriptor(),返回一个属性描述对象或者undefined。

    getPrototypeOf()

    • getPrototypeOf方法主要用来拦截获取对象原型。具体来说,拦截下面这些操作。

      - Object.prototype.proto

      - Object.prototype.isPrototypeOf()

      - Object.getPrototypeOf()

      - Reflect.getPrototypeOf()

      - instanceof

    • 注意,getPrototypeOf方法的返回值必须是对象或者null,否则报错。另外,如果目标对象不可扩展(extensible), getPrototypeOf方法必须返回目标对象的原型对象。

    isExtensible()

    • isExtensible方法拦截Object.isExtensible操作。

    • 注意,该方法只能返回布尔值,否则返回值会被自动转为布尔值。

    • 这个方法有一个强限制,它的返回值必须与目标对象的isExtensible属性保持一致,否则就会抛出错误。

    ownKey()

    • ownKeys方法用来拦截对象自身属性的读取操作。具体来说,拦截以下操作。

      - Object.getOwnPropertyNames()

      - Object.getOwnPropertySymbols()

      - Object.keys()

      - for...in循环

    • 注意,使用Object.keys方法时,有三类属性会被ownKeys方法自动过滤,不会返回。

      - 目标对象上不存在的属性

      - 属性名为 Symbol 值

      - 不可遍历(enumerable)的属性

    • ownKeys方法返回的数组成员,只能是字符串或 Symbol 值。如果有其他类型的值,或者返回的根本不是数组,就会报错。

    • 如果目标对象自身包含不可配置的属性,则该属性必须被ownKeys方法返回,否则报错。

    • 另外,如果目标对象是不可扩展的(non-extensition),这时ownKeys方法返回的数组之中,必须包含原对象的所有属性,且不能包含多余的属性,否则报错。

    preventExtensions()

    • preventExtensions方法拦截Object.preventExtensions()。该方法必须返回一个布尔值,否则会被自动转为布尔值。

    • 这个方法有一个限制,只有目标对象不可扩展时(即Object.isExtensible(proxy)为false),proxy.preventExtensions才能返回true,否则会报错。

    var p = new Proxy({}, {
      preventExtensions: function(target) {
        return true;
      }
    });
    
    Object.preventExtensions(p) // 报错
    

    上面代码中,proxy.preventExtensions方法返回true,但这时Object.isExtensible(proxy)会返回true,因此报错。

    为了防止出现这个问题,通常要在proxy.preventExtensions方法里面,调用一次Object.preventExtensions。

    var p = new Proxy({}, {
      preventExtensions: function(target) {
        console.log('called');
        Object.preventExtensions(target);
        return true;
      }
    });
    
    Object.preventExtensions(p)
    // "called"
    // true
    

    setPrototypeOf()

    • setPrototypeOf方法主要用来拦截Object.setPrototypeOf方法。

    • 注意,该方法只能返回布尔值,否则会被自动转为布尔值。另外,如果目标对象不可扩展(extensible),setPrototypeOf方法不得改变目标对象的原型。

    11.3 Proxy.revocable()

    • Proxy.revocable方法返回一个可取消的 Proxy 实例。
    let target = {};
    let handler = {};
    
    let {proxy, revoke} = Proxy.revocable(target, handler);
    
    proxy.foo = 123;
    proxy.foo // 123
    
    revoke();
    proxy.foo // TypeError: Revoked
    
    • Proxy.revocable方法返回一个对象,该对象的proxy属性是Proxy实例,revoke属性是一个函数,可以取消Proxy实例。上面代码中,当执行revoke函数之后,再访问Proxy实例,就会抛出一个错误。

    • Proxy.revocable的一个使用场景是,目标对象不允许直接访问,必须通过代理访问,一旦访问结束,就收回代理权,不允许再次访问。

    11.4 this 问题

    • 虽然 Proxy 可以代理针对目标对象的访问,但它不是目标对象的透明代理,即不做任何拦截的情况下,也无法保证与目标对象的行为一致。主要原因就是在 Proxy 代理的情况下,目标对象内部的this关键字会指向 Proxy 代理。

    11.5 实例:Web 服务的客户端

    http://es6.ruanyifeng.com/#docs/proxy#实例:Web-服务的客户端

    12 Reflect <a id = "Reflect"></a>

    12.1 概述

    • Reflect对象与Proxy对象一样,也是 ES6 为了操作对象而提供的新 API。Reflect对象的设计目的有这样几个。

    (1) 将Object对象的一些明显属于语言内部的方法(比如Object.defineProperty),放到Reflect对象上。现阶段,某些方法同时在Object和Reflect对象上部署,未来的新方法将只部署在Reflect对象上。也就是说,从Reflect对象上可以拿到语言内部的方法。

    (2) 修改某些Object方法的返回结果,让其变得更合理。比如,Object.defineProperty(obj, name, desc)在无法定义属性时,会抛出一个错误,而Reflect.defineProperty(obj, name, desc)则会返回false。

    (3) 让Object操作都变成函数行为。某些Object操作是命令式,比如name in obj和delete obj[name],而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。

    (4)Reflect对象的方法与Proxy对象的方法一一对应,只要是Proxy对象的方法,就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法,完成默认行为,作为修改行为的基础。也就是说,不管Proxy怎么修改默认行为,你总可以在Reflect上获取默认行为。

    12.2 静态方法

    • Reflect对象一共有 13 个静态方法。

      - Reflect.apply(target, thisArg, args)

      - Reflect.construct(target, args)

      - Reflect.get(target, name, receiver)

      - Reflect.set(target, name, value, receiver)

      - Reflect.defineProperty(target, name, desc)

      - Reflect.deleteProperty(target, name)

      - Reflect.has(target, name)

      - Reflect.ownKeys(target)

      - Reflect.isExtensible(target)

      - Reflect.preventExtensions(target)

      - Reflect.getOwnPropertyDescriptor(target, name)

      - Reflect.getPrototypeOf(target)

      - Reflect.setPrototypeOf(target, prototype)

    Reflect.get(target,name,receiver)

    • Reflect.get方法查找并返回target对象的name属性,如果没有该属性,则返回undefined。
    var myObject = {
      foo: 1,
      bar: 2,
      get baz() {
        return this.foo + this.bar;
      },
    }
    
    Reflect.get(myObject, 'foo') // 1
    Reflect.get(myObject, 'bar') // 2
    Reflect.get(myObject, 'baz') // 3
    
    • 如果name属性部署了读取函数(getter),则读取函数的this绑定receiver。
    var myObject = {
      foo: 1,
      bar: 2,
      get baz() {
        return this.foo + this.bar;
      },
    };
    
    var myReceiverObject = {
      foo: 4,
      bar: 4,
    };
    
    Reflect.get(myObject, 'baz', myReceiverObject) // 8
    

    如果第一个参数不是对象,Reflect.get方法会报错。

    Reflect.get(1, 'foo') // 报错
    Reflect.get(false, 'foo') // 报错
    

    Reflect.set(target,name,value,receiver)

    • Reflect.set方法设置target对象的name属性等于value。

    • 如果name属性设置了赋值函数,则赋值函数的this绑定receiver。

    • 如果第一个参数不是对象,Reflect.set会报错。

    Reflect.has(obj,name)

    • Reflect.has方法对应name in obj里面的in运算符。

    Reflect.deleteProperty(obj, name)

    • Reflect.deleteProperty方法等同于delete obj[name],用于删除对象的属性。

    Reflcet.construt(target,args)

    • Reflect.construct方法等同于new target(...args),这提供了一种不使用new,来调用构造函数的方法。

    Reflect.getPrototypeOf(boj)

    • Reflect.getPrototypeOf 方法用于读取对象的proto属性,对应 Object.getPrototypeOf(obj)。

    • Reflect.getPrototypeOf 和 Object.getPrototypeOf 的一个区别是,如果参数不是对象,Object.getPrototypeOf 会将这个参数转为对象,然后再运行,而 Reflect.getPrototypeOf 会报错。

    Reflect.setPrototypeOf(obj,newProto)

    • Reflect.setPrototypeOf 方法用于设置目标对象的原型(prototype),对应 Object.setPrototypeOf(obj, newProto) 方法。它返回一个布尔值,表示是否设置成功。

    • 如果无法设置目标对象的原型(比如,目标对象禁止扩展),Reflect.setPrototypeOf 方法返回false。

    Reflect.setPrototypeOf({}, null)
    // true
    Reflect.setPrototypeOf(Object.freeze({}), null)
    // false
    
    • 如果第一个参数不是对象,Object.setPrototypeOf 会返回第一个参数本身,而 Reflect.setPrototypeOf 会报错。

    • 如果第一个参数是 undefined 或 null,Object.setPrototypeOf 和 Reflect.setPrototypeOf 都会报错。

    Reflect.apply(func,thisArg,args)

    • Reflect.apply方法等同于Function.prototype.apply.call(func, thisArg, args),用于绑定this对象后执行给定函数。

    Reflect.defineProperty(target,propertyKey,attributes)

    • Reflect.defineProperty 方法基本等同于 Object.defineProperty,用来为对象定义属性。未来,后者会被逐渐废除,请从现在开始就使用 Reflect.defineProperty 代替它。

    Reflect.getOwnPropertyDescriptor(target,propertyKey)

    • Reflect.getOwnPropertyDescriptor 基本等同于 Object.getOwnPropertyDescriptor,用于得到指定属性的描述对象,将来会替代掉后者。

    Reflect.isExtensible(target)

    • Reflect.isExtensible 方法对应 Object.isExtensible,返回一个布尔值,表示当前对象是否可扩展。

    Reflect.preventExtension(target)

    • Reflect.preventExtensions 对应 Object.preventExtensions 方法,用于让一个对象变为不可扩展。它返回一个布尔值,表示是否操作成功。

    Reflect.ownKeys(target)

    • Reflect.ownKeys 方法用于返回对象的所有属性,基本等同于 Object.getOwnPropertyNames 与 Object.getOwnPropertySymbols 之和。

    12.3 实例:使用 Proxy 实现观察者模式

    http://es6.ruanyifeng.com/#docs/reflect#实例:使用-Proxy-实现观察者模式

    13 Promise 对象 <a id = "Promise"></a>

    13.1 Promise 的含义

    • Promise 是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理和更强大。

    • 所谓 Promise,简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果。从语法上说,Promise 是一个对象,从它可以获取异步操作的消息。Promise 提供统一的 API,各种异步操作都可以用同样的方法进行处理。

    • Promise对象有以下两个特点。

    (1)对象的状态不受外界影响。Promise对象代表一个异步操作,有三种状态:pending(进行中)、fulfilled(已成功)和rejected(已失败)。只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。这也是Promise这个名字的由来,它的英语意思就是“承诺”,表示其他手段无法改变。

    (2)一旦状态改变,就不会再变,任何时候都可以得到这个结果。Promise对象的状态改变,只有两种可能:从pending变为fulfilled和从pending变为rejected。只要这两种情况发生,状态就凝固了,不会再变了,会一直保持这个结果,这时就称为 resolved(已定型)。如果改变已经发生了,你再对Promise对象添加回调函数,也会立即得到这个结果。这与事件(Event)完全不同,事件的特点是,如果你错过了它,再去监听,是得不到结果的。

    • 有了Promise对象,就可以将异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数。此外,Promise对象提供统一的接口,使得控制异步操作更加容易。

    • Promise也有一些缺点。首先,无法取消Promise,一旦新建它就会立即执行,无法中途取消。其次,如果不设置回调函数,Promise内部抛出的错误,不会反应到外部。第三,当处于pending状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成)。

    13.2 基本用法

    • ES6 规定,Promise对象是一个构造函数,用来生成Promise实例。

    • Promise 构造函数接受一个函数作为参数,该函数的两个参数分别是resolve和reject。它们是两个函数,由 JavaScript 引擎提供,不用自己部署。

    • Promise实例生成以后,可以用then方法分别指定resolved状态和rejected状态的回调函数。其中,第二个函数是可选的,不一定要提供。这两个函数都接受Promise对象传出的值作为参数。

    13.3 Promise.prototype.then()

    • Promise 实例具有then方法,也就是说,then方法是定义在原型对象Promise.prototype上的。它的作用是为 Promise 实例添加状态改变时的回调函数。前面说过,then方法的第一个参数是resolved状态的回调函数,第二个参数(可选)是rejected状态的回调函数。

    • then方法返回的是一个新的Promise实例(注意,不是原来那个Promise实例)。因此可以采用链式写法,即then方法后面再调用另一个then方法。

    getJSON("/posts.json").then(function(json) {
      return json.post;
    }).then(function(post) {
      // ...
    });
    

    上面的代码使用then方法,依次指定了两个回调函数。第一个回调函数完成以后,会将返回结果作为参数,传入第二个回调函数。

    13.4 Promise.prototype.catch()

    • Promise.prototype.catch方法是.then(null, rejection)的别名,用于指定发生错误时的回调函数。
    getJSON('/posts.json').then(function(posts) {
      // ...
    }).catch(function(error) {
      // 处理 getJSON 和 前一个回调函数运行时发生的错误
      console.log('发生错误!', error);
    });
    
    • 另外,then方法指定的回调函数,如果运行中抛出错误,也会被catch方法捕获。

    • Promise 对象的错误具有“冒泡”性质,会一直向后传递,直到被捕获为止。也就是说,错误总是会被下一个catch语句捕获。

    getJSON('/post/1.json').then(function(post) {
      return getJSON(post.commentURL);
    }).then(function(comments) {
      // some code
    }).catch(function(error) {
      // 处理前面三个Promise产生的错误
    });
    

    上面代码中,一共有三个 Promise 对象:一个由getJSON产生,两个由then产生。它们之中任何一个抛出的错误,都会被最后一个catch捕获。

    • 一般来说,不要在then方法里面定义 Reject 状态的回调函数(即then的第二个参数),总是使用catch方法。

    • 跟传统的try/catch代码块不同的是,如果没有使用catch方法指定错误处理的回调函数,Promise 对象抛出的错误不会传递到外层代码,即不会有任何反应。

    13.5 Promise.prototype.finally()

    • finally方法用于指定不管 Promise 对象最后状态如何,都会执行的操作。该方法是 ES2018 引入标准的。
    promise
    .then(result => {···})
    .catch(error => {···})
    .finally(() => {···});
    
    • finally方法的回调函数不接受任何参数,这意味着没有办法知道,前面的 Promise 状态到底是fulfilled还是rejected。这表明,finally方法里面的操作,应该是与状态无关的,不依赖于 Promise 的执行结果。

    13.6 Promise.all()

    • Promise.all 方法用于将多个 Promise 实例,包装成一个新的 Promise 实例。
    const p = Promise.all([p1, p2, p3]);
    

    上面代码中,Promise.all 方法接受一个数组作为参数,p1、p2、p3都是 Promise 实例,如果不是,就会先调用下面讲到的Promise.resolve方法,将参数转为 Promise 实例,再进一步处理。(Promise.all 方法的参数可以不是数组,但必须具有 Iterator 接口,且返回的每个成员都是 Promise 实例。)

    p的状态由p1、p2、p3决定,分成两种情况。

    (1)只有p1、p2、p3的状态都变成fulfilled,p的状态才会变成fulfilled,此时p1、p2、p3的返回值组成一个数组,传递给p的回调函数。

    (2)只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。

    13.7 Promise.race()

    • Promise.race方法同样是将多个 Promise 实例,包装成一个新的 Promise 实例。
    const p = Promise.race([p1, p2, p3]);
    

    上面代码中,只要p1、p2、p3之中有一个实例率先改变状态,p的状态就跟着改变。那个率先改变的 Promise 实例的返回值,就传递给p的回调函数。

    Promise.race 方法的参数与 Promise.all 方法一样,如果不是 Promise 实例,就会先调用下面讲到的 Promise.resolve 方法,将参数转为 Promise 实例,再进一步处理。

    13.8 Promise.resolve()

    • 有时需要将现有对象转为 Promise 对象,Promise.resolve方法就起到这个作用。

    • Promise.resolve方法的参数分成四种情况。

    (1)参数是一个 Promise 实例

    • 如果参数是 Promise 实例,那么 Promise.resolve 将不做任何修改、原封不动地返回这个实例。

    (2)参数是一个 thenable 对象

    • thenable对象指的是具有then方法的对象,比如下面这个对象。
    let thenable = {
      then: function(resolve, reject) {
        resolve(42);
      }
    };
    

    Promise.resolve方法会将这个对象转为 Promise 对象,然后就立即执行thenable对象的then方法。

    let thenable = {
      then: function(resolve, reject) {
        resolve(42);
      }
    };
    
    let p1 = Promise.resolve(thenable);
    p1.then(function(value) {
      console.log(value);  // 42
    });
    

    上面代码中,thenable对象的then方法执行后,对象p1的状态就变为resolved,从而立即执行最后那个then方法指定的回调函数,输出 42。

    (3)参数不是具有 then 方法的对象,或根本就不是对象

    • 如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的 Promise 对象,状态为resolved。

    (4)不带有任何参数

    • Promise.resolve方法允许调用时不带参数,直接返回一个resolved状态的 Promise 对象。

    所以,如果希望得到一个 Promise 对象,比较方便的方法就是直接调用Promise.resolve方法。

    const p = Promise.resolve();
    
    p.then(function () {
      // ...
    });
    

    上面代码的变量p就是一个 Promise 对象。

    需要注意的是,立即resolve的 Promise 对象,是在本轮“事件循环”(event loop)的结束时,而不是在下一轮“事件循环”的开始时。

    setTimeout(function () {
      console.log('three');
    }, 0);
    
    Promise.resolve().then(function () {
      console.log('two');
    });
    
    console.log('one');
    
    // one
    // two
    // three
    

    上面代码中,setTimeout(fn, 0)在下一轮“事件循环”开始时执行,Promise.resolve()在本轮“事件循环”结束时执行,console.log('one')则是立即执行,因此最先输出。

    13.9 Promise.reject()

    • Promise.reject(reason)方法也会返回一个新的 Promise 实例,该实例的状态为rejected。
    const p = Promise.reject('出错了');
    // 等同于
    const p = new Promise((resolve, reject) => reject('出错了'))
    
    p.then(null, function (s) {
      console.log(s)
    });
    // 出错了
    

    上面代码生成一个 Promise 对象的实例p,状态为rejected,回调函数会立即执行。

    • 注意,Promise.reject()方法的参数,会原封不动地作为reject的理由,变成后续方法的参数。这一点与Promise.resolve方法不一致。
    const thenable = {
      then(resolve, reject) {
        reject('出错了');
      }
    };
    
    Promise.reject(thenable)
    .catch(e => {
      console.log(e === thenable)
    })
    // true
    

    上面代码中,Promise.reject方法的参数是一个thenable对象,执行以后,后面catch方法的参数不是reject抛出的“出错了”这个字符串,而是thenable对象。

    13.10 应用

    加载图片

    • 我们可以将图片的加载写成一个Promise,一旦加载完成,Promise的状态就发生变化。
    const preloadImage = function (path) {
      return new Promise(function (resolve, reject) {
        const image = new Image();
        image.onload  = resolve;
        image.onerror = reject;
        image.src = path;
      });
    };
    

    14 Iterator 和 for……of 循环 <a id = "Iterator 和 for……of 循环"></a>

    14.1 Iterator(遍历器)的概念

    • 遍历器(Iterator)它是一种接口,为各种不同的数据结构提供统一的访问机制。任何数据结构只要部署 Iterator 接口,就可以完成遍历操作(即依次处理该数据结构的所有成员)。

    • Iterator 的作用有三个:一是为各种数据结构,提供一个统一的、简便的访问接口;二是使得数据结构的成员能够按某种次序排列;三是 ES6 创造了一种新的遍历命令for...of循环,Iterator 接口主要供for...of消费。

    • Iterator 的遍历过程是这样的。

    (1)创建一个指针对象,指向当前数据结构的起始位置。也就是说,遍历器对象本质上,就是一个指针对象。

    (2)第一次调用指针对象的next方法,可以将指针指向数据结构的第一个成员。

    (3)第二次调用指针对象的next方法,指针就指向数据结构的第二个成员。

    (4)不断调用指针对象的next方法,直到它指向数据结构的结束位置。

    每一次调用next方法,都会返回数据结构的当前成员的信息。具体来说,就是返回一个包含value和done两个属性的对象。其中,value属性是当前成员的值,done属性是一个布尔值,表示遍历是否结束。

    14.2 默认 Iterator 接口

    • 当使用for...of循环遍历某种数据结构时,该循环会自动去寻找 Iterator 接口。

    • 一种数据结构只要部署了 Iterator 接口,我们就称这种数据结构是“可遍历的”(iterable)。

    • ES6 规定,默认的 Iterator 接口部署在数据结构的Symbol.iterator属性,或者说,一个数据结构只要具有Symbol.iterator属性,就可以认为是“可遍历的”(iterable)。Symbol.iterator属性本身是一个函数,就是当前数据结构默认的遍历器生成函数。执行这个函数,就会返回一个遍历器。至于属性名Symbol.iterator,它是一个表达式,返回Symbol对象的iterator属性,这是一个预定义好的、类型为 Symbol 的特殊值,所以要放在方括号内(参见《Symbol》一章)。

    • 原生具备 Iterator 接口的数据结构如下。

      - Array

      - Map

      - Set

      - String

      - TypedArray

      - 函数的 arguments 对象

      - NodeList 对象

    • 对象(Object)之所以没有默认部署 Iterator 接口,是因为对象的哪个属性先遍历,哪个属性后遍历是不确定的,需要开发者手动指定。本质上,遍历器是一种线性处理,对于任何非线性的数据结构,部署遍历器接口,就等于部署一种线性转换。不过,严格地说,对象部署遍历器接口并不是很必要,因为这时对象实际上被当作 Map 结构使用,ES5 没有 Map 结构,而 ES6 原生提供了。

    • 对于类似数组的对象(存在数值键名和length属性),部署 Iterator 接口,有一个简便方法,就是Symbol.iterator方法直接引用数组的 Iterator 接口。

    let iterable = {
      0: 'a',
      1: 'b',
      2: 'c',
      length: 3,
      [Symbol.iterator]: Array.prototype[Symbol.iterator]
    };
    for (let item of iterable) {
      console.log(item); // 'a', 'b', 'c'
    }
    

    14.3 调用 Iterator 接口的场合

    • 有一些场合会默认调用 Iterator 接口(即Symbol.iterator方法),除了下文会介绍的for...of循环,还有几个别的场合。

    (1)解构赋值

    (2)扩展运算符

    (3)yield*

    (4)其他场合

    • 由于数组的遍历会调用遍历器接口,所以任何接受数组作为参数的场合,其实都调用了遍历器接口。下面是一些例子。

      - for...of

      - Array.from()

      - Map(), Set(), WeakMap(), WeakSet()(比如new Map([['a',1],['b',2]]))

      - Promise.all()

      - Promise.race()

    14.4 字符串的 Iterator 接口

    • 字符串是一个类似数组的对象,也原生具有 Iterator 接口。

    14.5 Iterator 接口与 Generator 函数

    • Symbol.iterator方法的最简单实现,还是使用下一章要介绍的 Generator 函数。
    let myIterable = {
      [Symbol.iterator]: function* () {
        yield 1;
        yield 2;
        yield 3;
      }
    }
    [...myIterable] // [1, 2, 3]
    
    // 或者采用下面的简洁写法
    
    let obj = {
      * [Symbol.iterator]() {
        yield 'hello';
        yield 'world';
      }
    };
    
    for (let x of obj) {
      console.log(x);
    }
    // "hello"
    // "world"
    

    上面代码中,Symbol.iterator方法几乎不用部署任何代码,只要用 yield 命令给出每一步的返回值即可。

    14.6 遍历器对象的 return(),throw()

    • 遍历器对象除了具有next方法,还可以具有return方法和throw方法。如果你自己写遍历器对象生成函数,那么next方法是必须部署的,return方法和throw方法是否部署是可选的。

    • return方法的使用场合是,如果for...of循环提前退出(通常是因为出错,或者有break语句或continue语句),就会调用return方法。如果一个对象在完成遍历前,需要清理或释放资源,就可以部署return方法。

    • 注意,return方法必须返回一个对象,这是 Generator 规格决定的。

    • throw方法主要是配合 Generator 函数使用,一般的遍历器对象用不到这个方法。请参阅《Generator 函数》一章。

    14.7 for……of 循环

    • for...of循环可以使用的范围包括数组、Set 和 Map 结构、某些类似数组的对象(比如arguments对象、DOM NodeList 对象)、后文的 Generator 对象,以及字符串。

    数组

    • 数组原生具备iterator接口(即默认部署了Symbol.iterator属性),for...of循环本质上就是调用这个接口产生的遍历器。

    • for...in循环读取键名,for...of循环读取键值。如果要通过for...of循环,获取数组的索引,可以借助数组实例的entries方法和keys方法(参见《数组的扩展》一章)。

    • for...of循环调用遍历器接口,数组的遍历器接口只返回具有数字索引的属性。这一点跟for...in循环也不一样。

    Set 和 Map 结构

    • 首先,遍历的顺序是按照各个成员被添加进数据结构的顺序。

    • 其次,Set 结构遍历时,返回的是一个值,而 Map 结构遍历时,返回的是一个数组,该数组的两个成员分别为当前 Map 成员的键名和键值。

    计算生成的数据结构

    • 有些数据结构是在现有数据结构的基础上,计算生成的。比如,ES6 的数组、Set、Map 都部署了以下三个方法,调用后都返回遍历器对象。

      - entries() 返回一个遍历器对象,用来遍历[键名, 键值]组成的数组。对于数组,键名就是索引值;对于 Set,键名与键值相同。Map 结构的 Iterator 接口,默认就是调用entries方法。

      - keys() 返回一个遍历器对象,用来遍历所有的键名。

      - values() 返回一个遍历器对象,用来遍历所有的键值。

    这三个方法调用后生成的遍历器对象,所遍历的都是计算生成的数据结构。

    let arr = ['a', 'b', 'c'];
    for (let pair of arr.entries()) {
      console.log(pair);
    }
    // [0, 'a']
    // [1, 'b']
    // [2, 'c']
    

    类似数组的对象

    • 并不是所有类似数组的对象都具有 Iterator 接口,一个简便的解决方法,就是使用Array.from方法将其转为数组。

    对象

    • 对于普通的对象,for...of结构不能直接使用,会报错,必须部署了 Iterator 接口后才能使用。但是,这样情况下,for...in循环依然可以用来遍历键名。

    • 一种解决方法是,使用Object.keys方法将对象的键名生成一个数组,然后遍历这个数组。

    for (var key of Object.keys(someObject)) {
      console.log(key + ': ' + someObject[key]);
    }
    
    • 另一个方法是使用 Generator 函数将对象重新包装一下。
    function* entries(obj) {
      for (let key of Object.keys(obj)) {
        yield [key, obj[key]];
      }
    }
    
    for (let [key, value] of entries(obj)) {
      console.log(key, '->', value);
    }
    // a -> 1
    // b -> 2
    // c -> 3
    

    与其他遍历语法的比较

    • 最原始的写法就是for循环。这种写法比较麻烦。

    • forEach方法的问题在于,无法中途跳出forEach循环,break命令或return命令都不能奏效。

    • for...in循环有几个缺点。

      - 数组的键名是数字,但是for...in循环是以字符串作为键名“0”、“1”、“2”等等。

      - for...in循环不仅遍历数字键名,还会遍历手动添加的其他键,甚至包括原型链上的键。

      - 某些情况下,for...in循环会以任意顺序遍历键名。

    总之,for...in循环主要是为遍历对象而设计的,不适用于遍历数组。

    • for...of循环相比上面几种做法,有一些显著的优点。

      - 有着同for...in一样的简洁语法,但是没有for...in那些缺点。

      - 不同于forEach方法,它可以与break、continue和return配合使用。

      - 提供了遍历所有数据结构的统一操作接口。

    15 Generator 函数的语法 <a id = "Generator 函数的语法"></a>

    15.1 简介

    基本概念

    • Generator 函数是 ES6 提供的一种异步编程解决方案。语法上,可以把它理解成是一个状态机,封装了多个内部状态。

    • 执行 Generator 函数会返回一个遍历器对象。

    • 形式上,Generator 函数是一个普通函数,但是有两个特征。一是,function关键字与函数名之间有一个星号;二是,函数体内部使用yield表达式,定义不同的内部状态(yield在英语里的意思就是“产出”)。

    • Generator 函数的调用方法与普通函数一样,也是在函数名后面加上一对圆括号。不同的是,调用 Generator 函数后,该函数并不执行,返回的也不是函数运行结果,而是一个指向内部状态的指针对象,也就是上一章介绍的遍历器对象(Iterator Object)。

    • 下一步,必须调用遍历器对象的next方法,使得指针移向下一个状态。也就是说,每次调用next方法,内部指针就从函数头部或上一次停下来的地方开始执行,直到遇到下一个yield表达式(或return语句)为止。换言之,Generator 函数是分段执行的,yield表达式是暂停执行的标记,而next方法可以恢复执行。

    • ES6 没有规定,function关键字与函数名之间的星号,写在哪个位置。这导致下面的写法都能通过。

    function * foo(x, y) { ··· }
    function *foo(x, y) { ··· }
    function* foo(x, y) { ··· }
    function*foo(x, y) { ··· }
    

    由于 Generator 函数仍然是普通函数,所以一般的写法是上面的第三种,即星号紧跟在function关键字后面。

    yield 表达式

    • 由于 Generator 函数返回的遍历器对象,只有调用next方法才会遍历下一个内部状态,所以其实提供了一种可以暂停执行的函数。yield表达式就是暂停标志。

    • 需要注意的是,yield表达式后面的表达式,只有当调用next方法、内部指针指向该语句时才会执行,因此等于为 JavaScript 提供了手动的“惰性求值”(Lazy Evaluation)的语法功能。

    function* gen() {
      yield  123 + 456;
    }
    

    上面代码中,yield后面的表达式123 + 456,不会立即求值,只会在next方法将指针移到这一句时,才会求值。

    • Generator 函数可以不用yield表达式,这时就变成了一个单纯的暂缓执行函数。

    • 另外需要注意,yield表达式只能用在 Generator 函数里面,用在其他地方都会报错。

    • 另外,yield表达式如果用在另一个表达式之中,必须放在圆括号里面。

    function* demo() {
      console.log('Hello' + yield); // SyntaxError
      console.log('Hello' + yield 123); // SyntaxError
    
      console.log('Hello' + (yield)); // OK
      console.log('Hello' + (yield 123)); // OK
    }
    
    • yield表达式用作函数参数或放在赋值表达式的右边,可以不加括号。
    function* demo() {
      foo(yield 'a', yield 'b'); // OK
      let input = yield; // OK
    }
    

    与 Iterator 接口的关系

    • 上一章说过,任意一个对象的Symbol.iterator方法,等于该对象的遍历器生成函数,调用该函数会返回该对象的一个遍历器对象。

    • 由于 Generator 函数就是遍历器生成函数,因此可以把 Generator 赋值给对象的Symbol.iterator属性,从而使得该对象具有 Iterator 接口。

    var myIterable = {};
    myIterable[Symbol.iterator] = function* () {
      yield 1;
      yield 2;
      yield 3;
    };
    
    [...myIterable] // [1, 2, 3]
    

    上面代码中,Generator 函数赋值给Symbol.iterator属性,从而使得myIterable对象具有了 Iterator 接口,可以被...运算符遍历了。

    • Generator 函数执行后,返回一个遍历器对象。该对象本身也具有Symbol.iterator 属性,执行后返回自身。
    function* gen(){
      // some code
    }
    
    var g = gen();
    
    g[Symbol.iterator]() === g
    // true
    

    上面代码中,gen是一个 Generator 函数,调用它会生成一个遍历器对象g。它的Symbol.iterator属性,也是一个遍历器对象生成函数,执行后返回它自己。

    15.2 next 方法的参数

    • yield表达式本身没有返回值,或者说总是返回undefined。next方法可以带一个参数,该参数就会被当作上一个yield表达式的返回值。

    • 这个功能有很重要的语法意义。Generator 函数从暂停状态到恢复运行,它的上下文状态(context)是不变的。通过next方法的参数,就有办法在 Generator 函数开始运行之后,继续向函数体内部注入值。也就是说,可以在 Generator 函数运行的不同阶段,从外部向内部注入不同的值,从而调整函数行为。

    function* foo(x) {
      var y = 2 * (yield (x + 1));
      var z = yield (y / 3);
      return (x + y + z);
    }
    
    var a = foo(5);
    a.next() // Object{value:6, done:false}
    a.next() // Object{value:NaN, done:false}
    a.next() // Object{value:NaN, done:true}
    
    var b = foo(5);
    b.next() // { value:6, done:false }
    b.next(12) // { value:8, done:false }
    b.next(13) // { value:42, done:true }
    
    • 注意,由于next方法的参数表示上一个yield表达式的返回值,所以在第一次使用next方法时,传递参数是无效的。V8 引擎直接忽略第一次使用next方法时的参数,只有从第二次使用next方法开始,参数才是有效的。从语义上讲,第一个next方法用来启动遍历器对象,所以不用带有参数。

    15.3 for……of 循环

    • for...of 循环可以自动遍历 Generator 函数时生成的Iterator对象,且此时不再需要调用next方法。

    下面是一个利用 Generator 函数和for...of循环,实现斐波那契数列的例子。

    function* fibonacci() {
      let [prev, curr] = [0, 1];
      for (;;) {
        yield curr;
        [prev, curr] = [curr, prev + curr];
      }
    }
    
    for (let n of fibonacci()) {
      if (n > 1000) break;
      console.log(n);
    }
    

    从上面代码可见,使用for...of语句时不需要使用next方法。

    • 利用for...of循环,可以写出遍历任意对象(object)的方法。原生的 JavaScript 对象没有遍历接口,无法使用for...of循环,通过 Generator 函数为它加上这个接口,就可以用了。

    • 除了for...of循环以外,扩展运算符(...)、解构赋值和Array.from方法内部调用的,都是遍历器接口。这意味着,它们都可以将 Generator 函数返回的 Iterator 对象,作为参数。

    15.4 Generator.prototype.throw()

    • Generator 函数返回的遍历器对象,都有一个throw方法,可以在函数体外抛出错误,然后在 Generator 函数体内捕获。
    var g = function* () {
      try {
        yield;
      } catch (e) {
        console.log('内部捕获', e);
      }
    };
    
    var i = g();
    i.next();
    
    try {
      i.throw('a');
      i.throw('b');
    } catch (e) {
      console.log('外部捕获', e);
    }
    // 内部捕获 a
    // 外部捕获 b
    
    • throw方法抛出的错误要被内部捕获,前提是必须至少执行过一次next方法。

    • throw方法被捕获以后,会附带执行下一条yield表达式。也就是说,会附带执行一次next方法。

    • Generator 函数体外抛出的错误,可以在函数体内捕获;反过来,Generator 函数体内抛出的错误,也可以被函数体外的catch捕获。

    function* foo() {
      var x = yield 3;
      var y = x.toUpperCase();
      yield y;
    }
    
    var it = foo();
    
    it.next(); // { value:3, done:false }
    
    try {
      it.next(42);
    } catch (err) {
      console.log(err);
    }
    

    上面代码中,第二个next方法向函数体内传入一个参数 42,数值是没有toUpperCase方法的,所以会抛出一个 TypeError 错误,被函数体外的catch捕获。

    • 一旦 Generator 执行过程中抛出错误,且没有被内部捕获,就不会再执行下去了。如果此后还调用next方法,将返回一个value属性等于undefined、done属性等于true的对象,即 JavaScript 引擎认为这个 Generator 已经运行结束了。

    15.5 Generator.prototype.return()

    • Generator 函数返回的遍历器对象,还有一个return方法,可以返回给定的值,并且终结遍历 Generator 函数。

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

    function* numbers () {
      yield 1;
      try {
        yield 2;
        yield 3;
      } finally {
        yield 4;
        yield 5;
      }
      yield 6;
    }
    var g = numbers();
    g.next() // { value: 1, done: false }
    g.next() // { value: 2, done: false }
    g.return(7) // { value: 4, done: false }
    g.next() // { value: 5, done: false }
    g.next() // { value: 7, done: true }
    

    上面代码中,调用return方法后,就开始执行finally代码块,然后等到finally代码块执行完,再执行return方法。

    15.6 next()、throw()、return() 的共同点

    • next()、throw()、return()这三个方法本质上是同一件事,可以放在一起理解。它们的作用都是让 Generator 函数恢复执行,并且使用不同的语句替换yield表达式。

    15.7 yield* 表达式

    • 如果在 Generator 函数内部,调用另一个 Generator 函数,默认情况下是没有效果的。这个就需要用到yield*表达式,用来在一个 Generator 函数里面执行另一个 Generator 函数。

    来看一个对比的例子。

    function* inner() {
      yield 'hello!';
    }
    
    function* outer1() {
      yield 'open';
      yield inner();
      yield 'close';
    }
    
    var gen = outer1()
    gen.next().value // "open"
    gen.next().value // 返回一个遍历器对象
    gen.next().value // "close"
    
    function* outer2() {
      yield 'open'
      yield* inner()
      yield 'close'
    }
    
    var gen = outer2()
    gen.next().value // "open"
    gen.next().value // "hello!"
    gen.next().value // "close"
    
    • 如果yield*后面跟着一个数组,由于数组原生支持遍历器,因此就会遍历数组成员。

    • 实际上,任何数据结构只要有 Iterator 接口,就可以被yield*遍历。

    • 如果被代理的 Generator 函数有return语句,那么就可以向代理它的 Generator 函数返回数据。

    function* foo() {
      yield 2;
      yield 3;
      return "foo";
    }
    
    function* bar() {
      yield 1;
      var v = yield* foo();
      console.log("v: " + v);
      yield 4;
    }
    
    var it = bar();
    
    it.next()
    // {value: 1, done: false}
    it.next()
    // {value: 2, done: false}
    it.next()
    // {value: 3, done: false}
    it.next();
    // "v: foo"
    // {value: 4, done: false}
    it.next()
    // {value: undefined, done: true}
    

    上面代码在第四次调用next方法的时候,屏幕上会有输出,这是因为函数foo的return语句,向函数bar提供了返回值。

    15.8 作为对象属性的 Generator 函数

    • 如果一个对象的属性是 Generator 函数,可以简写成下面的形式。
    let obj = {
      * myGeneratorMethod() {
        ···
      }
    };
    

    15.9 函数的 this

    • Generator 函数总是返回一个遍历器,ES6 规定这个遍历器是 Generator 函数的实例,也继承了 Generator 函数的prototype对象上的方法。
    function* g() {}
    
    g.prototype.hello = function () {
      return 'hi!';
    };
    
    let obj = g();
    
    obj instanceof g // true
    obj.hello() // 'hi!'
    

    上面代码表明,Generator 函数g返回的遍历器obj,是g的实例,而且继承了g.prototype。但是,如果把g当作普通的构造函数,并不会生效,因为g返回的总是遍历器对象,而不是this对象。

    • Generator 函数也不能跟new命令一起用,会报错。

    http://es6.ruanyifeng.com/#docs/generator#Generator-函数的this

    15.10 含义

    Generator 与状态机

    • Generator 是实现状态机的最佳结构。比如,下面的clock函数就是一个状态机。
    var ticking = true;
    var clock = function() {
      if (ticking)
        console.log('Tick!');
      else
        console.log('Tock!');
      ticking = !ticking;
    }
    

    上面代码的clock函数一共有两种状态(Tick和Tock),每运行一次,就改变一次状态。这个函数如果用 Generator 实现,就是下面这样。

    var clock = function* () {
      while (true) {
        console.log('Tick!');
        yield;
        console.log('Tock!');
        yield;
      }
    };
    

    上面的 Generator 实现与 ES5 实现对比,可以看到少了用来保存状态的外部变量ticking,这样就更简洁,更安全(状态不会被非法篡改)、更符合函数式编程的思想,在写法上也更优雅。Generator 之所以可以不用外部变量保存状态,是因为它本身就包含了一个状态信息,即目前是否处于暂停态。

    Generator 与协程

    http://es6.ruanyifeng.com/#docs/generator#Generator-与协程

    Generator 与上下文

    • JavaScript 代码运行时,会产生一个全局的上下文环境(context,又称运行环境),包含了当前所有的变量和对象。然后,执行函数(或块级代码)的时候,又会在当前上下文环境的上层,产生一个函数运行的上下文,变成当前(active)的上下文,由此形成一个上下文环境的堆栈(context stack)。

    这个堆栈是“后进先出”的数据结构,最后产生的上下文环境首先执行完成,退出堆栈,然后再执行完成它下层的上下文,直至所有代码执行完成,堆栈清空。

    Generator 函数不是这样,它执行产生的上下文环境,一旦遇到yield命令,就会暂时退出堆栈,但是并不消失,里面的所有变量和对象会冻结在当前状态。等到对它执行next命令时,这个上下文环境又会重新加入调用栈,冻结的变量和对象恢复执行。

    function* gen() {
      yield 1;
      return 2;
    }
    
    let g = gen();
    
    console.log(
      g.next().value,
      g.next().value,
    );
    

    上面代码中,第一次执行g.next()时,Generator 函数gen的上下文会加入堆栈,即开始运行gen内部的代码。等遇到yield 1时,gen上下文退出堆栈,内部状态冻结。第二次执行g.next()时,gen上下文重新加入堆栈,变成当前的上下文,重新恢复执行。

    15.11 应用

    • Generator 可以暂停函数执行,返回任意表达式的值。这种特点使得 Generator 有多种应用场景。

    (1)异步操作的同步化表达

    • Generator 函数的暂停执行的效果,意味着可以把异步操作写在yield表达式里面,等到调用next方法时再往后执行。这实际上等同于不需要写回调函数了,因为异步操作的后续操作可以放在yield表达式下面,反正要等到调用next方法时再执行。所以,Generator 函数的一个重要实际意义就是用来处理异步操作,改写回调函数。
    function* loadUI() {
      showLoadingScreen();
      yield loadUIDataAsynchronously();
      hideLoadingScreen();
    }
    var loader = loadUI();
    // 加载UI
    loader.next()
    
    // 卸载UI
    loader.next()
    

    上面代码中,第一次调用loadUI函数时,该函数不会执行,仅返回一个遍历器。下一次对该遍历器调用next方法,则会显示Loading界面(showLoadingScreen),并且异步加载数据(loadUIDataAsynchronously)。等到数据加载完成,再一次使用next方法,则会隐藏Loading界面。可以看到,这种写法的好处是所有Loading界面的逻辑,都被封装在一个函数,按部就班非常清晰。

    • Ajax 是典型的异步操作,通过 Generator 函数部署 Ajax 操作,可以用同步的方式表达。
    function* main() {
      var result = yield request("http://some.url");
      var resp = JSON.parse(result);
        console.log(resp.value);
    }
    
    function request(url) {
      makeAjaxCall(url, function(response){
        it.next(response);
      });
    }
    
    var it = main();
    it.next();
    

    上面代码的main函数,就是通过 Ajax 操作获取数据。可以看到,除了多了一个yield,它几乎与同步操作的写法完全一样。注意,makeAjaxCall函数中的next方法,必须加上response参数,因为yield表达式,本身是没有值的,总是等于undefined。

    • 下面是另一个例子,通过 Generator 函数逐行读取文本文件。
    function* numbers() {
      let file = new FileReader("numbers.txt");
      try {
        while(!file.eof) {
          yield parseInt(file.readLine(), 10);
        }
      } finally {
        file.close();
      }
    }
    

    上面代码打开文本文件,使用yield表达式可以手动逐行读取文件。

    (2)控制流管理

    (3)部署 Iterator 接口

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

    function* iterEntries(obj) {
      let keys = Object.keys(obj);
      for (let i=0; i < keys.length; i++) {
        let key = keys[i];
        yield [key, obj[key]];
      }
    }
    
    let myObj = { foo: 3, bar: 7 };
    
    for (let [key, value] of iterEntries(myObj)) {
      console.log(key, value);
    }
    
    // foo 3
    // bar 7
    

    上述代码中,myObj是一个普通对象,通过iterEntries函数,就有了 Iterator 接口。也就是说,可以在任意对象上部署next方法。

    下面是一个对数组部署 Iterator 接口的例子,尽管数组原生具有这个接口。

    function* makeSimpleGenerator(array){
      var nextIndex = 0;
    
      while(nextIndex < array.length){
        yield array[nextIndex++];
      }
    }
    
    var gen = makeSimpleGenerator(['yo', 'ya']);
    
    gen.next().value // 'yo'
    gen.next().value // 'ya'
    gen.next().done  // true
    

    (4)作为数据结构

    Generator 可以看作是数据结构,更确切地说,可以看作是一个数组结构,因为 Generator 函数可以返回一系列的值,这意味着它可以对任意表达式,提供类似数组的接口。

    function* doStuff() {
      yield fs.readFile.bind(null, 'hello.txt');
      yield fs.readFile.bind(null, 'world.txt');
      yield fs.readFile.bind(null, 'and-such.txt');
    }
    

    上面代码就是依次返回三个函数,但是由于使用了 Generator 函数,导致可以像处理数组那样,处理这三个返回的函数。

    for (task of doStuff()) {
      // task是一个函数,可以像回调函数那样使用它
    }
    

    实际上,如果用 ES5 表达,完全可以用数组模拟 Generator 的这种用法。

    function doStuff() {
      return [
        fs.readFile.bind(null, 'hello.txt'),
        fs.readFile.bind(null, 'world.txt'),
        fs.readFile.bind(null, 'and-such.txt')
      ];
    }
    

    上面的函数,可以用一模一样的for...of循环处理!两相一比较,就不难看出 Generator 使得数据或者操作,具备了类似数组的接口。

    16 Generator 函数的异步应用 <a id = "Generator 函数的异步应用"></a>

    • 异步编程对 JavaScript 语言太重要。Javascript 语言的执行环境是“单线程”的,如果没有异步编程,根本没法用,非卡死不可。

    16.1 传统方法

    • ES6 诞生以前,异步编程的方法,大概有下面四种。

      - 回调函数

      - 事件监听

      - 发布/订阅

      - Promise 对象

    Generator 函数将 JavaScript 异步编程带入了一个全新的阶段。

    16.2 基本概念

    异步

    • 所谓"异步",简单说就是一个任务不是连续完成的,可以理解成该任务被人为分成两段,先执行第一段,然后转而执行其他任务,等做好了准备,再回过头执行第二段。

    • 相应地,连续的执行就叫做同步。

    回调函数

    • JavaScript 语言对异步编程的实现,就是回调函数。所谓回调函数,就是把任务的第二段单独写在一个函数里面,等到重新执行这个任务的时候,就直接调用这个函数。回调函数的英语名字callback,直译过来就是"重新调用"。

    读取文件进行处理,是这样写的。

    fs.readFile('/etc/passwd', 'utf-8', function (err, data) {
      if (err) throw err;
      console.log(data);
    });
    

    Promise

    • 回调函数本身并没有问题,它的问题出现在多个回调函数嵌套。代码不是纵向发展,而是横向发展,很快就会乱成一团,无法管理。因为多个异步操作形成了强耦合,只要有一个操作需要修改,它的上层回调函数和下层回调函数,可能都要跟着修改。这种情况称为“回调函数地狱”(callback hell)。

    • Promise 对象就是为了解决这个问题而提出的。它不是新的语法功能,而是一种新的写法,允许将回调函数的嵌套改成链式调用。

    • Promise 的最大问题是代码冗余,原来的任务被 Promise 包装了一下,不管什么操作,一眼看去都是一堆 then ,原来的语义变得很不清楚。

    16.3 Generator 函数

    协程

    • 传统的编程语言,早有异步编程的解决方案(其实是多任务的解决方案)。其中有一种叫做"协程"(coroutine),意思是多个线程互相协作,完成异步任务。

    协程有点像函数,又有点像线程。它的运行流程大致如下。

      - 第一步,协程A开始执行。

      - 第二步,协程A执行到一半,进入暂停,执行权转移到协程B。

      - 第三步,(一段时间后)协程B交还执行权。

      - 第四步,协程A恢复执行。

    上面流程的协程A,就是异步任务,因为它分成两段(或多段)执行。

    举例来说,读取文件的协程写法如下。

    function* asyncJob() {
      // ...其他代码
      var f = yield readFile(fileA);
      // ...其他代码
    }
    

    上面代码的函数asyncJob是一个协程,它的奥妙就在其中的yield命令。它表示执行到此处,执行权将交给其他协程。也就是说,yield命令是异步两个阶段的分界线。

    协程遇到yield命令就暂停,等到执行权返回,再从暂停的地方继续往后执行。它的最大优点,就是代码的写法非常像同步操作,如果去除yield命令,简直一模一样。

    协程的 Generator 函数实现

    • Generator 函数是协程在 ES6 的实现,最大特点就是可以交出函数的执行权(即暂停执行)。

    Generator 函数的数据交换和错误处理

    • Generator 函数可以暂停执行和恢复执行,这是它能封装异步任务的根本原因。除此之外,它还有两个特性,使它可以作为异步编程的完整解决方案:函数体内外的数据交换和错误处理机制。

    • next返回值的 value 属性,是 Generator 函数向外输出数据;next方法还可以接受参数,向 Generator 函数体内输入数据。

    • Generator 函数内部还可以部署错误处理代码,捕获函数体外抛出的错误。

    异步任务的封装

    http://es6.ruanyifeng.com/#docs/generator-async#异步任务的封装

    16.4 Thunk 函数

    • Thunk 函数是自动执行 Generator 函数的一种方法。

    参数的求值策略

    • 函参求职策略:

    一种意见是"传值调用"(call by value),即在进入函数体之前,就计算x + 5的值(等于 6),再将这个值传入函数f。C 语言就采用这种策略。

    f(x + 5)
    // 传值调用时,等同于
    f(6)
    

    另一种意见是“传名调用”(call by name),即直接将表达式x + 5传入函数体,只在用到它的时候求值。Haskell 语言采用这种策略。

    f(x + 5)
    // 传名调用时,等同于
    (x + 5) * 2
    

    Thunk 函数的含义

    • 编译器的“传名调用”实现,往往是将参数放到一个临时函数之中,再将这个临时函数传入函数体。这个临时函数就叫做 Thunk 函数。

    Javascript 语言的 Thunk 函数

    • JavaScript 语言是传值调用,它的 Thunk 函数含义有所不同。在 JavaScript 语言中,Thunk 函数替换的不是表达式,而是多参数函数,将其替换成一个只接受回调函数作为参数的单参数函数。
    // 正常版本的readFile(多参数版本)
    fs.readFile(fileName, callback);
    
    // Thunk版本的readFile(单参数版本)
    var Thunk = function (fileName) {
      return function (callback) {
        return fs.readFile(fileName, callback);
      };
    };
    
    var readFileThunk = Thunk(fileName);
    readFileThunk(callback);
    

    上面代码中,fs模块的readFile方法是一个多参数函数,两个参数分别为文件名和回调函数。经过转换器处理,它变成了一个单参数函数,只接受回调函数作为参数。这个单参数版本,就叫做 Thunk 函数。

    • 任何函数,只要参数有回调函数,就能写成 Thunk 函数的形式。下面是一个简单的 Thunk 函数转换器。
    // ES5版本
    var Thunk = function(fn){
      return function (){
        var args = Array.prototype.slice.call(arguments);
        return function (callback){
          args.push(callback);
          return fn.apply(this, args);
        }
      };
    };
    
    // ES6版本
    const Thunk = function(fn) {
      return function (...args) {
        return function (callback) {
          return fn.call(this, ...args, callback);
        }
      };
    };
    

    使用上面的转换器,生成fs.readFile的 Thunk 函数。

    var readFileThunk = Thunk(fs.readFile);
    readFileThunk(fileA)(callback);
    

    下面是另一个完整的例子。

    function f(a, cb) {
      cb(a);
    }
    const ft = Thunk(f);
    
    ft(1)(console.log) // 1
    

    Thunkify 模块

    • 生产环境的转换器,建议使用 Thunkify 模块。

    Generator 函数的流程管理

    Thunk 函数的自动流程管理

    15.5 co 模块

    基本用法

    • co 模块是著名程序员 TJ Holowaychuk 于 2013 年 6 月发布的一个小工具,用于 Generator 函数的自动执行。

    下面是一个 Generator 函数,用于依次读取两个文件。

    var gen = function* () {
      var f1 = yield readFile('/etc/fstab');
      var f2 = yield readFile('/etc/shells');
      console.log(f1.toString());
      console.log(f2.toString());
    };
    

    co 模块可以让你不用编写 Generator 函数的执行器。

    var co = require('co');
    co(gen);
    

    上面代码中,Generator 函数只要传入co函数,就会自动执行。

    co函数返回一个Promise对象,因此可以用then方法添加回调函数。

    co(gen).then(function (){
      console.log('Generator 函数执行完成');
    });
    

    上面代码中,等到 Generator 函数执行结束,就会输出一行提示。

    co 模块的原理

    基于 Promise 对象的自动执行

    co 模块的源码

    处理并发的异步操作

    实例:处理 Stream

    17 async 函数 <a id = "async 函数"></a>

    17.1 含义

    • ES2017 标准引入了 async 函数,使得异步操作变得更加方便。

    async 函数是什么?一句话,它就是 Generator 函数的语法糖。

    前文有一个 Generator 函数,依次读取两个文件。

    const fs = require('fs');
    
    const readFile = function (fileName) {
      return new Promise(function (resolve, reject) {
        fs.readFile(fileName, function(error, data) {
          if (error) return reject(error);
          resolve(data);
        });
      });
    };
    
    const gen = function* () {
      const f1 = yield readFile('/etc/fstab');
      const f2 = yield readFile('/etc/shells');
      console.log(f1.toString());
      console.log(f2.toString());
    };
    

    写成async函数,就是下面这样。

    const asyncReadFile = async function () {
      const f1 = await readFile('/etc/fstab');
      const f2 = await readFile('/etc/shells');
      console.log(f1.toString());
      console.log(f2.toString());
    };
    

    一比较就会发现,async函数就是将 Generator 函数的星号(*)替换成async,将yield替换成await,仅此而已。

    async函数对 Generator 函数的改进,体现在以下四点。

    (1)内置执行器。

    Generator 函数的执行必须靠执行器,所以才有了co模块,而async函数自带执行器。也就是说,async函数的执行,与普通函数一模一样,只要一行。

    asyncReadFile();
    上面的代码调用了asyncReadFile函数,然后它就会自动执行,输出最后结果。这完全不像 Generator 函数,需要调用next方法,或者用co模块,才能真正执行,得到最后结果。

    (2)更好的语义。

    async和await,比起星号和yield,语义更清楚了。async表示函数里有异步操作,await表示紧跟在后面的表达式需要等待结果。

    (3)更广的适用性。

    co模块约定,yield命令后面只能是 Thunk 函数或 Promise 对象,而async函数的await命令后面,可以是 Promise 对象和原始类型的值(数值、字符串和布尔值,但这时等同于同步操作)。

    (4)返回值是 Promise。

    async函数的返回值是 Promise 对象,这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。

    进一步说,async函数完全可以看作多个异步操作,包装成的一个 Promise 对象,而await命令就是内部then命令的语法糖。

    17.2 基本用法

    • async函数返回一个 Promise 对象,可以使用then方法添加回调函数。当函数执行的时候,一旦遇到await就会先返回,等到异步操作完成,再接着执行函数体内后面的语句。

    下面是一个例子。

    async function getStockPriceByName(name) {
      const symbol = await getStockSymbol(name);
      const stockPrice = await getStockPrice(symbol);
      return stockPrice;
    }
    
    getStockPriceByName('goog').then(function (result) {
      console.log(result);
    });
    

    上面代码是一个获取股票报价的函数,函数前面的async关键字,表明该函数内部有异步操作。调用该函数时,会立即返回一个Promise对象。

    下面是另一个例子,指定多少毫秒后输出一个值。

    function timeout(ms) {
      return new Promise((resolve) => {
        setTimeout(resolve, ms);
      });
    }
    
    async function asyncPrint(value, ms) {
      await timeout(ms);
      console.log(value);
    }
    
    asyncPrint('hello world', 50);
    

    上面代码指定 50 毫秒以后,输出hello world。

    由于async函数返回的是 Promise 对象,可以作为await命令的参数。所以,上面的例子也可以写成下面的形式。

    async function timeout(ms) {
      await new Promise((resolve) => {
        setTimeout(resolve, ms);
      });
    }
    
    async function asyncPrint(value, ms) {
      await timeout(ms);
      console.log(value);
    }
    
    asyncPrint('hello world', 50);
    
    • async 函数有多种使用形式。
    // 函数声明
    async function foo() {}
    
    // 函数表达式
    const foo = async function () {};
    
    // 对象的方法
    let obj = { async foo() {} };
    obj.foo().then(...)
    
    // Class 的方法
    class Storage {
      constructor() {
        this.cachePromise = caches.open('avatars');
      }
    
      async getAvatar(name) {
        const cache = await this.cachePromise;
        return cache.match(`/avatars/${name}.jpg`);
      }
    }
    
    const storage = new Storage();
    storage.getAvatar('jake').then(…);
    
    // 箭头函数
    const foo = async () => {};
    

    17.3 语法

    • async函数的语法规则总体上比较简单,难点是错误处理机制。

    返回 Promise 对象

    • async函数返回一个 Promise 对象。

    • async函数内部return语句返回的值,会成为then方法回调函数的参数。

    async function f() {
      return 'hello world';
    }
    
    f().then(v => console.log(v))
    // "hello world"
    

    上面代码中,函数f内部return命令返回的值,会被then方法回调函数接收到。

    • async函数内部抛出错误,会导致返回的 Promise 对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。
    async function f() {
      throw new Error('出错了');
    }
    
    f().then(
      v => console.log(v),
      e => console.log(e)
    )
    // Error: 出错了
    

    Promise 对象的状态变化

    • async函数返回的 Promise 对象,必须等到内部所有await命令后面的 Promise 对象执行完,才会发生状态改变,除非遇到return语句或者抛出错误。也就是说,只有async函数内部的异步操作执行完,才会执行then方法指定的回调函数。

    await 命令

    • 正常情况下,await命令后面是一个 Promise 对象。如果不是,会被转成一个立即resolve的 Promise 对象。

    • await命令后面的 Promise 对象如果变为reject状态,则reject的参数会被catch方法的回调函数接收到。

    错误处理

    • 如果await后面的异步操作出错,那么等同于async函数返回的 Promise 对象被reject。
    async function f() {
      await new Promise(function (resolve, reject) {
        throw new Error('出错了');
      });
    }
    
    f()
    .then(v => console.log(v))
    .catch(e => console.log(e))
    // Error:出错了
    

    上面代码中,async函数f执行后,await后面的 Promise 对象会抛出一个错误对象,导致catch方法的回调函数被调用,它的参数就是抛出的错误对象。具体的执行机制,可以参考后文的“async 函数的实现原理”。

    • 防止出错的方法,也是将其放在try...catch代码块之中。
    async function f() {
      try {
        await new Promise(function (resolve, reject) {
          throw new Error('出错了');
        });
      } catch(e) {
      }
      return await('hello world');
    }
    
    • 如果有多个await命令,可以统一放在try...catch结构中。
    async function main() {
      try {
        const val1 = await firstStep();
        const val2 = await secondStep(val1);
        const val3 = await thirdStep(val1, val2);
    
        console.log('Final: ', val3);
      }
      catch (err) {
        console.error(err);
      }
    }
    

    使用注意点

    • 第一点,前面已经说过,await命令后面的Promise对象,运行结果可能是rejected,所以最好把await命令放在try...catch代码块中。

    • 第二点,多个await命令后面的异步操作,如果不存在继发关系,最好让它们同时触发。

    • 第三点,await命令只能用在async函数之中,如果用在普通函数,就会报错。

    17.4 async 函数的实现原理

    • async 函数的实现原理,就是将 Generator 函数和自动执行器,包装在一个函数里。

    17.5 与其他异步处理方法的比较

    17.6 实例:按顺序完成异步操作

    • 实际开发中,经常遇到一组异步操作,需要按照顺序完成。比如,依次远程读取一组 URL,然后按照读取的顺序输出结果。
    async function logInOrder(urls) {
      // 并发读取远程URL
      const textPromises = urls.map(async url => {
        const response = await fetch(url);
        return response.text();
      });
    
      // 按次序输出
      for (const textPromise of textPromises) {
        console.log(await textPromise);
      }
    }
    

    上面代码中,虽然map方法的参数是async函数,但它是并发执行的,因为只有async函数内部是继发执行,外部不受影响。后面的for..of循环内部使用了await,因此实现了按顺序输出。

    17.7 异步遍历器

    • ES2018 引入了”异步遍历器“(Async Iterator),为异步操作提供原生的遍历器接口,即value和done这两个属性都是异步产生。

    异步遍历的接口

    • 异步遍历器的最大的语法特点,就是调用遍历器的next方法,返回的是一个 Promise 对象。
    asyncIterator
      .next()
      .then(
        ({ value, done }) => /* ... */
      );
    

    上面代码中,asyncIterator是一个异步遍历器,调用next方法以后,返回一个 Promise 对象。因此,可以使用then方法指定,这个 Promise 对象的状态变为resolve以后的回调函数。回调函数的参数,则是一个具有value和done两个属性的对象,这个跟同步遍历器是一样的。

    • 我们知道,一个对象的同步遍历器的接口,部署在Symbol.iterator属性上面。同样地,对象的异步遍历器接口,部署在Symbol.asyncIterator属性上面。不管是什么样的对象,只要它的Symbol.asyncIterator属性有值,就表示应该对它进行异步遍历。

    for await……of

    • 前面介绍过,for...of循环用于遍历同步的 Iterator 接口。新引入的for await...of循环,则是用于遍历异步的 Iterator 接口。
    async function f() {
      for await (const x of createAsyncIterable(['a', 'b'])) {
        console.log(x);
      }
    }
    // a
    // b
    

    上面代码中,createAsyncIterable()返回一个拥有异步遍历器接口的对象,for...of循环自动调用这个对象的异步遍历器的next方法,会得到一个 Promise 对象。await用来处理这个 Promise 对象,一旦resolve,就把得到的值(x)传入for...of的循环体。

    • 如果next方法返回的 Promise 对象被reject,for await...of就会报错,要用try...catch捕捉。
    async function () {
      try {
        for await (const x of createRejectingIterable()) {
          console.log(x);
        }
      } catch (e) {
        console.error(e);
      }
    }
    

    异步 Generator 函数

    • 就像 Generator 函数返回一个同步遍历器对象一样,异步 Generator 函数的作用,是返回一个异步遍历器对象。

    • 在语法上,异步 Generator 函数就是async函数与 Generator 函数的结合。

    async function* gen() {
      yield 'hello';
    }
    const genObj = gen();
    genObj.next().then(x => console.log(x));
    // { value: 'hello', done: false }
    

    上面代码中,gen是一个异步 Generator 函数,执行后返回一个异步 Iterator 对象。对该对象调用next方法,返回一个 Promise 对象。

    • 异步遍历器的设计目的之一,就是 Generator 函数处理同步操作和异步操作时,能够使用同一套接口。

    • 异步 Generator 函数内部,能够同时使用await和yield命令。可以这样理解,await命令用于将外部操作产生的值输入函数内部,yield命令用于将函数内部的值输出。

    • 注意,普通的 async 函数返回的是一个 Promise 对象,而异步 Generator 函数返回的是一个异步 Iterator 对象。可以这样理解,async 函数和异步 Generator 函数,是封装异步操作的两种方法,都用来达到同一种目的。区别在于,前者自带执行器,后者通过 for await...of 执行,或者自己编写执行器。

    • 异步 Generator 函数出现以后,JavaScript 就有了四种函数形式:普通函数、async 函数、Generator 函数和异步 Generator 函数。请注意区分每种函数的不同之处。基本上,如果是一系列按照顺序执行的异步操作(比如读取文件,然后写入新内容,再存入硬盘),可以使用 async 函数;如果是一系列产生相同数据结构的异步操作(比如一行一行读取文件),可以使用异步 Generator 函数。

    • 异步 Generator 函数也可以通过next方法的参数,接收外部传入的数据。

    const writer = openFile('someFile.txt');
    writer.next('hello'); // 立即执行
    writer.next('world'); // 立即执行
    await writer.return(); // 等待写入结束
    

    上面代码中,openFile是一个异步 Generator 函数。next方法的参数,向该函数内部的操作传入数据。每次next方法都是同步执行的,最后的await命令用于等待整个写入操作结束。

    yield* 语句

    • yield*语句也可以跟一个异步遍历器。
    async function* gen1() {
      yield 'a';
      yield 'b';
      return 2;
    }
    
    async function* gen2() {
      // result 最终会等于 2
      const result = yield* gen1();
    }
    

    上面代码中,gen2函数里面的result变量,最后的值是2。

    与同步 Generator 函数一样,for await...of循环会展开yield*。

    (async function () {
      for await (const x of gen2()) {
        console.log(x);
      }
    })();
    // a
    // b
    

    18 Class 的基本语法 <a id = "Class 的基本语法"></a>

    18.1 简介

    • JavaScript 语言中,生成实例对象的传统方法是通过构造函数。下面是一个例子。
    function Point(x, y) {
      this.x = x;
      this.y = y;
    }
    
    Point.prototype.toString = function () {
      return '(' + this.x + ', ' + this.y + ')';
    };
    
    var p = new Point(1, 2);
    
    • ES6 提供了更接近传统语言的写法,引入了 Class(类)这个概念,作为对象的模板。通过class关键字,可以定义类。

    基本上,ES6 的class可以看作只是一个语法糖,它的绝大部分功能,ES5 都可以做到,新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的代码用 ES6 的class改写,就是下面这样。

    //定义类
    class Point {
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
    
      toString() {
        return '(' + this.x + ', ' + this.y + ')';
      }
    }
    
    • 注意,定义“类”的方法的时候,前面不需要加上function这个关键字,直接把函数定义放进去了就可以了。另外,方法之间不需要逗号分隔,加了会报错。

    • ES6 的类,完全可以看作构造函数的另一种写法。

    class Point {
      // ...
    }
    
    typeof Point // "function"
    Point === Point.prototype.constructor // true
    

    上面代码表明,类的数据类型就是函数,类本身就指向构造函数。

    • 使用的时候,也是直接对类使用new命令,跟构造函数的用法完全一致。

    • 构造函数的prototype属性,在 ES6 的“类”上面继续存在。事实上,类的所有方法都定义在类的prototype属性上面。

    • 由于类的方法都定义在prototype对象上面,所以类的新方法可以添加在prototype对象上面。Object.assign方法可以很方便地一次向类添加多个方法。

    • prototype对象的constructor属性,直接指向“类”的本身,这与 ES5 的行为是一致的。

    Point.prototype.constructor === Point // true
    
    • 另外,类的内部所有定义的方法,都是不可枚举的(non-enumerable)。

    • 类的属性名,可以采用表达式。

    let methodName = 'getArea';
    
    class Square {
      constructor(length) {
        // ...
      }
    
      [methodName]() {
        // ...
      }
    }
    

    上面代码中,Square类的方法名getArea,是从表达式得到的。

    18.2 严格模式

    • 类和模块的内部,默认就是严格模式,所以不需要使用use strict指定运行模式。只要你的代码写在类或模块之中,就只有严格模式可用。

    • 考虑到未来所有的代码,其实都是运行在模块之中,所以 ES6 实际上把整个语言升级到了严格模式。

    18.3 constructor 方法

    • constructor方法是类的默认方法,通过new命令生成对象实例时,自动调用该方法。一个类必须有constructor方法,如果没有显式定义,一个空的constructor方法会被默认添加。

    • constructor方法默认返回实例对象(即this),完全可以指定返回另外一个对象。

    • 类必须使用new调用,否则会报错。这是它跟普通构造函数的一个主要区别,后者不用new也可以执行。

    18.4 类的实例对象

    • 生成类的实例对象的写法,与 ES5 完全一样,也是使用new命令。前面说过,如果忘记加上new,像函数那样调用Class,将会报错。

    • 与 ES5 一样,实例的属性除非显式定义在其本身(即定义在this对象上),否则都是定义在原型上(即定义在class上)。

    • 与 ES5 一样,类的所有实例共享一个原型对象。这也意味着,可以通过实例的proto属性为“类”添加方法。

    <blockquote>
    proto 并不是语言本身的特性,这是各大厂商具体实现时添加的私有属性,虽然目前很多现代浏览器的 JS 引擎中都提供了这个私有属性,但依旧不建议在生产中使用该属性,避免对环境产生依赖。生产环境中,我们可以使用 Object.getPrototypeOf 方法来获取实例对象的原型,然后再来为原型添加方法/属性。
    </blockquote>

    18.5 Class 表达式

    • 与函数一样,类也可以使用表达式的形式定义。
    const MyClass = class Me {
      getClassName() {
        return Me.name;
      }
    };
    

    上面代码使用表达式定义了一个类。需要注意的是,这个类的名字是MyClass而不是Me,Me只在 Class 的内部代码可用,指代当前类。

    • 如果类的内部没用到的话,可以省略Me,也就是可以写成下面的形式。
    const MyClass = class { /* ... */ };
    
    • 采用 Class 表达式,可以写出立即执行的 Class。
    let person = new class {
      constructor(name) {
        this.name = name;
      }
    
      sayName() {
        console.log(this.name);
      }
    }('张三');
    
    person.sayName(); // "张三"
    

    上面代码中,person是一个立即执行的类的实例。

    18.6 不存在变量提升

    • 类不存在变量提升(hoist),这一点与 ES5 完全不同。
    new Foo(); // ReferenceError
    class Foo {}
    

    上面代码中,Foo类使用在前,定义在后,这样会报错,因为 ES6 不会把类的声明提升到代码头部。这种规定的原因与下文要提到的继承有关,必须保证子类在父类之后定义。

    {
      let Foo = class {};
      class Bar extends Foo {
      }
    }
    

    上面的代码不会报错,因为Bar继承Foo的时候,Foo已经有定义了。但是,如果存在class的提升,上面代码就会报错,因为class会被提升到代码头部,而let命令是不提升的,所以导致Bar继承Foo的时候,Foo还没有定义。

    18.7 私有方法和私有属性

    现有的方法

    • 私有方法是常见需求,但 ES6 不提供,只能通过变通方法模拟实现。

    • 一种做法是在命名上加以区别。

    class Widget {
    
      // 公有方法
      foo (baz) {
        this._bar(baz);
      }
    
      // 私有方法
      _bar(baz) {
        return this.snaf = baz;
      }
    
      // ...
    }
    

    上面代码中,_bar方法前面的下划线,表示这是一个只限于内部使用的私有方法。但是,这种命名是不保险的,在类的外部,还是可以调用到这个方法。

    • 另一种方法就是索性将私有方法移出模块,因为模块内部的所有方法都是对外可见的。
    class Widget {
      foo (baz) {
        bar.call(this, baz);
      }
    
      // ...
    }
    
    function bar(baz) {
      return this.snaf = baz;
    }
    

    上面代码中,foo是公有方法,内部调用了bar.call(this, baz)。这使得bar实际上成为了当前模块的私有方法。

    • 还有一种方法是利用Symbol值的唯一性,将私有方法的名字命名为一个Symbol值。
    const bar = Symbol('bar');
    const snaf = Symbol('snaf');
    
    export default class myClass{
    
      // 公有方法
      foo(baz) {
        this[bar](baz);
      }
    
      // 私有方法
      [bar](baz) {
        return this[snaf] = baz;
      }
    
      // ...
    };
    

    上面代码中,bar和snaf都是Symbol值,导致第三方无法获取到它们,因此达到了私有方法和私有属性的效果。

    私有属性的提案

    • 与私有方法一样,ES6 不支持私有属性。目前,有一个提案,为class加了私有属性。方法是在属性名之前,使用#表示。
    class Point {
      #x;
    
      constructor(x = 0) {
        #x = +x; // 写成 this.#x 亦可
      }
    
      get x() { return #x }
      set x(value) { #x = +value }
    }
    

    上面代码中,#x就是私有属性,在Point类之外是读取不到这个属性的。由于井号#是属性名的一部分,使用时必须带有#一起使用,所以#x和x是两个不同的属性。

    • 私有属性可以指定初始值,在构造函数执行时进行初始化。
    class Point {
      #x = 0;
      constructor() {
        #x; // 0
      }
    }
    

    之所以要引入一个新的前缀#表示私有属性,而没有采用private关键字,是因为 JavaScript 是一门动态语言,使用独立的符号似乎是唯一的可靠方法,能够准确地区分一种属性是否为私有属性。另外,Ruby 语言使用@表示私有属性,ES6 没有用这个符号而使用#,是因为@已经被留给了 Decorator。

    这种写法不仅可以写私有属性,还可以用来写私有方法。

    class Foo {
      #a;
      #b;
      #sum() { return #a + #b; }
      printSum() { console.log(#sum()); }
      constructor(a, b) { #a = a; #b = b; }
    }
    

    上面代码中,#sum()就是一个私有方法。

    • 另外,私有属性也可以设置 getter 和 setter 方法。
    class Counter {
      #xValue = 0;
    
      get #x() { return #xValue; }
      set #x(value) {
        this.#xValue = value;
      }
    
      constructor() {
        super();
        // ...
      }
    }
    

    上面代码中,#x是一个私有属性,它的读写都通过get #x()和set #x()来完成。

    18.8 this 的指向

    • 类的方法内部如果含有this,它默认指向类的实例。但是,必须非常小心,一旦单独使用该方法,很可能报错。

    http://es6.ruanyifeng.com/#docs/class#this-的指向

    18.9 name 属性

    • 由于本质上,ES6 的类只是 ES5 的构造函数的一层包装,所以函数的许多特性都被Class继承,包括name属性。
    class Point {}
    Point.name // "Point"
    
    • name属性总是返回紧跟在class关键字后面的类名。

    18.10 Class 的取值函数(getter)和存值函数(setter)

    • 与 ES5 一样,在“类”的内部可以使用get和set关键字,对某个属性设置存值函数和取值函数,拦截该属性的存取行为。
    class MyClass {
      constructor() {
        // ...
      }
      get prop() {
        return 'getter';
      }
      set prop(value) {
        console.log('setter: '+value);
      }
    }
    
    let inst = new MyClass();
    
    inst.prop = 123;
    // setter: 123
    
    inst.prop
    // 'getter'
    

    上面代码中,prop属性有对应的存值函数和取值函数,因此赋值和读取行为都被自定义了。

    • 存值函数和取值函数是设置在属性的 Descriptor 对象上的。

    18.11 Class 的 Generator 方法

    • 如果某个方法之前加上星号(*),就表示该方法是一个 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
    

    上面代码中,Foo类的Symbol.iterator方法前有一个星号,表示该方法是一个 Generator 函数。Symbol.iterator方法返回一个Foo类的默认遍历器,for...of循环会自动调用这个遍历器。

    18.12 Class 的静态方法

    • 类相当于实例的原型,所有在类中定义的方法,都会被实例继承。如果在一个方法前,加上static关键字,就表示该方法不会被实例继承,而是直接通过类来调用,这就称为“静态方法”。

    • 注意,如果静态方法包含this关键字,这个this指的是类,而不是实例。

    • 静态方法可以与非静态方法重名。

    • 父类的静态方法,可以被子类继承。

    • 静态方法也是可以从super对象上调用的。

    18.13 Class 的静态属性和实例属性

    • 静态属性指的是 Class 本身的属性,即Class.propName,而不是定义在实例对象(this)上的属性。
    class Foo {
    }
    
    Foo.prop = 1;
    Foo.prop // 1
    

    上面的写法为Foo类定义了一个静态属性prop。

    目前,只有这种写法可行,因为 ES6 明确规定,Class 内部只有静态方法,没有静态属性。

    (1)类的实例属性

    • 类的实例属性可以用等式,写入类的定义之中。
    class MyClass {
      myProp = 42;
    
      constructor() {
        console.log(this.myProp); // 42
      }
    }
    

    上面代码中,myProp就是MyClass的实例属性。在MyClass的实例上,可以读取这个属性。

    以前,我们定义实例属性,只能写在类的constructor方法里面。

    class ReactCounter extends React.Component {
      constructor(props) {
        super(props);
        this.state = {
          count: 0
        };
      }
    }
    

    上面代码中,构造方法constructor里面,定义了this.state属性。

    (2)类的静态属性

    • 类的静态属性只要在上面的实例属性写法前面,加上static关键字就可以了。
    class MyClass {
      static myStaticProp = 42;
    
      constructor() {
        console.log(MyClass.myStaticProp); // 42
      }
    }
    

    同样的,这个新写法大大方便了静态属性的表达。

    // 老写法
    class Foo {
      // ...
    }
    Foo.prop = 1;
    
    // 新写法
    class Foo {
      static prop = 1;
    }
    

    上面代码中,老写法的静态属性定义在类的外部。整个类生成以后,再生成静态属性。这样让人很容易忽略这个静态属性,也不符合相关代码应该放在一起的代码组织原则。另外,新写法是显式声明(declarative),而不是赋值处理,语义更好。

    18.14 new.target 属性

    • new是从构造函数生成实例对象的命令。ES6 为new命令引入了一个new.target属性,该属性一般用在构造函数之中,返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的,new.target会返回undefined,因此这个属性可以用来确定构造函数是怎么调用的。
    function Person(name) {
      if (new.target !== undefined) {
        this.name = name;
      } else {
        throw new Error('必须使用 new 命令生成实例');
      }
    }
    
    // 另一种写法
    function Person(name) {
      if (new.target === Person) {
        this.name = name;
      } else {
        throw new Error('必须使用 new 命令生成实例');
      }
    }
    
    var person = new Person('张三'); // 正确
    var notAPerson = Person.call(person, '张三');  // 报错
    

    上面代码确保构造函数只能通过new命令调用。

    Class 内部调用new.target,返回当前 Class。

    class Rectangle {
      constructor(length, width) {
        console.log(new.target === Rectangle);
        this.length = length;
        this.width = width;
      }
    }
    
    var obj = new Rectangle(3, 4); // 输出 true
    

    需要注意的是,子类继承父类时,new.target会返回子类。

    class Rectangle {
      constructor(length, width) {
        console.log(new.target === Rectangle);
        // ...
      }
    }
    
    class Square extends Rectangle {
      constructor(length) {
        super(length, length);
      }
    }
    
    var obj = new Square(3); // 输出 false
    

    上面代码中,new.target会返回子类。

    利用这个特点,可以写出不能独立使用、必须继承后才能使用的类。

    class Shape {
      constructor() {
        if (new.target === Shape) {
          throw new Error('本类不能实例化');
        }
      }
    }
    
    class Rectangle extends Shape {
      constructor(length, width) {
        super();
        // ...
      }
    }
    
    var x = new Shape();  // 报错
    var y = new Rectangle(3, 4);  // 正确
    

    上面代码中,Shape类不能被实例化,只能用于继承。

    注意,在函数外部,使用new.target会报错。

    19 Class 的继承 <a id = "Class 的继承"></a>

    19.1 简介

    • Class 可以通过extends关键字实现继承,这比 ES5 的通过修改原型链实现继承,要清晰和方便很多。
    class ColorPoint extends Point {
      constructor(x, y, color) {
        super(x, y); // 调用父类的constructor(x, y)
        this.color = color;
      }
    
      toString() {
        return this.color + ' ' + super.toString(); // 调用父类的toString()
      }
    }
    

    上面代码中,constructor方法和toString方法之中,都出现了super关键字,它在这里表示父类的构造函数,用来新建父类的this对象。

    子类必须在constructor方法中调用super方法,否则新建实例时会报错。这是因为子类自己的this对象,必须先通过父类的构造函数完成塑造,得到与父类同样的实例属性和方法,然后再对其进行加工,加上子类自己的实例属性和方法。如果不调用super方法,子类就得不到this对象。

    • 如果子类没有定义constructor方法,这个方法会被默认添加,代码如下。也就是说,不管有没有显式定义,任何一个子类都有constructor方法。
    class ColorPoint extends Point {
    }
    
    // 等同于
    class ColorPoint extends Point {
      constructor(...args) {
        super(...args);
      }
    }
    
    • 另一个需要注意的地方是,在子类的构造函数中,只有调用super之后,才可以使用this关键字,否则会报错。这是因为子类实例的构建,是基于对父类实例加工,只有super方法才能返回父类实例。

    下面是生成子类实例的代码。

    let cp = new ColorPoint(25, 8, 'green');
    
    cp instanceof ColorPoint // true
    cp instanceof Point // true
    

    上面代码中,实例对象cp同时是ColorPoint和Point两个类的实例,这与 ES5 的行为完全一致。

    • 最后,父类的静态方法,也会被子类继承。
    class A {
      static hello() {
        console.log('hello world');
      }
    }
    
    class B extends A {
    }
    
    B.hello()  // hello world
    

    上面代码中,hello()是A类的静态方法,B继承A,也继承了A的静态方法。

    19.2 Object.getPrototypeOf()

    • Object.getPrototypeOf 方法可以用来从子类上获取父类。
    Object.getPrototypeOf(ColorPoint) === Point
    // true
    

    因此,可以使用这个方法判断,一个类是否继承了另一个类。

    19.3 super 关键字

    • super这个关键字,既可以当作函数使用,也可以当作对象使用。在这两种情况下,它的用法完全不同。

    • 第一种情况,super作为函数调用时,代表父类的构造函数。ES6 要求,子类的构造函数必须执行一次super函数。作为函数时,super()只能用在子类的构造函数之中,用在其他地方就会报错。

    • 第二种情况,super作为对象时,在普通方法中,指向父类的原型对象;在静态方法中,指向父类。

    class A {
      p() {
        return 2;
      }
    }
    
    class B extends A {
      constructor() {
        super();
        console.log(super.p()); // 2
      }
    }
    
    let b = new B();
    

    上面代码中,子类B当中的super.p(),就是将super当作一个对象使用。这时,super在普通方法之中,指向A.prototype,所以super.p()就相当于A.prototype.p()。

    • 这里需要注意,由于super指向父类的原型对象,所以定义在父类实例上的方法或属性,是无法通过super调用的。
    class A {
      constructor() {
        this.p = 2;
      }
    }
    
    class B extends A {
      get m() {
        return super.p;
      }
    }
    
    let b = new B();
    b.m // undefined
    

    上面代码中,p是父类A实例的属性,super.p就引用不到它。

    • ES6 规定,在子类普通方法中通过super调用父类的方法时,方法内部的this指向当前的子类实例。
    class A {
      constructor() {
        this.x = 1;
      }
      print() {
        console.log(this.x);
      }
    }
    
    class B extends A {
      constructor() {
        super();
        this.x = 2;
      }
      m() {
        super.print();
      }
    }
    
    let b = new B();
    b.m() // 2
    

    上面代码中,super.print()虽然调用的是A.prototype.print(),但是A.prototype.print()内部的this指向子类B的实例,导致输出的是2,而不是1。也就是说,实际上执行的是super.print.call(this)。

    • 由于this指向子类实例,所以如果通过super对某个属性赋值,这时super就是this,赋值的属性会变成子类实例的属性。
    class A {
      constructor() {
        this.x = 1;
      }
    }
    
    class B extends A {
      constructor() {
        super();
        this.x = 2;
        super.x = 3;
        console.log(super.x); // undefined
        console.log(this.x); // 3
      }
    }
    
    let b = new B();
    

    上面代码中,super.x赋值为3,这时等同于对this.x赋值为3。而当读取super.x的时候,读的是A.prototype.x,所以返回undefined。

    • 如果super作为对象,用在静态方法之中,这时super将指向父类,而不是父类的原型对象。
    class Parent {
      static myMethod(msg) {
        console.log('static', msg);
      }
    
      myMethod(msg) {
        console.log('instance', msg);
      }
    }
    
    class Child extends Parent {
      static myMethod(msg) {
        super.myMethod(msg);
      }
    
      myMethod(msg) {
        super.myMethod(msg);
      }
    }
    
    Child.myMethod(1); // static 1
    
    var child = new Child();
    child.myMethod(2); // instance 2
    

    上面代码中,super在静态方法之中指向父类,在普通方法之中指向父类的原型对象。

    • 另外,在子类的静态方法中通过super调用父类的方法时,方法内部的this指向当前的子类,而不是子类的实例。
    class A {
      constructor() {
        this.x = 1;
      }
      static print() {
        console.log(this.x);
      }
    }
    
    class B extends A {
      constructor() {
        super();
        this.x = 2;
      }
      static m() {
        super.print();
      }
    }
    
    B.x = 3;
    B.m() // 3
    

    上面代码中,静态方法B.m里面,super.print指向父类的静态方法。这个方法里面的this指向的是B,而不是B的实例。

    • 最后,由于对象总是继承其他对象的,所以可以在任意一个对象中,使用super关键字。
    var obj = {
      toString() {
        return "MyObject: " + super.toString();
      }
    };
    
    obj.toString(); // MyObject: [object Object]
    

    19.4 类的 prototype 属性和 proto 属性

    • 大多数浏览器的 ES5 实现之中,每一个对象都有proto属性,指向对应的构造函数的prototype属性。Class 作为构造函数的语法糖,同时有prototype属性和proto属性,因此同时存在两条继承链。

    (1)子类的proto属性,表示构造函数的继承,总是指向父类。

    (2)子类prototype属性的proto属性,表示方法的继承,总是指向父类的prototype属性。

    extends 的继承目标

    • extends关键字后面可以跟多种类型的值。
    class B extends A {
    }
    

    上面代码的A,只要是一个有prototype属性的函数,就能被B继承。由于函数都有prototype属性(除了Function.prototype函数),因此A可以是任意函数。

    下面,讨论三种特殊情况。

    • 第一种特殊情况,子类继承Object类。
    class A extends Object {
    }
    
    A.__proto__ === Object // true
    A.prototype.__proto__ === Object.prototype // true
    

    这种情况下,A其实就是构造函数Object的复制,A的实例就是Object的实例。

    • 第二种特殊情况,不存在任何继承。
    class A {
    }
    
    A.__proto__ === Function.prototype // true
    A.prototype.__proto__ === Object.prototype // true
    

    这种情况下,A作为一个基类(即不存在任何继承),就是一个普通函数,所以直接继承Function.prototype。但是,A调用后返回一个空对象(即Object实例),所以A.prototype.proto指向构造函数(Object)的prototype属性。

    • 第三种特殊情况,子类继承null。
    class A extends null {
    }
    
    A.__proto__ === Function.prototype // true
    A.prototype.__proto__ === undefined // true
    

    这种情况与第二种情况非常像。A也是一个普通函数,所以直接继承Function.prototype。但是,A调用后返回的对象不继承任何方法,所以它的proto指向undefined,即实质上执行了下面的代码。

    class C extends null {
      constructor() { return Object.create(null); }
    }
    

    实例的 proto 属性

    • 子类实例的proto属性的proto属性,指向父类实例的proto属性。也就是说,子类的原型的原型,是父类的原型。
    var p1 = new Point(2, 3);
    var p2 = new ColorPoint(2, 3, 'red');
    
    p2.__proto__ === p1.__proto__ // false
    p2.__proto__.__proto__ === p1.__proto__ // true
    

    上面代码中,ColorPoint继承了Point,导致前者原型的原型是后者的原型。

    因此,通过子类实例的proto.proto属性,可以修改父类实例的行为。

    p2.__proto__.__proto__.printName = function () {
      console.log('Ha');
    };
    
    p1.printName() // "Ha"
    

    上面代码在ColorPoint的实例p2上向Point类添加方法,结果影响到了Point的实例p1。

    19.5 原生构造函数的继承

    • extends关键字不仅可以用来继承类,还可以用来继承原生的构造函数。因此可以在原生数据结构的基础上,定义自己的数据结构。下面就是定义了一个带版本功能的数组。
    class VersionedArray extends Array {
      constructor() {
        super();
        this.history = [[]];
      }
      commit() {
        this.history.push(this.slice());
      }
      revert() {
        this.splice(0, this.length, ...this.history[this.history.length - 1]);
      }
    }
    
    var x = new VersionedArray();
    
    x.push(1);
    x.push(2);
    x // [1, 2]
    x.history // [[]]
    
    x.commit();
    x.history // [[], [1, 2]]
    
    x.push(3);
    x // [1, 2, 3]
    x.history // [[], [1, 2]]
    
    x.revert();
    x // [1, 2]
    

    上面代码中,VersionedArray会通过commit方法,将自己的当前状态生成一个版本快照,存入history属性。revert方法用来将数组重置为最新一次保存的版本。除此之外,VersionedArray依然是一个普通数组,所有原生的数组方法都可以在它上面调用。

    • 注意,继承Object的子类,有一个行为差异。
    class NewObj extends Object{
      constructor(){
        super(...arguments);
      }
    }
    var o = new NewObj({attr: true});
    o.attr === true  // false
    

    上面代码中,NewObj继承了Object,但是无法通过super方法向父类Object传参。这是因为 ES6 改变了Object构造函数的行为,一旦发现Object方法不是通过new Object()这种形式调用,ES6 规定Object构造函数会忽略参数。

    19.6 Mixin 模式的实现

    • Mixin 指的是多个对象合成一个新的对象,新对象具有各个组成成员的接口。它的最简单实现如下。
    const a = {
      a: 'a'
    };
    const b = {
      b: 'b'
    };
    const c = {...a, ...b}; // {a: 'a', b: 'b'}
    

    上面代码中,c对象是a对象和b对象的合成,具有两者的接口。

    下面是一个更完备的实现,将多个类的接口“混入”(mix in)另一个类。

    function mix(...mixins) {
      class Mix {}
    
      for (let mixin of mixins) {
        copyProperties(Mix.prototype, mixin); // 拷贝实例属性
        copyProperties(Mix.prototype, Object.getPrototypeOf(mixin)); // 拷贝原型属性
      }
    
      return Mix;
    }
    
    function copyProperties(target, source) {
      for (let key of Reflect.ownKeys(source)) {
        if ( key !== "constructor"
          && key !== "prototype"
          && key !== "name"
        ) {
          let desc = Object.getOwnPropertyDescriptor(source, key);
          Object.defineProperty(target, key, desc);
        }
      }
    }
    

    上面代码的mix函数,可以将多个对象合成为一个类。使用的时候,只要继承这个类即可。

    class DistributedEdit extends mix(Loggable, Serializable) {
      // ...
    }
    

    20 Decorator <a id = "Decorator"></a>

    20.1 类的修饰

    • 许多面向对象的语言都有修饰器(Decorator)函数,用来修改类的行为。目前,有一个提案将这项功能,引入了 ECMAScript。

    • 基本上,修饰器的行为就是下面这样。

    @decorator
    class A {}
    
    // 等同于
    
    class A {}
    A = decorator(A) || A;
    

    也就是说,修饰器是一个对类进行处理的函数。修饰器函数的第一个参数,就是所要修饰的目标类。

    function testable(target) {
      // ...
    }
    

    上面代码中,testable函数的参数target,就是会被修饰的类。

    • 如果觉得一个参数不够用,可以在修饰器外面再封装一层函数。
    function testable(isTestable) {
      return function(target) {
        target.isTestable = isTestable;
      }
    }
    
    @testable(true)
    class MyTestableClass {}
    MyTestableClass.isTestable // true
    
    @testable(false)
    class MyClass {}
    MyClass.isTestable // false
    

    上面代码中,修饰器testable可以接受参数,这就等于可以修改修饰器的行为。

    • 注意,修饰器对类的行为的改变,是代码编译时发生的,而不是在运行时。这意味着,修饰器能在编译阶段运行代码。也就是说,修饰器本质就是编译时执行的函数。

    20.2 方法的修饰

    • 修饰器不仅可以修饰类,还可以修饰类的属性。
    class Person {
      @readonly
      name() { return `${this.first} ${this.last}` }
    }
    

    上面代码中,修饰器readonly用来修饰“类”的name方法。

    修饰器函数readonly一共可以接受三个参数。

    function readonly(target, name, descriptor){
      // descriptor对象原来的值如下
      // {
      //   value: specifiedFunction,
      //   enumerable: false,
      //   configurable: true,
      //   writable: true
      // };
      descriptor.writable = false;
      return descriptor;
    }
    
    readonly(Person.prototype, 'name', descriptor);
    // 类似于
    Object.defineProperty(Person.prototype, 'name', descriptor);
    

    修饰器第一个参数是类的原型对象,上例是Person.prototype,修饰器的本意是要“修饰”类的实例,但是这个时候实例还没生成,所以只能去修饰原型(这不同于类的修饰,那种情况时target参数指的是类本身);第二个参数是所要修饰的属性名,第三个参数是该属性的描述对象。

    20.3 为什么修饰器不能用于函数?

    • 修饰器只能用于类和类的方法,不能用于函数,因为存在函数提升。类是不会提升的,所以就没有这方面的问题。

    • 另一方面,如果一定要修饰函数,可以采用高阶函数的形式直接执行。

    function doSomething(name) {
      console.log('Hello, ' + name);
    }
    
    function loggingDecorator(wrapped) {
      return function() {
        console.log('Starting');
        const result = wrapped.apply(this, arguments);
        console.log('Finished');
        return result;
      }
    }
    
    const wrapped = loggingDecorator(doSomething);
    

    20.4 core-decorators.js

    http://es6.ruanyifeng.com/#docs/decorator#core-decorators-js

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

    http://es6.ruanyifeng.com/#docs/decorator#使用修饰器实现自动发布事件

    20.6 Mixin

    • 在修饰器的基础上,可以实现Mixin模式。所谓Mixin模式,就是对象继承的一种替代方案,中文译为“混入”(mix in),意为在一个对象之中混入另外一个对象的方法。

    请看下面的例子。

    const Foo = {
      foo() { console.log('foo') }
    };
    
    class MyClass {}
    
    Object.assign(MyClass.prototype, Foo);
    
    let obj = new MyClass();
    obj.foo() // 'foo'
    

    上面代码之中,对象Foo有一个foo方法,通过Object.assign方法,可以将foo方法“混入”MyClass类,导致MyClass的实例obj对象都具有foo方法。这就是“混入”模式的一个简单实现。

    下面,我们部署一个通用脚本mixins.js,将 Mixin 写成一个修饰器。

    export function mixins(...list) {
      return function (target) {
        Object.assign(target.prototype, ...list);
      };
    }
    

    然后,就可以使用上面这个修饰器,为类“混入”各种方法。

    import { mixins } from './mixins';
    
    const Foo = {
      foo() { console.log('foo') }
    };
    
    @mixins(Foo)
    class MyClass {}
    
    let obj = new MyClass();
    obj.foo() // "foo"
    

    通过mixins这个修饰器,实现了在MyClass类上面“混入”Foo对象的foo方法。

    20.7 Trait

    • Trait 也是一种修饰器,效果与 Mixin 类似,但是提供更多功能,比如防止同名方法的冲突、排除混入某些方法、为混入的方法起别名等等。

    20.8 Babel 转码器的支持

    • 目前,Babel 转码器已经支持 Decorator。

    首先,安装babel-core和babel-plugin-transform-decorators。由于后者包括在babel-preset-stage-0之中,所以改为安装babel-preset-stage-0亦可。

    $ npm install babel-core babel-plugin-transform-decorators
    

    然后,设置配置文件.babelrc。

    {
      "plugins": ["transform-decorators"]
    }
    

    这时,Babel 就可以对 Decorator 转码了。

    脚本中打开的命令如下。

    babel.transform("code", {plugins: ["transform-decorators"]})
    

    Babel 的官方网站提供一个在线转码器,只要勾选 Experimental,就能支持 Decorator 的在线转码。

    21 Module 的语法 <a id = "Module 的语法"></a>

    21.1 概述

    • ES6 模块的设计思想是尽量的静态化,使得编译时就能确定模块的依赖关系,以及输入和输出的变量。

    • 由于 ES6 模块是编译时加载,使得静态分析成为可能。有了它,就能进一步拓宽 JavaScript 的语法,比如引入宏(macro)和类型检验(type system)这些只能靠静态分析实现的功能。

    除了静态加载带来的各种好处,ES6 模块还有以下好处。

      - 不再需要UMD模块格式了,将来服务器和浏览器都会支持 ES6 模块格式。目前,通过各种工具库,其实已经做到了这一点。

      - 将来浏览器的新 API 就能用模块格式提供,不再必须做成全局变量或者navigator对象的属性。

      - 不再需要对象作为命名空间(比如Math对象),未来这些功能可以通过模块提供。

    21.2 严格模式

    • ES6 的模块自动采用严格模式,不管你有没有在模块头部加上"use strict";。

    严格模式主要有以下限制。

      - 变量必须声明后再使用

      - 函数的参数不能有同名属性,否则报错

      - 不能使用with语句

      - 不能对只读属性赋值,否则报错

      - 不能使用前缀 0 表示八进制数,否则报错

      - 不能删除不可删除的属性,否则报错

      - 不能删除变量delete prop,会报错,只能删除属性delete global[prop]

      - eval不会在它的外层作用域引入变量

      - eval和arguments不能被重新赋值

      - arguments不会自动反映函数参数的变化

      - 不能使用arguments.callee

      - 不能使用arguments.caller

      - 禁止this指向全局对象

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

      - 增加了保留字(比如protected、static和interface)

    • 其中,尤其需要注意this的限制。ES6 模块之中,顶层的this指向undefined,即不应该在顶层代码使用this。

    21.3 export 命令

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

    • 一个模块就是一个独立的文件。该文件内部的所有变量,外部无法获取。如果你希望外部能够读取模块内部的某个变量,就必须使用export关键字输出该变量。下面是一个 JS 文件,里面使用export命令输出变量。

    // profile.js
    export var firstName = 'Michael';
    export var lastName = 'Jackson';
    export var year = 1958;
    

    上面代码是profile.js文件,保存了用户信息。ES6 将其视为一个模块,里面用export命令对外部输出了三个变量。

    export的写法,除了像上面这样,还有另外一种。

    // profile.js
    var firstName = 'Michael';
    var lastName = 'Jackson';
    var year = 1958;
    
    export {firstName, lastName, year};
    

    上面代码在export命令后面,使用大括号指定所要输出的一组变量。它与前一种写法(直接放置在var语句前)是等价的,但是应该优先考虑使用这种写法。因为这样就可以在脚本尾部,一眼看清楚输出了哪些变量。

    • export命令除了输出变量,还可以输出函数或类(class)。

    • 通常情况下,export输出的变量就是本来的名字,但是可以使用as关键字重命名。

    function v1() { ... }
    function v2() { ... }
    
    export {
      v1 as streamV1,
      v2 as streamV2,
      v2 as streamLatestVersion
    };
    

    上面代码使用as关键字,重命名了函数v1和v2的对外接口。重命名后,v2可以用不同的名字输出两次。

    • 另外,export语句输出的接口,与其对应的值是动态绑定关系,即通过该接口,可以取到模块内部实时的值。
    export var foo = 'bar';
    setTimeout(() => foo = 'baz', 500);
    

    上面代码输出变量foo,值为bar,500 毫秒之后变成baz。

    • 最后,export命令可以出现在模块的任何位置,只要处于模块顶层就可以。如果处于块级作用域内,就会报错,下一节的import命令也是如此。这是因为处于条件代码块之中,就没法做静态优化了,违背了 ES6 模块的设计初衷。

    21.4 import 命令

    • 使用export命令定义了模块的对外接口以后,其他 JS 文件就可以通过import命令加载这个模块。
    // main.js
    import {firstName, lastName, year} from './profile.js';
    
    function setName(element) {
      element.textContent = firstName + ' ' + lastName;
    }
    

    上面代码的import命令,用于加载profile.js文件,并从中输入变量。import命令接受一对大括号,里面指定要从其他模块导入的变量名。大括号里面的变量名,必须与被导入模块(profile.js)对外接口的名称相同。

    • 如果想为输入的变量重新取一个名字,import命令要使用as关键字,将输入的变量重命名。
    import { lastName as surname } from './profile.js';
    
    • import命令输入的变量都是只读的,因为它的本质是输入接口。也就是说,不允许在加载模块的脚本里面,改写接口。
    import {a} from './xxx.js'
    
    a = {}; // Syntax Error : 'a' is read-only;
    

    上面代码中,脚本加载了变量a,对其重新赋值就会报错,因为a是一个只读的接口。

    • 但是,如果a是一个对象,改写a的属性是允许的。
    import {a} from './xxx.js'
    
    a.foo = 'hello'; // 合法操作
    

    上面代码中,a的属性可以成功改写,并且其他模块也可以读到改写后的值。不过,这种写法很难查错,建议凡是输入的变量,都当作完全只读,轻易不要改变它的属性。

    import后面的from指定模块文件的位置,可以是相对路径,也可以是绝对路径,.js后缀可以省略。如果只是模块名,不带有路径,那么必须有配置文件,告诉 JavaScript 引擎该模块的位置。

    import {myMethod} from 'util';
    

    上面代码中,util是模块文件名,由于不带有路径,必须通过配置,告诉引擎怎么取到这个模块。

    注意,import命令具有提升效果,会提升到整个模块的头部,首先执行。

    foo();
    
    import { foo } from 'my_module';
    

    上面的代码不会报错,因为import的执行早于foo的调用。这种行为的本质是,import命令是编译阶段执行的,在代码运行之前。

    • 由于import是静态执行,所以不能使用表达式和变量,这些只有在运行时才能得到结果的语法结构。
    // 报错
    import { 'f' + 'oo' } from 'my_module';
    
    // 报错
    let module = 'my_module';
    import { foo } from module;
    
    // 报错
    if (x === 1) {
      import { foo } from 'module1';
    } else {
      import { foo } from 'module2';
    }
    

    上面三种写法都会报错,因为它们用到了表达式、变量和if结构。在静态分析阶段,这些语法都是没法得到值的。

    • 最后,import语句会执行所加载的模块,因此可以有下面的写法。
    import 'lodash';
    

    上面代码仅仅执行lodash模块,但是不输入任何值。

    • 如果多次重复执行同一句import语句,那么只会执行一次,而不会执行多次。
    import 'lodash';
    import 'lodash';
    

    上面代码加载了两次lodash,但是只会执行一次。

    import { foo } from 'my_module';
    import { bar } from 'my_module';
    
    // 等同于
    import { foo, bar } from 'my_module';
    

    上面代码中,虽然foo和bar在两个语句中加载,但是它们对应的是同一个my_module实例。也就是说,import语句是 Singleton 模式。

    • 目前阶段,通过 Babel 转码,CommonJS 模块的require命令和 ES6 模块的import命令,可以写在同一个模块里面,但是最好不要这样做。因为import在静态解析阶段执行,所以它是一个模块之中最早执行的。下面的代码可能不会得到预期结果。
    require('core-js/modules/es6.symbol');
    require('core-js/modules/es6.promise');
    import React from 'React';
    

    21.5 模块的整体加载

    • 除了指定加载某个输出值,还可以使用整体加载,即用星号(*)指定一个对象,所有输出值都加载在这个对象上面。

    下面是一个circle.js文件,它输出两个方法area和circumference。

    // circle.js
    
    export function area(radius) {
      return Math.PI * radius * radius;
    }
    
    export function circumference(radius) {
      return 2 * Math.PI * radius;
    }
    

    现在,加载这个模块。

    // main.js
    
    import { area, circumference } from './circle';
    
    console.log('圆面积:' + area(4));
    console.log('圆周长:' + circumference(14));
    

    上面写法是逐一指定要加载的方法,整体加载的写法如下。

    import * as circle from './circle';
    
    console.log('圆面积:' + circle.area(4));
    console.log('圆周长:' + circle.circumference(14));
    

    注意,模块整体加载所在的那个对象(上例是circle),应该是可以静态分析的,所以不允许运行时改变。下面的写法都是不允许的。

    import * as circle from './circle';
    
    // 下面两行都是不允许的
    circle.foo = 'hello';
    circle.area = function () {};
    

    21.6 export default 命令

    • 为了给用户提供方便,让他们不用阅读文档就能加载模块,就要用到export default命令,为模块指定默认输出。
    // export-default.js
    export default function () {
      console.log('foo');
    }
    

    上面代码是一个模块文件export-default.js,它的默认输出是一个函数。

    • 其他模块加载该模块时,import命令可以为该匿名函数指定任意名字。
    // import-default.js
    import customName from './export-default';
    customName(); // 'foo'
    

    上面代码的import命令,可以用任意名称指向export-default.js输出的方法,这时就不需要知道原模块输出的函数名。需要注意的是,这时import命令后面,不使用大括号。

    • export default命令用在非匿名函数前,也是可以的。
    // export-default.js
    export default function foo() {
      console.log('foo');
    }
    
    // 或者写成
    
    function foo() {
      console.log('foo');
    }
    
    export default foo;
    

    上面代码中,foo函数的函数名foo,在模块外部是无效的。加载的时候,视同匿名函数加载。

    • export default命令用于指定模块的默认输出。显然,一个模块只能有一个默认输出,因此export default命令只能使用一次。所以,import命令后面才不用加大括号,因为只可能唯一对应export default命令。

    • 本质上,export default就是输出一个叫做default的变量或方法,然后系统允许你为它取任意名字。所以,下面的写法是有效的。

    // modules.js
    function add(x, y) {
      return x * y;
    }
    export {add as default};
    // 等同于
    // export default add;
    
    // app.js
    import { default as foo } from 'modules';
    // 等同于
    // import foo from 'modules';
    
    • 正是因为export default命令其实只是输出一个叫做default的变量,所以它后面不能跟变量声明语句。
    // 正确
    export var a = 1;
    
    // 正确
    var a = 1;
    export default a;
    
    // 错误
    export default var a = 1;
    
    • 上面代码中,export default a的含义是将变量a的值赋给变量default。所以,最后一种写法会报错。

    • 同样地,因为export default命令的本质是将后面的值,赋给default变量,所以可以直接将一个值写在export default之后。

    // 正确
    export default 42;
    
    // 报错
    export 42;
    

    上面代码中,后一句报错是因为没有指定对外的接口,而前一句指定外对接口为default。

    • 有了export default命令,输入模块时就非常直观了,以输入 lodash 模块为例。
    import _ from 'lodash';
    
    • 如果想在一条import语句中,同时输入默认方法和其他接口,可以写成下面这样。
    import _, { each, each as forEach } from 'lodash';
    

    对应上面代码的export语句如下。

    export default function (obj) {
      // ···
    }
    
    export function each(obj, iterator, context) {
      // ···
    }
    
    export { each as forEach };
    

    上面代码的最后一行的意思是,暴露出forEach接口,默认指向each接口,即forEach和each指向同一个方法。

    export default也可以用来输出类。

    // MyClass.js
    export default class { ... }
    
    // main.js
    import MyClass from 'MyClass';
    let o = new MyClass();
    

    21.7 export 与 import 的复合写法

    • 如果在一个模块之中,先输入后输出同一个模块,import语句可以与export语句写在一起。
    export { foo, bar } from 'my_module';
    
    // 可以简单理解为
    import { foo, bar } from 'my_module';
    export { foo, bar };
    

    上面代码中,export和import语句可以结合在一起,写成一行。但需要注意的是,写成一行以后,foo和bar实际上并没有被导入当前模块,只是相当于对外转发了这两个接口,导致当前模块不能直接使用foo和bar。

    模块的接口改名和整体输出,也可以采用这种写法。

    // 接口改名
    export { foo as myFoo } from 'my_module';
    
    // 整体输出
    export * from 'my_module';
    

    默认接口的写法如下。

    export { default } from 'foo';
    

    具名接口改为默认接口的写法如下。

    export { es6 as default } from './someModule';
    
    // 等同于
    import { es6 } from './someModule';
    export default es6;
    

    同样地,默认接口也可以改名为具名接口。

    export { default as es6 } from './someModule';
    

    下面三种import语句,没有对应的复合写法。

    import * as someIdentifier from "someModule";
    import someIdentifier from "someModule";
    import someIdentifier, { namedIdentifier } from "someModule";
    

    为了做到形式的对称,现在有提案,提出补上这三种复合写法。

    export * as someIdentifier from "someModule";
    export someIdentifier from "someModule";
    export someIdentifier, { namedIdentifier } from "someModule";
    

    21.8 模块的继承

    • 模块之间也可以继承。

    假设有一个circleplus模块,继承了circle模块。

    // circleplus.js
    
    export * from 'circle';
    export var e = 2.71828182846;
    export default function(x) {
      return Math.exp(x);
    }
    

    上面代码中的export *,表示再输出circle模块的所有属性和方法。注意,export *命令会忽略circle模块的default方法。然后,上面代码又输出了自定义的e变量和默认方法。

    这时,也可以将circle的属性或方法,改名后再输出。

    // circleplus.js
    
    export { area as circleArea } from 'circle';
    

    上面代码表示,只输出circle模块的area方法,且将其改名为circleArea。

    加载上面模块的写法如下。

    // main.js
    
    import * as math from 'circleplus';
    import exp from 'circleplus';
    console.log(exp(math.e));
    

    上面代码中的import exp表示,将circleplus模块的默认方法加载为exp方法。

    21.9 跨模块常量

    • 本书介绍const命令的时候说过,const声明的常量只在当前代码块有效。如果想设置跨模块的常量(即跨多个文件),或者说一个值要被多个模块共享,可以采用下面的写法。
    // constants.js 模块
    export const A = 1;
    export const B = 3;
    export const C = 4;
    
    // test1.js 模块
    import * as constants from './constants';
    console.log(constants.A); // 1
    console.log(constants.B); // 3
    
    // test2.js 模块
    import {A, B} from './constants';
    console.log(A); // 1
    console.log(B); // 3
    

    如果要使用的常量非常多,可以建一个专门的constants目录,将各种常量写在不同的文件里面,保存在该目录下。

    // constants/db.js
    export const db = {
      url: 'http://my.couchdbserver.local:5984',
      admin_username: 'admin',
      admin_password: 'admin password'
    };
    
    // constants/user.js
    export const users = ['root', 'admin', 'staff', 'ceo', 'chief', 'moderator'];
    

    然后,将这些文件输出的常量,合并在index.js里面。

    // constants/index.js
    export {db} from './db';
    export {users} from './users';
    

    使用的时候,直接加载index.js就可以了。

    // script.js
    import {db, users} from './index';
    

    21.10 import()

    简介

    • 前面介绍过,import命令会被 JavaScript 引擎静态分析,先于模块内的其他语句执行。也就是说,import和export命令只能在模块的顶层,不能在代码块之中(比如,在if代码块之中,或在函数之中)。

    这样的设计,固然有利于编译器提高效率,但也导致无法在运行时加载模块。在语法上,条件加载就不可能实现。如果import命令要取代 Node 的require方法,这就形成了一个障碍。因为require是运行时加载模块,import命令无法取代require的动态加载功能。

    const path = './' + fileName;
    const myModual = require(path);
    

    上面的语句就是动态加载,require到底加载哪一个模块,只有运行时才知道。import命令做不到这一点。

    因此,有一个提案,建议引入import()函数,完成动态加载。

    import(specifier)
    

    上面代码中,import函数的参数specifier,指定所要加载的模块的位置。import命令能够接受什么参数,import()函数就能接受什么参数,两者区别主要是后者为动态加载。

    import()返回一个 Promise 对象。下面是一个例子。

    const main = document.querySelector('main');
    
    import(`./section-modules/${someVariable}.js`)
      .then(module => {
        module.loadPageInto(main);
      })
      .catch(err => {
        main.textContent = err.message;
      });
    

    import()函数可以用在任何地方,不仅仅是模块,非模块的脚本也可以使用。它是运行时执行,也就是说,什么时候运行到这一句,就会加载指定的模块。另外,import()函数与所加载的模块没有静态连接关系,这点也是与import语句不相同。import()类似于 Node 的require方法,区别主要是前者是异步加载,后者是同步加载。

    适用场合

    下面是import()的一些适用场合。

    (1)按需加载。

    import()可以在需要的时候,再加载某个模块。

    button.addEventListener('click', event => {
      import('./dialogBox.js')
      .then(dialogBox => {
        dialogBox.open();
      })
      .catch(error => {
        /* Error handling */
      })
    });
    

    上面代码中,import()方法放在click事件的监听函数之中,只有用户点击了按钮,才会加载这个模块。

    (2)条件加载

    import()可以放在if代码块,根据不同的情况,加载不同的模块。

    if (condition) {
      import('moduleA').then(...);
    } else {
      import('moduleB').then(...);
    }
    

    上面代码中,如果满足条件,就加载模块 A,否则加载模块 B。

    (3)动态的模块路径

    import()允许模块路径动态生成。

    import(f())
    .then(...);
    

    上面代码中,根据函数f的返回结果,加载不同的模块。

    注意点

    • import()加载模块成功以后,这个模块会作为一个对象,当作then方法的参数。因此,可以使用对象解构赋值的语法,获取输出接口。
    import('./myModule.js')
    .then(({export1, export2}) => {
      // ...·
    });
    

    上面代码中,export1和export2都是myModule.js的输出接口,可以解构获得。

    • 如果模块有default输出接口,可以用参数直接获得。
    import('./myModule.js')
    .then(myModule => {
      console.log(myModule.default);
    });
    

    上面的代码也可以使用具名输入的形式。

    import('./myModule.js')
    .then(({default: theDefault}) => {
      console.log(theDefault);
    });
    
    • 如果想同时加载多个模块,可以采用下面的写法。
    Promise.all([
      import('./module1.js'),
      import('./module2.js'),
      import('./module3.js'),
    ])
    .then(([module1, module2, module3]) => {
       ···
    });
    
    • import()也可以用在 async 函数之中。
    async function main() {
      const myModule = await import('./myModule.js');
      const {export1, export2} = await import('./myModule.js');
      const [module1, module2, module3] =
        await Promise.all([
          import('./module1.js'),
          import('./module2.js'),
          import('./module3.js'),
        ]);
    }
    main();
    

    22 Module 的加载实现 <a id = "Module 的加载实现"></a>

    22.1 浏览器加载

    传统方法

    HTML 网页中,浏览器通过<code><script></code>标签加载 JavaScript 脚本。

    <!-- 页面内嵌的脚本 -->
    <script type="application/javascript">
      // module code
    </script>
    
    <!-- 外部脚本 -->
    <script type="application/javascript" src="path/to/myModule.js">
    </script>
    

    上面代码中,由于浏览器脚本的默认语言是 JavaScript,因此type="application/javascript"可以省略。

    默认情况下,浏览器是同步加载 JavaScript 脚本,即渲染引擎遇到<code><script></code>标签就会停下来,等到执行完脚本,再继续向下渲染。如果是外部脚本,还必须加入脚本下载的时间。

    如果脚本体积很大,下载和执行的时间就会很长,因此造成浏览器堵塞,用户会感觉到浏览器“卡死”了,没有任何响应。这显然是很不好的体验,所以浏览器允许脚本异步加载,下面就是两种异步加载的语法。

    <script src="path/to/myModule.js" defer></script>
    <script src="path/to/myModule.js" async></script>
    

    上面代码中,<code><script></code>标签打开defer或async属性,脚本就会异步加载。渲染引擎遇到这一行命令,就会开始下载外部脚本,但不会等它下载和执行,而是直接执行后面的命令。

    • defer与async的区别是:defer要等到整个页面在内存中正常渲染结束(DOM 结构完全生成,以及其他脚本执行完成),才会执行;async一旦下载完,渲染引擎就会中断渲染,执行这个脚本以后,再继续渲染。一句话,defer是“渲染完再执行”,async是“下载完就执行”。另外,如果有多个defer脚本,会按照它们在页面出现的顺序加载,而多个async脚本是不能保证加载顺序的。

    加载规则

    • 浏览器加载 ES6 模块,也使用<code><script></code>标签,但是要加入type="module"属性。
    <script type="module" src="./foo.js"></script>
    

    上面代码在网页中插入一个模块foo.js,由于type属性设为module,所以浏览器知道这是一个 ES6 模块。

    • 浏览器对于带有type="module"的<code><script></code>,都是异步加载,不会造成堵塞浏览器,即等到整个页面渲染完,再执行模块脚本,等同于打开了<code><script></code>标签的defer属性。
    <script type="module" src="./foo.js"></script>
    <!-- 等同于 -->
    <script type="module" src="./foo.js" defer></script>
    
    • 如果网页有多个<code><script type="module"></code>>,它们会按照在页面出现的顺序依次执行。

    • <code><script></code>标签的async属性也可以打开,这时只要加载完成,渲染引擎就会中断渲染立即执行。执行完成后,再恢复渲染。

    <script type="module" src="./foo.js" async></script>
    
    • 一旦使用了async属性,<code><script type="module"></code>就不会按照在页面出现的顺序执行,而是只要该模块加载完成,就执行该模块。

    • ES6 模块也允许内嵌在网页中,语法行为与加载外部脚本完全一致。

    <script type="module">
      import utils from "./utils.js";
    
      // other code
    </script>
    
    • 对于外部的模块脚本(上例是foo.js),有几点需要注意。

      - 代码是在模块作用域之中运行,而不是在全局作用域运行。模块内部的顶层变量,外部不可见。

      - 模块脚本自动采用严格模式,不管有没有声明use strict。

      - 模块之中,可以使用import命令加载其他模块(.js后缀不可省略,需要提供绝对 URL 或相对 URL),也可以使用export命令输出对外接口。

      - 模块之中,顶层的this关键字返回undefined,而不是指向window。也就是说,在模块顶层使用this关键字,是无意义的。

      - 同一个模块如果加载多次,将只执行一次。

    下面是一个示例模块。

    import utils from 'https://example.com/js/utils.js';
    
    const x = 1;
    
    console.log(x === window.x); //false
    console.log(this === undefined); // true
    

    利用顶层的this等于undefined这个语法点,可以侦测当前代码是否在 ES6 模块之中。

    const isNotModuleScript = this !== undefined;
    

    22.2 ES6 模块与 CommmonJS 模块的差异

    讨论 Node 加载 ES6 模块之前,必须了解 ES6 模块与 CommonJS 模块完全不同。

    它们有两个重大差异。

      - CommonJS 模块输出的是一个值的拷贝,ES6 模块输出的是值的引用。

      - CommonJS 模块是运行时加载,ES6 模块是编译时输出接口。

    • CommonJS 模块输出的是值的拷贝,也就是说,一旦输出一个值,模块内部的变化就影响不到这个值。

    • ES6 模块的运行机制与 CommonJS 不一样。JS 引擎对脚本静态分析的时候,遇到模块加载命令import,就会生成一个只读引用。等到脚本真正执行时,再根据这个只读引用,到被加载的那个模块里面去取值。换句话说,ES6 的import有点像 Unix 系统的“符号连接”,原始值变了,import加载的值也会跟着变。因此,ES6 模块是动态引用,并且不会缓存值,模块里面的变量绑定其所在的模块。

    • 由于 ES6 输入的模块变量,只是一个“符号连接”,所以这个变量是只读的,对它进行重新赋值会报错。

    22.3 Node 加载

    概述

    内部变量

    • ES6 模块应该是通用的,同一个模块不用修改,就可以用在浏览器环境和服务器环境。为了达到这个目标,Node 规定 ES6 模块之中不能使用 CommonJS 模块的特有的一些内部变量。

    首先,就是this关键字。ES6 模块之中,顶层的this指向undefined;CommonJS 模块的顶层this指向当前模块,这是两者的一个重大差异。

    其次,以下这些顶层变量在 ES6 模块之中都是不存在的。

      - arguments

      - require

      - module

      - exports

      - __filename

      - __dirname

    如果你一定要使用这些变量,有一个变通方法,就是写一个 CommonJS 模块输出这些变量,然后再用 ES6 模块加载这个 CommonJS 模块。但是这样一来,该 ES6 模块就不能直接用于浏览器环境了,所以不推荐这样做。

    // expose.js
    module.exports = {__dirname};
    
    // use.mjs
    import expose from './expose.js';
    const {__dirname} = expose;
    

    上面代码中,expose.js是一个 CommonJS 模块,输出变量__dirname,该变量在 ES6 模块之中不存在。ES6 模块加载expose.js,就可以得到__dirname。

    ES6 模块加载 CommonJS 模块

    • CommonJS 模块的输出都定义在module.exports这个属性上面。Node 的import命令加载 CommonJS 模块,Node 会自动将module.exports属性,当作模块的默认输出,即等同于export default xxx。

    下面是一个 CommonJS 模块。

    // a.js
    module.exports = {
      foo: 'hello',
      bar: 'world'
    };
    
    // 等同于
    export default {
      foo: 'hello',
      bar: 'world'
    };
    

    import命令加载上面的模块,module.exports会被视为默认输出,即import命令实际上输入的是这样一个对象{ default: module.exports }。

    所以,一共有三种写法,可以拿到 CommonJS 模块的module.exports。

    // 写法一
    import baz from './a';
    // baz = {foo: 'hello', bar: 'world'};
    
    // 写法二
    import {default as baz} from './a';
    // baz = {foo: 'hello', bar: 'world'};
    
    // 写法三
    import * as baz from './a';
    // baz = {
    //   get default() {return module.exports;},
    //   get foo() {return this.default.foo}.bind(baz),
    //   get bar() {return this.default.bar}.bind(baz)
    // }
    

    上面代码的第三种写法,可以通过baz.default拿到module.exports。foo属性和bar属性就是可以通过这种方法拿到了module.exports。

    • CommonJS 模块的输出缓存机制,在 ES6 加载方式下依然有效。
    // foo.js
    module.exports = 123;
    setTimeout(_ => module.exports = null);
    

    上面代码中,对于加载foo.js的脚本,module.exports将一直是123,而不会变成null。

    由于 ES6 模块是编译时确定输出接口,CommonJS 模块是运行时确定输出接口,所以采用import命令加载 CommonJS 模块时,不允许采用下面的写法。

    // 不正确
    import { readFile } from 'fs';
    

    上面的写法不正确,因为fs是 CommonJS 格式,只有在运行时才能确定readFile接口,而import命令要求编译时就确定这个接口。解决方法就是改为整体输入。

    // 正确的写法一
    import * as express from 'express';
    const app = express.default();
    
    // 正确的写法二
    import express from 'express';
    const app = express();
    

    CommonJS 模块加载 ES6 模块

    • CommonJS 模块加载 ES6 模块,不能使用require命令,而要使用import()函数。ES6 模块的所有输出接口,会成为输入对象的属性。
    // es.mjs
    let foo = { bar: 'my-default' };
    export default foo;
    
    // cjs.js
    const es_namespace = await import('./es.mjs');
    // es_namespace = {
    //   get default() {
    //     ...
    //   }
    // }
    console.log(es_namespace.default);
    // { bar:'my-default' }
    

    上面代码中,default接口变成了es_namespace.default属性。

    下面是另一个例子。

    // es.js
    export let foo = { bar:'my-default' };
    export { foo as bar };
    export function f() {};
    export class c {};
    
    // cjs.js
    const es_namespace = await import('./es');
    // es_namespace = {
    //   get foo() {return foo;}
    //   get bar() {return foo;}
    //   get f() {return f;}
    //   get c() {return c;}
    // }
    

    22.4 循环加载

    • “循环加载”(circular dependency)指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。

    对于 JavaScript 语言来说,目前最常见的两种模块格式 CommonJS 和 ES6,处理“循环加载”的方法是不一样的,返回的结果也不一样。

    CommonJS 模块的加载原理

    • CommonJS 的一个模块,就是一个脚本文件。require命令第一次加载该脚本,就会执行整个脚本,然后在内存生成一个对象。
    {
      id: '...',
      exports: { ... },
      loaded: true,
      ...
    }
    

    上面代码就是 Node 内部加载模块后生成的一个对象。该对象的id属性是模块名,exports属性是模块输出的各个接口,loaded属性是一个布尔值,表示该模块的脚本是否执行完毕。其他还有很多属性,这里都省略了。

    以后需要用到这个模块的时候,就会到exports属性上面取值。即使再次执行require命令,也不会再次执行该模块,而是到缓存之中取值。也就是说,CommonJS 模块无论加载多少次,都只会在第一次加载时运行一次,以后再加载,就返回第一次运行的结果,除非手动清除系统缓存。

    CommonJS 模块的循环加载

    • CommonJS 模块的重要特性是加载时执行,即脚本代码在require的时候,就会全部执行。一旦出现某个模块被"循环加载",就只输出已经执行的部分,还未执行的部分不会输出。

    ES6 模块的循环加载

    • ES6 处理“循环加载”与 CommonJS 有本质的不同。ES6 模块是动态引用,如果使用import从一个模块加载变量(即import foo from 'foo'),那些变量不会被缓存,而是成为一个指向被加载模块的引用,需要开发者自己保证,真正取值的时候能够取到值。

    http://es6.ruanyifeng.com/#docs/module-loader#ES6-模块的循环加载

    22.5 ES6 模块的转码

    浏览器目前还不支持 ES6 模块,为了现在就能使用,可以将转为 ES5 的写法。除了 Babel 可以用来转码之外,还有以下两个方法,也可以用来转码。

    ES6 module transpiler

    SystemJS

    23 编程风格 <a id = "编程风格"></a>

    • 多家公司和组织已经公开了它们的风格规范,下面的内容主要参考了 Airbnb 公司的 JavaScript 风格规范。

    23.1 块级作用域

    (1)let 取代 var

    • ES6 提出了两个新的声明变量的命令:let和const。其中,let完全可以取代var,因为两者语义相同,而且let没有副作用。

    • var命令存在变量提升效用,let命令没有这个问题。

    • 所以,建议不再使用var命令,而是使用let命令取代。

    (2)全局常量和线程安全

    • 在let和const之间,建议优先使用const,尤其是在全局环境,不应该设置变量,只应设置常量。

    • const优于let有几个原因。一个是const可以提醒阅读程序的人,这个变量不应该改变;另一个是const比较符合函数式编程思想,运算不改变值,只是新建值,而且这样也有利于将来的分布式运算;最后一个原因是 JavaScript 编译器会对const进行优化,所以多使用const,有利于提高程序的运行效率,也就是说let和const的本质区别,其实是编译器内部的处理不同。

    // bad
    var a = 1, b = 2, c = 3;
    
    // good
    const a = 1;
    const b = 2;
    const c = 3;
    
    // best
    const [a, b, c] = [1, 2, 3];
    
    • const声明常量还有两个好处,一是阅读代码的人立刻会意识到不应该修改这个值,二是防止了无意间修改变量值所导致的错误。

    • 所有的函数都应该设置为常量。

    • 长远来看,JavaScript 可能会有多线程的实现(比如 Intel 公司的 River Trail 那一类的项目),这时let表示的变量,只应出现在单线程运行的代码中,不能是多线程共享的,这样有利于保证线程安全。

    23.2 字符串

    • 静态字符串一律使用单引号或反引号,不使用双引号。动态字符串使用反引号。
    // bad
    const a = "foobar";
    const b = 'foo' + a + 'bar';
    
    // acceptable
    const c = `foobar`;
    
    // good
    const a = 'foobar';
    const b = `foo${a}bar`;
    const c = 'foobar';
    

    23.3 解构赋值

    • 使用数组成员对变量赋值时,优先使用解构赋值。
    const arr = [1, 2, 3, 4];
    
    // bad
    const first = arr[0];
    const second = arr[1];
    
    // good
    const [first, second] = arr;
    
    • 函数的参数如果是对象的成员,优先使用解构赋值。
    // bad
    function getFullName(user) {
      const firstName = user.firstName;
      const lastName = user.lastName;
    }
    
    // good
    function getFullName(obj) {
      const { firstName, lastName } = obj;
    }
    
    // best
    function getFullName({ firstName, lastName }) {
    }
    
    • 如果函数返回多个值,优先使用对象的解构赋值,而不是数组的解构赋值。这样便于以后添加返回值,以及更改返回值的顺序。
    // bad
    function processInput(input) {
      return [left, right, top, bottom];
    }
    
    // good
    function processInput(input) {
      return { left, right, top, bottom };
    }
    
    const { left, right } = processInput(input);
    

    23.4 对象

    • 单行定义的对象,最后一个成员不以逗号结尾。多行定义的对象,最后一个成员以逗号结尾。
    // bad
    const a = { k1: v1, k2: v2, };
    const b = {
      k1: v1,
      k2: v2
    };
    
    // good
    const a = { k1: v1, k2: v2 };
    const b = {
      k1: v1,
      k2: v2,
    };
    
    • 对象尽量静态化,一旦定义,就不得随意添加新的属性。如果添加属性不可避免,要使用Object.assign方法。
    // bad
    const a = {};
    a.x = 3;
    
    // if reshape unavoidable
    const a = {};
    Object.assign(a, { x: 3 });
    
    // good
    const a = { x: null };
    a.x = 3;
    
    • 如果对象的属性名是动态的,可以在创造对象的时候,使用属性表达式定义。
    // bad
    const obj = {
      id: 5,
      name: 'San Francisco',
    };
    obj[getKey('enabled')] = true;
    
    // good
    const obj = {
      id: 5,
      name: 'San Francisco',
      [getKey('enabled')]: true,
    };
    
    • 另外,对象的属性和方法,尽量采用简洁表达法,这样易于描述和书写。
    var ref = 'some value';
    
    // bad
    const atom = {
      ref: ref,
    
      value: 1,
    
      addValue: function (value) {
        return atom.value + value;
      },
    };
    
    // good
    const atom = {
      ref,
    
      value: 1,
    
      addValue(value) {
        return atom.value + value;
      },
    };
    

    23.5 数组

    • 使用扩展运算符(...)拷贝数组。
    // bad
    const len = items.length;
    const itemsCopy = [];
    let i;
    
    for (i = 0; i < len; i++) {
      itemsCopy[i] = items[i];
    }
    
    // good
    const itemsCopy = [...items];
    
    • 使用 Array.from 方法,将类似数组的对象转为数组。
    const foo = document.querySelectorAll('.foo');
    const nodes = Array.from(foo);
    

    23.6 函数

    • 立即执行函数可以写成箭头函数的形式。

    • 那些需要使用函数表达式的场合,尽量用箭头函数代替。因为这样更简洁,而且绑定了 this。

    • 箭头函数取代Function.prototype.bind,不应再用 self/_this/that 绑定 this。

    // bad
    const self = this;
    const boundMethod = function(...params) {
      return method.apply(self, params);
    }
    
    // acceptable
    const boundMethod = method.bind(this);
    
    // best
    const boundMethod = (...params) => method.apply(this, params);
    
    • 简单的、单行的、不会复用的函数,建议采用箭头函数。如果函数体较为复杂,行数较多,还是应该采用传统的函数写法。

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

    // bad
    function divide(a, b, option = false ) {
    }
    
    // good
    function divide(a, b, { option = false } = {}) {
    }
    
    • 不要在函数体内使用 arguments 变量,使用 rest 运算符(...)代替。因为 rest 运算符显式表明你想要获取参数,而且 arguments 是一个类似数组的对象,而 rest 运算符可以提供一个真正的数组。
    // bad
    function concatenateAll() {
      const args = Array.prototype.slice.call(arguments);
      return args.join('');
    }
    
    // good
    function concatenateAll(...args) {
      return args.join('');
    }
    
    • 使用默认值语法设置函数参数的默认值。
    // bad
    function handleThings(opts) {
      opts = opts || {};
    }
    
    // good
    function handleThings(opts = {}) {
      // ...
    }
    

    23.7 Map 结构

    • 注意区分 Object 和 Map,只有模拟现实世界的实体对象时,才使用 Object。如果只是需要key: value的数据结构,使用 Map 结构。因为 Map 有内建的遍历机制。

    23.8 Class

    • 总是用 Class,取代需要 prototype 的操作。因为 Class 的写法更简洁,更易于理解。
    // bad
    function Queue(contents = []) {
      this._queue = [...contents];
    }
    Queue.prototype.pop = function() {
      const value = this._queue[0];
      this._queue.splice(0, 1);
      return value;
    }
    
    // good
    class Queue {
      constructor(contents = []) {
        this._queue = [...contents];
      }
      pop() {
        const value = this._queue[0];
        this._queue.splice(0, 1);
        return value;
      }
    }
    
    • 使用extends实现继承,因为这样更简单,不会有破坏instanceof运算的危险。
    // bad
    const inherits = require('inherits');
    function PeekableQueue(contents) {
      Queue.apply(this, contents);
    }
    inherits(PeekableQueue, Queue);
    PeekableQueue.prototype.peek = function() {
      return this._queue[0];
    }
    
    // good
    class PeekableQueue extends Queue {
      peek() {
        return this._queue[0];
      }
    }
    

    23.9 模块

    • 首先,Module 语法是 JavaScript 模块的标准写法,坚持使用这种写法。使用import取代require。

    • 使用export取代module.exports。

    • 如果模块只有一个输出值,就使用export default,如果模块有多个输出值,就不使用export default,export default与普通的export不要同时使用。

    • 不要在模块输入中使用通配符。因为这样可以确保你的模块之中,有一个默认输出(export default)。

    • 如果模块默认输出一个函数,函数名的首字母应该小写。

    • 如果模块默认输出一个对象,对象名的首字母应该大写。

    23.10 ESLint 的使用

    24 读懂规格 <a id = "读懂规格"></a>

    24.1 概述

    • ECMAScript 6 的规格,可以在 ECMA 国际标准组织的官方网站 www.ecma-international.org/ecma-262/6.0/ 免费下载和在线阅读。

    • ECMAScript 6 规格的 26 章之中,第 1 章到第 3 章是对文件本身的介绍,与语言关系不大。第 4 章是对这门语言总体设计的描述,有兴趣的读者可以读一下。第 5 章到第 8 章是语言宏观层面的描述。第 5 章是规格的名词解释和写法的介绍,第 6 章介绍数据类型,第 7 章介绍语言内部用到的抽象操作,第 8 章介绍代码如何运行。第 9 章到第 26 章介绍具体的语法。

    • 对于一般用户来说,除了第 4 章,其他章节都涉及某一方面的细节,不用通读,只要在用到的时候,查阅相关章节即可。

    24.2 术语

    抽象操作

    • 所谓”抽象操作“(abstract operations)就是引擎的一些内部方法,外部不能调用。规格定义了一系列的抽象操作,规定了它们的行为,留给各种引擎自己去实现。

    举例来说,Boolean(value)的算法,第一步是这样的。

      1.Let b be ToBoolean(value).

    这里的ToBoolean就是一个抽象操作,是引擎内部求出布尔值的算法。

    许多函数的算法都会多次用到同样的步骤,所以 ES6 规格将它们抽出来,定义成”抽象操作“,方便描述。

    Record 和 field

    • ES6 规格将键值对(key-value map)的数据结构称为 Record,其中的每一组键值对称为 field。这就是说,一个 Record 由多个 field 组成,而每个 field 都包含一个键名(key)和一个键值(value)。

    [[Notation]]

    • ES6 规格大量使用[[Notation]]这种书写法,比如[[Value]]、[[Writable]]、[[Get]]、[[Set]]等等。它用来指代 field 的键名。

    举例来说,obj是一个 Record,它有一个Prototype属性。ES6 规格不会写obj.Prototype,而是写obj.[[Prototype]]。一般来说,使用[[Notation]]这种书写法的属性,都是对象的内部属性。

    所有的 JavaScript 函数都有一个内部属性[[Call]],用来运行该函数。

    F.[[Call]](V, argumentsList)
    

    上面代码中,F是一个函数对象,[[Call]]是它的内部方法,F.[[call]]()表示运行该函数,V表示[[Call]]运行时this的值,argumentsList则是调用时传入函数的参数。

    Completion Record

    • 每一个语句都会返回一个 Completion Record,表示运行结果。每个 Completion Record 有一个[[Type]]属性,表示运行结果的类型。

    [[Type]]属性有五种可能的值。

      - normal

      - return

      - throw

      - break

      - continue

    • 如果[[Type]]的值是normal,就称为 normal completion,表示运行正常。其他的值,都称为 abrupt completion。其中,开发者只需要关注[[Type]]为throw的情况,即运行出错;break、continue、return这三个值都只出现在特定场景,可以不用考虑。

    24.3 抽象操作的标准流程

    • 抽象操作的运行流程,一般是下面这样。

      1. Let resultCompletionRecord be AbstractOp().

      2. If resultCompletionRecord is an abrupt completion, return resultCompletionRecord.

      3. Let result be resultCompletionRecord.[[Value]].

      4. return result.

    上面的第一步是调用抽象操作AbstractOp(),得到resultCompletionRecord,这是一个 Completion Record。第二步,如果这个 Record 属于 abrupt completion,就将resultCompletionRecord返回给用户。如果此处没有返回,就表示运行结果正常,所得的值存放在resultCompletionRecord.[[Value]]属性。第三步,将这个值记为result。第四步,将result返回给用户。

    ES6 规格将这个标准流程,使用简写的方式表达。

      1. Let result be AbstractOp().

      2. ReturnIfAbrupt(result).

      3. return result.

    这个简写方式里面的ReturnIfAbrupt(result),就代表了上面的第二步和第三步,即如果有报错,就返回错误,否则取出值。

    甚至还有进一步的简写格式。

      1. Let result be ? AbstractOp().
      2. return result.

    上面流程的?,就代表AbstractOp()可能会报错。一旦报错,就返回错误,否则取出值。

    除了?,ES 6 规格还使用另一个简写符号!。

      1. Let result be ! AbstractOp().

      2. return result.

    上面流程的!,代表AbstractOp()不会报错,返回的一定是 normal completion,总是可以取出值。

    24.4 相等运算符

    • 相等运算符(==)是一个很让人头痛的运算符,它的语法行为多变,不符合直觉。这个小节就看看规格怎么规定它的行为。

    请看下面这个表达式,请问它的值是多少。

    0 == null
    

    如果你不确定答案,或者想知道语言内部怎么处理,就可以去查看规格,7.2.12 小节是对相等运算符(==)的描述。

    规格对每一种语法行为的描述,都分成两部分:先是总体的行为描述,然后是实现的算法细节。相等运算符的总体描述,只有一句话。

      “The comparison x == y, where x and y are values, produces true or false.”

    上面这句话的意思是,相等运算符用于比较两个值,返回true或false。

    下面是算法细节。

      1.ReturnIfAbrupt(x).

      2.ReturnIfAbrupt(y).

      3.If Type(x) is the same as Type(y), then

      4.Return the result of performing Strict Equality Comparison x === y.

      5.If x is null and y is undefined, return true.

      6.If x is undefined and y is null, return true.

      7.If Type(x) is Number and Type(y) is String, return the result of the comparison x == ToNumber(y).

      8.If Type(x) is String and Type(y) is Number, return the result of the comparison ToNumber(x) == y.

    If Type(x) is Boolean, return the result of the comparison ToNumber(x) == y.

      9.If Type(y) is Boolean, return the result of the comparison x == ToNumber(y).

      10.If Type(x) is either String, Number, or Symbol and Type(y) is Object, then return the result of the comparison x == ToPrimitive(y).

      11.If Type(x) is Object and Type(y) is either String, Number, or Symbol, then return the result of the comparison ToPrimitive(x) == y.

      12.Return false.

    上面这段算法,一共有 12 步,翻译如下。

      1.如果x不是正常值(比如抛出一个错误),中断执行。

      2.如果y不是正常值,中断执行。

      3.如果Type(x)与Type(y)相同,执行严格相等运算x === y。

      4.如果x是null,y是undefined,返回true。

      5.如果x是undefined,y是null,返回true。

      6.如果Type(x)是数值,Type(y)是字符串,返回x == ToNumber(y)的结果。

      7.如果Type(x)是字符串,Type(y)是数值,返回ToNumber(x) == y的结果。

      8.如果Type(x)是布尔值,返回ToNumber(x) == y的结果。

      9.如果Type(y)是布尔值,返回x == ToNumber(y)的结果。

      10.如果Type(x)是字符串或数值或Symbol值,Type(y)是对象,返回x == ToPrimitive(y)的结果。

      11.如果Type(x)是对象,Type(y)是字符串或数值或Symbol值,返回ToPrimitive(x) == y的结果。

      12.返回false。

    由于0的类型是数值,null的类型是 Null(这是规格4.3.13 小节的规定,是内部 Type 运算的结果,跟typeof运算符无关)。因此上面的前 11 步都得不到结果,要到第 12 步才能得到false。

    0 == null // false
    

    24.5 数组的空位

    const a1 = [undefined, undefined, undefined];
    const a2 = [, , ,];
    
    a1.length // 3
    a2.length // 3
    
    a1[0] // undefined
    a2[0] // undefined
    
    a1[0] === a2[0] // true
    

    上面代码中,数组a1的成员是三个undefined,数组a2的成员是三个空位。这两个数组很相似,长度都是 3,每个位置的成员读取出来都是undefined。

    但是,它们实际上存在重大差异。

    0 in a1 // true
    0 in a2 // false
    
    a1.hasOwnProperty(0) // true
    a2.hasOwnProperty(0) // false
    
    Object.keys(a1) // ["0", "1", "2"]
    Object.keys(a2) // []
    
    a1.map(n => 1) // [1, 1, 1]
    a2.map(n => 1) // [, , ,]
    

    上面代码一共列出了四种运算,数组a1和a2的结果都不一样。前三种运算(in运算符、数组的hasOwnProperty方法、Object.keys方法)都说明,数组a2取不到属性名。最后一种运算(数组的map方法)说明,数组a2没有发生遍历。

    为什么a1与a2成员的行为不一致?数组的成员是undefined或空位,到底有什么不同?

    规格的12.2.5 小节《数组的初始化》给出了答案。

      “Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an AssignmentExpression (i.e., a comma at the beginning or after another comma), the missing array element contributes to the length of the Array and increases the index of subsequent elements. Elided array elements are not defined. If an element is elided at the end of an array, that element does not contribute to the length of the Array.”

    翻译如下。

      "数组成员可以省略。只要逗号前面没有任何表达式,数组的length属性就会加 1,并且相应增加其后成员的位置索引。被省略的成员不会被定义。如果被省略的成员是数组最后一个成员,则不会导致数组length属性增加。”

    上面的规格说得很清楚,数组的空位会反映在length属性,也就是说空位有自己的位置,但是这个位置的值是未定义,即这个值是不存在的。如果一定要读取,结果就是undefined(因为undefined在 JavaScript 语言中表示不存在)。

    这就解释了为什么in运算符、数组的hasOwnProperty方法、Object.keys方法,都取不到空位的属性名。因为这个属性名根本就不存在,规格里面没说要为空位分配属性名(位置索引),只说要为下一个元素的位置索引加 1。

    至于为什么数组的map方法会跳过空位,请看下一节。

    24.6 数组的 map 方法

    规格的22.1.3.15 小节定义了数组的map方法。该小节先是总体描述map方法的行为,里面没有提到数组空位。

    后面的算法描述是这样的。

    1. Let O be ToObject(this value).
    2. ReturnIfAbrupt(O).
    3. Let len be ToLength(Get(O, "length")).
    4. ReturnIfAbrupt(len).
    5. If IsCallable(callbackfn) is false, throw a TypeError exception.
    6. If thisArg was supplied, let T be thisArg; else let T be undefined.
    7. Let A be ArraySpeciesCreate(O, len).
    8. ReturnIfAbrupt(A).
    9. Let k be 0.
    10. Repeat, while k < len
    11. Let Pk be ToString(k).
    12. Let kPresent be HasProperty(O, Pk).
    13. ReturnIfAbrupt(kPresent).
    14. If kPresent is true, then
    15. Let kValue be Get(O, Pk).
    16. ReturnIfAbrupt(kValue).
    17. Let mappedValue be Call(callbackfn, T, «kValue, k, O»).
    18. ReturnIfAbrupt(mappedValue).
    19. Let status be CreateDataPropertyOrThrow (A, Pk, mappedValue).
    20. ReturnIfAbrupt(status).
    21. Increase k by 1.
    22. Return A.

    翻译如下。

    1. 得到当前数组的this对象
    2. 如果报错就返回
    3. 求出当前数组的length属性
    4. 如果报错就返回
    5. 如果 map 方法的参数callbackfn不可执行,就报错
    6. 如果 map 方法的参数之中,指定了this,就让T等于该参数,否则T为undefined
    7. 生成一个新的数组A,跟当前数组的length属性保持一致
    8. 如果报错就返回
    9. 设定k等于 0
    10. 只要k小于当前数组的length属性,就重复下面步骤
    11. 设定Pk等于ToString(k),即将K转为字符串
    12. 设定kPresent等于HasProperty(O, Pk),即求当前数组有没有指定属性
    13. 如果报错就返回
    14. 如果kPresent等于true,则进行下面步骤
    15. 设定kValue等于Get(O, Pk),取出当前数组的指定属性
    16. 如果报错就返回
    17. 设定mappedValue等于Call(callbackfn, T, «kValue, k, O»),即执行回调函数
    18. 如果报错就返回
    19. 设定status等于CreateDataPropertyOrThrow (A, Pk, mappedValue),即将回调函数的值放入A数组的指定位置
    20. 如果报错就返回
    21. k增加 1
    22. 返回A

    仔细查看上面的算法,可以发现,当处理一个全是空位的数组时,前面步骤都没有问题。进入第 10 步中第 2 步时,kPresent会报错,因为空位对应的属性名,对于数组来说是不存在的,因此就会返回,不会进行后面的步骤。

    const arr = [, , ,];
    arr.map(n => {
      console.log(n);
      return 1;
    }) // [, , ,]
    

    上面代码中,arr是一个全是空位的数组,map方法遍历成员时,发现是空位,就直接跳过,不会进入回调函数。因此,回调函数里面的console.log语句根本不会执行,整个map方法返回一个全是空位的新数组。

    V8 引擎对map方法的实现如下,可以看到跟规格的算法描述完全一致。

    function ArrayMap(f, receiver) {
      CHECK_OBJECT_COERCIBLE(this, "Array.prototype.map");
    
      // Pull out the length so that modifications to the length in the
      // loop will not affect the looping and side effects are visible.
      var array = TO_OBJECT(this);
      var length = TO_LENGTH_OR_UINT32(array.length);
      return InnerArrayMap(f, receiver, array, length);
    }
    
    function InnerArrayMap(f, receiver, array, length) {
      if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
    
      var accumulator = new InternalArray(length);
      var is_array = IS_ARRAY(array);
      var stepping = DEBUG_IS_STEPPING(f);
      for (var i = 0; i < length; i++) {
        if (HAS_INDEX(array, i, is_array)) {
          var element = array[i];
          // Prepare break slots for debugger step in.
          if (stepping) %DebugPrepareStepInIfStepping(f);
          accumulator[i] = %_Call(f, receiver, element, i, array);
        }
      }
      var result = new GlobalArray();
      %MoveArrayContents(accumulator, result);
      return result;
    }
    

    25 ArrayBuffer <a id = "ArrayBuffer"></a>

    相关文章

      网友评论

        本文标题:ES6笔记

        本文链接:https://www.haomeiwen.com/subject/ydfiyftx.html