【JavaScript】《JavaScript高级程序设计 (第4版) 》笔记-附录A-ES2018 和 ES2019

红宝书《JavaScript高级程序设计(第5版)》学习大纲 《JavaScript高级程序设计(第5版)》是JavaScript领域的经典“红宝书”,它从基础语法讲到高级特性,还包含浏览器环境和前端工程化等内容。本书2024年12月出版,我将用通俗易懂的方式,把书中的知识点一一介绍出来。搭配书本一起看,效果会更好! 阅读详情
附录A、ES2018 和 ES2019
  1. ES2018 和 ES2019

    • 从 ECMAScript 2015 开始,TC39 委员会改为每年发布一版新 ECMAScript 规范。这样各个提案可以独立发展,每年所有达到成熟阶段的提案会被打包发布到新一版标准中。不过,打包多少特性并不重要,主要取决于浏览器厂商实现的情况。一旦提案进入第 4 阶段(stage 4),其内容就不会更改,并通常会包含在下一版 ECMAScript 规范中,浏览器就会着手根据自己的计划实现提案的特性。
    • ECMAScript 2018 于 2018 年 1 月完成,主要增加了异步迭代、剩余和扩展操作符、正则表达式和期约等方面的特性。可以通过 TC39 委员会的 GitHub 仓库了解规范的最新动态。
    • 注意,本附录中介绍的特性相对较新,往往只有新近版本的浏览器才支持。使用这些特性之前,请参考 Can I Use 网站确定支持相应特性的浏览器及其版本。
  2. 异步迭代

    • 在 ECMAScript 最近发布的几个版本中,异步执行和迭代器协议是两个极其热门的主题。异步执行用于释放对执行线程的控制以执行慢操作和收回控制,而迭代器协议则涉及为任意对象定义规范顺序。异步迭代只是这两个概念在逻辑上的统一。
    • 同步迭代器在每次调用 next()时都会返回{ value, done }对象。当然,这要求确定这个对象内容的计算和资源获取在 next()调用退出时必须完成,否则这些值就无法确定。在使用同步迭代器迭代异步确定的值时,主执行线程会被阻塞,以等待异步操作完成。
    • 有了异步迭代器,这个问题就迎刃而解了。异步迭代器在每次调用 next()时会提供解决为{ value, done }对象的期约。这样,执行线程可以释放并在当前这步循环完成之前执行其他任务。
  3. 创建并使用异步迭代器

    • 要理解异步迭代器,最简单的办法是用它跟同步迭代器进行比较。下面代码中创建了一个简单的Emitter 类,该类包含一个同步生成器函数,该函数会产生一个同步迭代器,同步迭代器输出 0~4:
      class Emitter { 
          constructor(max) { 
              this.max = max; 
              this.syncIdx = 0; 
          } 
          *[Symbol.iterator]() { 
              while(this.syncIdx < this.max) { 
                  yield this.syncIdx++;
              } 
          } 
      } 
      const emitter = new Emitter(5); 
      function syncCount() { 
          const syncCounter = emitter[Symbol.iterator](); 
          for (const x of syncCounter) { 
              console.log(x); 
          } 
      } 
      syncCount(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4
      
    • 这个例子之所以可以运行起来,主要是因为迭代器可以立即产生下一个值。假如你不想在确定下一个产生的值时阻塞主线程执行,也可以定义异步迭代器函数,让它产生期约包装的值。
    • 为此,要使用迭代器和生成器的异步版本。ECMAScript 2018 为此定义了 Symbol.asyncIterator,以便定义和调用输出期约的生成器函数。同时,这一版规范还为异步迭代器增加了 for-await-of 循环,用于使用异步迭代器。
    • 相应地,前面的例子可以扩展为同时支持同步和异步迭代:
      class Emitter { 
          constructor(max) { 
              this.max = max; 
              this.syncIdx = 0; 
              this.asyncIdx = 0; 
          } 
          *[Symbol.iterator]() { 
              while(this.syncIdx < this.max) { 
                  yield this.syncIdx++; 
              } 
          } 
          async *[Symbol.asyncIterator]() { 
              // *[Symbol.asyncIterator]() { 
                  while(this.asyncIdx < this.max) { 
                      // yield new Promise((resolve) => resolve(this.asyncIdx++)); 
                      yield this.asyncIdx++ 
                  } 
              } 
          } 
          const emitter = new Emitter(5); 
          function syncCount() { 
              const syncCounter = emitter[Symbol.iterator](); 
              for (const x of syncCounter) { 
                  console.log(x);
              } 
          } 
          async function asyncCount() { 
              const asyncCounter = emitter[Symbol.asyncIterator](); 
              for await(const x of asyncCounter) { 
                  console.log(x); 
              } 
          }
      } 
      syncCount(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4 
      asyncCount(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4
      
    • 为了加深理解,可以把前面例子中的同步生成器传给 for-await-of 循环:
      const emitter = new Emitter(5); 
          async function asyncIteratorSyncCount() { 
          const syncCounter = emitter[Symbol.iterator](); 
          for await(const x of syncCounter) { 
              console.log(x); 
          } 
      } 
      asyncIteratorSyncCount(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4
      
    • 虽然这里迭代的是同步生成器产生的原始值,但 for-await-of 循环仍像它们被包装在期约中一样处理它们。这说明 for-await-of 循环可以流畅地处理同步和异步可迭代对象。但是常规 for 循环就不能处理异步迭代器了:
      function syncIteratorAsyncCount() { 
          const asyncCounter = emitter[Symbol.asyncIterator](); 
          for (const x of asyncCounter) { 
              console.log(x); 
          } 
      } 
      syncIteratorAsyncCount(); 
      // TypeError: asyncCounter is not iterable
      
    • 关于异步迭代器,要理解的非常重要的一个概念是 Symbol.asyncIterator 符号不会改变生成器函数的行为或者消费生成器的方式。注意在前面的例子中,生成器函数加上了 async 修饰符成为异步函数,又加上了星号成为生成器函数。Symbol.asyncIterator 在这里只起一个提示的作用,告诉将来消费这个迭代器的外部结构如 for-await-of 循环,这个迭代器会返回期约对象的序列。
  4. 理解异步迭代器队列

    • 当然,前面的例子是假想的,因为迭代器返回的期约都会立即解决,所以跟同步迭代器的区别很难看出来。想象一下迭代器返回的期约会在不确定的时间解决,而且它们返回的顺序是乱的。异步迭代器应该尽可能模拟同步迭代器,包括每次迭代时代码的按顺序执行。为此,异步迭代器会维护一个回调队列,以保证早期值的迭代器处理程序总是会在处理晚期值之前完成,即使后面的值早于之前的值解决。
    • 为验证这一点,下面的例子中的异步迭代器以随机时长返回期约。异步迭代队列可以保证期约解决的顺序不会干扰迭代顺序。结果应该按顺序打印一组整数(但间隔时间随机):
      class Emitter { 
          constructor(max) { 
              this.max = max; 
              this.syncIdx = 0; 
              this.asyncIdx = 0; 
          } 
          *[Symbol.iterator]() { 
              while(this.syncIdx < this.max) { 
                  yield this.syncIdx++; 
              } 
          } 
          async *[Symbol.asyncIterator]() { 
              while(this.asyncIdx < this.max) { 
                  yield new Promise((resolve) => { 
                      setTimeout(() => { 
                          resolve(this.asyncIdx++); 
                      }, Math.floor(Math.random() * 1000)); 
                  }); 
              } 
          } 
      } 
      const emitter = new Emitter(5); 
      function syncCount() { 
          const syncCounter = emitter[Symbol.iterator](); 
          for (const x of syncCounter) { 
              console.log(x); 
          } 
      } 
      async function asyncCount() { 
          const asyncCounter = emitter[Symbol.asyncIterator](); 
          for await(const x of asyncCounter) { 
              console.log(x); 
          }
      } 
      syncCount(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4 
      asyncCount(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4
      
  5. 处理异步迭代器的 reject()

    • 因为异步迭代器使用期约来包装返回值,所以必须考虑某个期约被拒绝的情况。由于异步迭代会按顺序完成,而在循环中跳过被拒绝的期间是不合理的。因此,被拒绝的期约会强制退出迭代器:
      class Emitter { 
          constructor(max) { 
              this.max = max; 
              this.asyncIdx = 0; 
          } 
          async *[Symbol.asyncIterator]() { 
              while (this.asyncIdx < this.max) { 
                  if (this.asyncIdx < 3) { 
                      yield this.asyncIdx++; 
                  } else { 
                      throw 'Exited loop'; 
                  } 
              } 
          } 
      } 
      const emitter = new Emitter(5); 
      async function asyncCount() { 
          const asyncCounter = emitter[Symbol.asyncIterator](); 
          for await (const x of asyncCounter) { 
              console.log(x); 
          } 
      } 
      asyncCount(); 
      // 0 
      // 1 
      // 2 
      // Uncaught (in promise) Exited loop
      
  6. 使用 next()手动异步迭代

    • for-await-of 循环提供了两个有用的特性:一是利用异步迭代器队列保证按顺序执行,二是隐藏异步迭代器的期约。不过,使用这个循环会隐藏很多底层行为。
    • 因为异步迭代器仍遵守迭代器协议,所以可以使用 next()逐个遍历异步可迭代对象。如前所述,next()返回的值会包含一个期约,该期约可解决为{ value, done }这样的迭代结果。这意味着必须使用期约 API 获取方法,同时也意味着可以不使用异步迭代器队列。
      const emitter = new Emitter(5); 
      const asyncCounter = emitter[Symbol.asyncIterator](); 
      console.log(asyncCounter.next()); 
      // Promise<{value, done}>
      
  7. 顶级异步循环

    • 一般来说,包括 for-await-of 循环在内的异步行为不能出现在异步函数外部。不过,有时候可能确实需要在这样的上下文使用异步行为。为此可以通过创建异步 IIFE 来达到目的:
      class Emitter { 
          constructor(max) { 
              this.max = max; 
              this.asyncIdx = 0; 
          } 
          async *[Symbol.asyncIterator]() { 
              while(this.asyncIdx < this.max) { 
                  yield new Promise((resolve) => resolve(this.asyncIdx++)); 
              } 
          } 
      } 
      const emitter = new Emitter(5); 
      (async function() { 
          const asyncCounter = emitter[Symbol.asyncIterator](); 
          for await(const x of asyncCounter) { 
              console.log(x); 
          } 
      })(); 
      // 0 
      // 1 
      // 2 
      // 3 
      // 4
      
  8. 实现可观察对象

    • 异步迭代器可以耐心等待下一次迭代而不会导致计算成本,那么这也为实现可观察对象(Observable)接口提供了可能。总体上看,这涉及捕获事件,将它们封装在期约中,然后把这些事件提供给迭代器,而处理程序可以利用这些异步迭代器。在某个事件触发时,异步迭代器的下一个期约会解决为该事件。
    • 注意,可观察对象的话题超出了本书范围,因为它们很大程度上是作为第三方库实现的。有兴趣的读者可以了解一下非常流行的 RxJS 库。
    • 下面这个简单的例子会捕获浏览器事件的可观察流。这需要一个期约的队列,每个期约对应一个事件。该队列也会保持事件生成的顺序,对这种问题来说保持顺序也是合理的。
      class Observable { 
          constructor() { 
              this.promiseQueue = []; 
              // 保存用于解决队列中下一个期约的程序
              this.resolve = null; 
              // 把最初的期约推到队列
              // 该期约会解决为第一个观察到的事件
              this.enqueue(); 
          } 
          // 创建新期约,保存其解决方法
          // 再把它保存到队列中
          enqueue() { 
              this.promiseQueue.push( 
              new Promise((resolve) => this.resolve = resolve)); 
          } 
          // 从队列前端移除期约
          // 并返回它
          dequeue() { 
              return this.promiseQueue.shift(); 
          } 
      }
      
    • 要利用这个期约队列,可以在这个类上定义一个异步生成器方法。该生成器可用于任何类型的事件:
      class Observable { 
          constructor() { 
              this.promiseQueue = []; 
              // 保存用于解决队列中下一个期约的程序
              this.resolve = null; 
              // 把最初的期约推到队列
              // 该期约会解决为第一个观察到的事件
              this.enqueue(); 
          } 
          // 创建新期约,保存其解决方法
          // 再把它保存到队列中
          enqueue() { 
              this.promiseQueue.push( 
              new Promise((resolve) => this.resolve = resolve)); 
          } 
          // 从队列前端移除期约
          // 并返回它
          dequeue() { 
              return this.promiseQueue.shift(); 
          } 
          async *fromEvent (element, eventType) { 
              // 在有事件生成时,用事件对象来解决队列头部的期约
              // 同时把另一个期约加入队列
              element.addEventListener(eventType, (event) => { 
                  this.resolve(event); 
                  this.enqueue(); 
              }); 
              // 每次解决队列前面的期约
              // 都会向异步迭代器返回相应的事件对象
              while (1) { 
                  yield await this.dequeue(); 
              } 
          } 
      }
      
    • 这样,这个类就定义完了。接下来在 DOM 元素上定义可观察对象就很简单了。假设页面上有一个<button>元素,可以像下面这样捕获该按钮上的一系列 click 事件,然后在控制台把它们打印出来:
      class Observable { 
          constructor() { 
              this.promiseQueue = []; 
              // 保存用于解决队列中下一个期约的程序
              this.resolve = null; 
              // 把最初的期约推到队列
              // 该期约会解决为第一个观察到的事件
              this.enqueue(); 
          } 
          // 创建新期约,保存其解决方法
          // 再把它保存到队列中
          enqueue() { 
              this.promiseQueue.push( 
              new Promise((resolve) => this.resolve = resolve)); 
          } 
          // 从队列前端移除期约
          // 并返回它
          dequeue() { 
              return this.promiseQueue.shift(); 
          } 
          async *fromEvent (element, eventType) { 
              // 在有事件生成时,用事件对象来解决 队列头部的期约
              // 同时把另一个期约加入队列
              element.addEventListener(eventType, (event) => { 
                  this.resolve(event); 
                  this.enqueue(); 
              }); 
              // 每次解决队列前面的期约
              // 都会向异步迭代器返回相应的事件对象
              while (1) { 
                  yield await this.dequeue(); 
              } 
          } 
      } 
      (async function() { 
      const observable = new Observable(); 
      const button = document.querySelector('button'); 
      const mouseClickIterator = observable.fromEvent(button, 'click'); 
      for await (const clickEvent of mouseClickIterator) { 
          console.log(clickEvent); 
      } 
      })();
      
  9. 对象字面量的剩余操作符和扩展操作符

    • ECMAScript 2018 将数组中的剩余操作符和扩展操作符也移植到了对象字面量。这极大地方便了对象合并和通过其他对象创建新对象。
  10. 剩余操作符

    • 剩余操作符可以在解构对象时将所有剩下未指定的可枚举属性收集到一个对象中。比如:
      const person = { name: 'Matt', age: 27, job: 'Engineer' }; 
      const { name, ...remainingData } = person; 
      console.log(name); // Matt 
      console.log(remainingData); // { age: 27, job: 'Engineer' }
      
    • 每个对象字面量中最多可以使用一次剩余操作符,而且必须放在最后。因为每个对象字面量只能有一个剩余操作符,所以可以嵌套剩余操作符。嵌套时,因为子属性对应的剩余操作符没有歧义,所以返回对象的内容不会重叠:
      const person = { name: 'Matt', age: 27, job: { title: 'Engineer', level: 10 } }; 
      const { name, job: { title, ...remainingJobData }, ...remainingPersonData } = person; 
      console.log(name); // Matt 
      console.log(title); // Engineer 
      console.log(remainingPersonData); // { age: 27 } 
      console.log(remainingJobData); // { level: 10 } 
      const { ...a, job } = person; 
      // SyntaxError: Rest element must be last element 
      
    • 剩余操作符在对象间执行浅复制,因此会复制对象的引用而不会克隆整个对象:
      const person = { name: 'Matt', age: 27, job: { title: 'Engineer', level: 10 } }; 
      const { ...remainingData } = person; 
      console.log(person === remainingData); // false 
      console.log(person.job === remainingData.job); // true
      
    • 剩余操作符会复制所有自有可枚举属性,包括符号:
      const s = Symbol(); 
      const foo = { a: 1, [s]: 2, b: 3 } 
      const {a, ...remainingData} = foo; 
      console.log(remainingData); 
      // { b: 3, Symbol(): 2 }
      
  11. 扩展操作符

    • 扩展操作符可以像拼接数组一样合并两个对象。应用到内部对象的扩展操作符会对所有自有可枚举属性执行浅复制到外部对象,包括符号:
      const s = Symbol(); 
      const foo = { a: 1 }; 
      const bar = { [s]: 2 }; 
      const foobar = {...foo, c: 3, ...bar}; 
      console.log(foobar); 
      // { a: 1, c: 3 Symbol(): 2 }
      
    • 扩展对象的顺序很重要,主要有两个原因。
      • (1) 对象跟踪插入顺序。从扩展对象复制的属性按照它们在对象字面量中列出的顺序插入。
      • (2) 对象会覆盖重名属性。在出现重名属性时,会使用后出现属性的值。
    • 下面的例子演示了上述约定:
      const foo = { a: 1 }; 
      const bar = { b: 2 }; 
      const foobar = {c: 3, ...bar, ...foo}; 
      console.log(foobar); 
      // { c: 3, b: 2, a: 1 } 
      const baz = { c: 4 }; 
      const foobarbaz = {...foo, ...bar, c: 3, ...baz}; 
      console.log(foobarbaz); 
      // { a: 1, b: 2, c: 4 }
      
    • 与剩余操作符一样,所有复制都是浅复制:
      const foo = { a: 1 }; 
      const bar = { b: 2, c: { d: 3 } }; 
      const foobar = {...foo, ...bar}; 
      console.log(foobar.c === bar.c); // true
      
  12. Promise.prototype.finally()

    • 以前,只能使用不太好看的方式处理期约退出“待定”状态,而不管后续状态如何。换句话说,通常需要重复利用处理程序:
      let resolveA, rejectB; 
      function finalHandler() { 
          console.log('finished'); 
      } 
      function resolveHandler(val) { 
          console.log('resolved'); 
          finalHandler(); 
      } 
      function rejectHandler(err) { 
          console.log('rejected'); 
          finalHandler(); 
      } 
      new Promise((resolve, reject) => { 
          resolveA = resolve; 
      }) 
      .then(resolveHandler, rejectHandler); 
      
      new Promise((resolve, reject) => { 
          rejectB = reject; 
      }) 
      .then(resolveHandler, rejectHandler); 
      resolveA(); 
      rejectB(); 
      // resolved 
      // finished 
      // rejected 
      // finished
      
    • 有了 Promise.prototype.finally(),就可以统一共享的处理程序。finally()处理程序不传递任何参数,也不知道自己处理的期约是解决的还是拒绝的。前面的代码可以重构为如下形式:
      let resolveA, rejectB; 
      function finalHandler() { 
          console.log('finished'); 
      } 
      function resolveHandler(val) { 
          console.log('resolved'); 
      } 
      function rejectHandler(err) { 
          console.log('rejected'); 
      } 
      new Promise((resolve, reject) => { 
          resolveA = resolve; 
      }) 
      .then(resolveHandler, rejectHandler) 
      .finally(finalHandler);
      new Promise((resolve, reject) => { 
          rejectB = reject; 
      }) 
      .then(resolveHandler, rejectHandler) 
      .finally(finalHandler); 
      resolveA(); 
      rejectB(); 
      // resolved 
      // rejected 
      // finished 
      // finished
      
    • 注意日志的顺序不一样了。每个 finally()都会创建一个新期约实例,而这个新期约会添加到浏览器的微任务队列,只有前面的处理程序执行完成才会解决。
  13. 正则表达式相关特性

    • ECMAScript 2018 为正则表达式增加了一些特性。
  14. dotAll 标志

    • 正则表达式中用于匹配任意字符的点(.)不匹配换行符,比如\n 和\r 或非 BMP 字符,如表情符号。
      const text = ` 
      foo 
      bar 
      `; 
      const re = /foo.bar/; 
      console.log(re.test(text)); // false
      
    • 为此,规范新增了 s 标志(意思是单行,singleline),从而解决了这个问题:
      const text = ` 
      foo 
      bar 
      `; 
      const re = /foo.bar/s; 
      console.log(re.test(text)); // true
      
  15. 向后查找断言

    • 正则表达式支持肯定式向前查找断言和否定式向前查找断言,可以匹配后跟指定字符串的表达式:
      const text = 'foobar'; 
      // 肯定式向前查找
      // 断言后跟某个值,但不捕获该值
      const rePositiveMatch = /foo(?=bar)/; 
      const rePositiveNoMatch = /foo(?=baz)/;
      console.log(rePositiveMatch.exec(text)); 
      // ["foo"] 
      console.log(rePositiveNoMatch.exec(text)); 
      // null 
      // 否定式向前查找
      // 断言后面不是某个值,但不捕获该值
      const reNegativeNoMatch = /foo(?!bar)/; 
      const reNegativeMatch = /foo(?!baz)/; 
      console.log(reNegativeNoMatch.exec(text)); 
      // null 
      console.log(reNegativeMatch.exec(text)); 
      // ["foo"]
      
    • 规范相应地增加了与这些断言对应的肯定式向后查找和否定式向后查找。向后查找与向前查找的工作原理类似,只是会检测要捕获内容之前的内容。
      const text = 'foobar'; 
      // 肯定式向后查找
      // 断言前面是某个值,但不捕获该值
      const rePositiveMatch = /(?<=foo)bar/; 
      const rePositiveNoMatch = /(?<=baz)bar/; 
      console.log(rePositiveMatch.exec(text)); 
      // ["bar"] 
      console.log(rePositiveNoMatch.exec(text)); 
      // null 
      // 否定式向后查找
      // 断言前面不是某个值,但不捕获该值
      const reNegativeNoMatch = /(?<!foo)bar/; 
      const reNegativeMatch = /(?<!baz)bar/; 
      console.log(reNegativeNoMatch.exec(text)); 
      // null 
      console.log(reNegativeMatch.exec(text)); 
      // ["bar"]
      
  16. 命名捕获组

    • 多个捕获组通常是按索引来取值的,但索引没有上下文,反映不出它们包含的是什么内容:
      const text = '2018-03-14'; 
      const re = /(\d+)-(\d+)-(\d+)/; 
      console.log(re.exec(text)); 
      // ["2018-03-14", "2018", "03", "14"]
      
    • 为此,规范支持将捕获组与有效 JavaScript 标识符关联,这样就可以通过标识符获取捕获组的内容:
      const text = '2018-03-14'; 
      const re = /(?<year>\d+)-(?<month>\d+)-(?<day>\d+)/; 
      console.log(re.exec(text).groups); 
      // { year: "2018", month: "03", day: "14" }
      
  17. Unicode 属性转义

    • Unicode 标准为每个字符都定义了属性。字符属性,涉及字符名称、类别、空格指示和字符内部定义的脚本或语言等。通过使用 Unicode 属性转义可以在正则表达式中使用这些属性。
    • 有些属性是二进制,意味可以独立使用。比如 Uppercase 和 White_Space。有些属性是键/值对,即一个属性对应一个属性值。比如 Script_Extensions=Greek。
    • Unicode 属性列表及属性值列表参见 Unicode 网站。
    • Unicode 属性转义在正则表达式中可使用\p 表示匹配,使用\P 表示不匹配:
      const pi = String.fromCharCode(0x03C0); 
      const linereturn = ` 
      `; 
      const reWhiteSpace = /\p{White_Space}/u; 
      const reGreek = /\p{Script_Extensions=Greek}/u; 
      const reNotWhiteSpace = /\P{White_Space}/u; 
      const reNotGreek = /\P{Script_Extensions=Greek}/u; 
      console.log(reWhiteSpace.test(pi)); // false 
      console.log(reWhiteSpace.test(linereturn)); // true 
      console.log(reNotWhiteSpace.test(pi)); // true 
      console.log(reNotWhiteSpace.test(linereturn)); // false 
      console.log(reGreek.test(pi)); // true 
      console.log(reGreek.test(linereturn)); // false 
      console.log(reNotGreek.test(pi)); // false 
      console.log(reNotGreek.test(linereturn)); // true
      
  18. 数组打平方法

    • ECMAScript 2019 在 Array.prototype 上增加了两个方法:flat()和 flatMap()。这两个方法为打平数组提供了便利。如果没有这两个方法,则打平数组就要使用迭代或递归。
    • 注意,flat()和 flatMap()只能用于打平嵌套数组。嵌套的可迭代对象如 Map 和 Set不能打平。
  19. Array.prototype.flatten()

    • 下面是如果没有这两个新方法要打平数组的一个示例实现:
      function flatten(sourceArray, flattenedArray = []) { 
          for (const element of sourceArray) { 
              if (Array.isArray(element)) {
                  flatten(element, flattenedArray); 
              } else { 
      		    flattenedArray.push(element); 
              } 
          } 
          return flattenedArray; 
      } 
      const arr = [[0], 1, 2, [3, [4, 5]], 6]; 
      console.log(flatten(arr)) 
      // [0, 1, 2, 3, 4, 5, 6]
      
    • 这个例子在很多方面像一个树形数据结构:数组中每个元素都像一个子节点,非数组元素是叶节点。因此,这个例子中的输入数组是一个高度为 2 有 7 个叶节点的树。打平这个数组本质上是对叶节点的按序遍历。
    • 有时候如果能指定打平到第几级嵌套是很有用的。比如下面这个例子,它重写了上面的版本,允许指定要打平几级:
      function flatten(sourceArray, depth, flattenedArray = []) { 
          for (const element of sourceArray) { 
              if (Array.isArray(element) && depth > 0) { 
                  flatten(element, depth - 1, flattenedArray); 
              } else { 
                  flattenedArray.push(element); 
              } 
          } 
          return flattenedArray; 
      } 
      const arr = [[0], 1, 2, [3, [4, 5]], 6]; 
      console.log(flatten(arr, 1)); 
      // [0, 1, 2, 3, [4, 5], 6]
      
    • 为了解决上述问题,规范增加了 Array.prototype.flat()方法。该方法接收 depth 参数(默认值为 1),返回一个对要打平 Array 实例的浅复制副本。下面看几个例子:
      const arr = [[0], 1, 2, [3, [4, 5]], 6]; 
      console.log(arr.flat(2)); 
      // [0, 1, 2, 3, 4, 5, 6] 
      console.log(arr.flat()); 
      // [0, 1, 2, 3, [4, 5], 6]
      
    • 因为是执行浅复制,所以包含循环引用的数组在被打平时会从源数组复制值:
      const arr = [[0], 1, 2, [3, [4, 5]], 6]; 
      arr.push(arr); 
      console.log(arr.flat()); 
      // [0, 1, 2, 3, 4, 5, 6, [0], 1, 2, [3, [4, 5]], 6]
      
  20. Array.prototype.flatMap()

    • Array.prototype.flatMap()方法会在打平数组之前执行一次映射操作。在功能上,arr.flatMap(f)与 arr.map(f).flat()等价;但 arr.flatMap()更高效,因为浏览器只需要执行一次遍历。
    • flatMap()的函数签名与 map()相同。下面是一个简单的例子:
      const arr = [[1], [3], [5]]; 
      console.log(arr.map(([x]) => [x, x + 1])); 
      // [[1, 2], [3, 4], [5, 6]] 
      console.log(arr.flatMap(([x]) => [x, x + 1])); 
      // [1, 2, 3, 4, 5, 6]
      
    • flatMap()在非数组对象的方法返回数组时特别有用,例如字符串的 split()方法。来看下面的例子,该例子把一组输入字符串分割为单词,然后把这些单词拼接为一个单词数组:
      const arr = ['Lorem ipsum dolor sit amet,', 'consectetur adipiscing elit.']; 
      console.log(arr.flatMap((x) => x.split(/[\W+]/))); 
      // ["Lorem", "ipsum", "dolor", "sit", "amet", "", "consectetur", "adipiscing", 
      "elit", ""]
      
    • 对于上面的例子,可以利用空数组进一步过滤上一次映射后的结果,这也是一个数据处理技巧(虽然可能会有些性能损失)。下面的例子扩展了上面的例子,去掉了空字符串:
      const arr = ['Lorem ipsum dolor sit amet,', 'consectetur adipiscing elit.']; 
      console.log(arr.flatMap((x) => x.split(/[\W+]/)).flatMap((x) => x || [])); 
      // ["Lorem", "ipsum", "dolor", "sit", "amet", consectetur", "adipiscing", "elit"]
      
    • 这里,结果中的每个空字符串首先映射到一个空数组。在打平时,这些空数组就会因为没有内容而被忽略。
    • 注意,不建议使用这个技巧。这是因为过滤每个值都要构建一个立即丢弃的 Array 实例。
  21. Object.fromEntries()

    • ECMAScript 2019 又给 Object 类添加了一个静态方法 fromEntries(),用于通过键/值对数组的集合构建对象。这个方法执行与 Object.entries()方法相反的操作。来看下面的例子:
      const obj = { 
          foo: 'bar', 
          baz: 'qux' 
      }; 
      const objEntries = Object.entries(obj); 
      console.log(objEntries); 
      // [["foo", "bar"], ["baz", "qux"]] 
      console.log(Object.fromEntries(objEntries)); 
      // { foo: "bar", baz: "qux" }
      
    • 此静态方法接收一个可迭代对象参数,该可迭代对象可以包含任意数量的大小为 2 的可迭代对象。这个方法可以方便地将 Map 实例转换为 Object 实例,因为 Map 迭代器返回的结果与 fromEntries()的参数恰好匹配:
      const map = new Map().set('foo', 'bar'); 
      console.log(Object.fromEntries(map)); 
      // { foo: "bar" }
      
  22. 字符串修理方法

    • ECMAScript 2019 向 String.prototype 添加了两个新方法:trimStart() 和 trimEnd()。它们分别用于删除字符串开头和末尾的空格。这两个方法旨在取代之前的 trimLeft()和 trimRight(),因为后两个方法在从右往左书写的语言(如阿拉伯语和希伯来语)中有歧义。
    • 在只有一个空格的情况下,这两个方法相当于执行与 padStart()和 padEnd()相反的操作。下面的例子演示了使用这两个方法删除字符串前后的空格:
      let s = ' foo '; 
      console.log(s.trimStart()); // "foo " 
      console.log(s.trimEnd()); // " foo"
      
  23. Symbol.prototype.description

    • ECMAScript 2019在 Symbol.prototype 上增加了 description 属性,用于取得可选的符号描述。以前,只能通过将符号转型为字符串来取得这个描述:
      const s = Symbol('foo'); 
      console.log(s.toString()); 
      // Symbol(foo)
      
    • 这个原型属性是只读的,可以在实例上直接取得符号的描述。如果没有描述,则默认为 undefined。
      const s = Symbol('foo'); 
      console.log(s.description); 
      // foo
      
  24. 可选的 catch 绑定

    • 在 ECMAScript 2019 之前,try/catch 块的结构相当严格。即使不想使用捕获的错误对象,解析器也要求必须在 catch 子句中把该对象赋值给一个变量:
      try { 
          throw 'foo'; 
      } catch (e) {
          // 发生错误了,但你不想使用错误对象
      }
      
    • 在 ECMAScript 2019 中,可以省略这个赋值,并完全忽略错误:
      try { 
          throw 'foo'; 
      } catch { 
          // 发生错误了,但你不想使用错误对象
      }
      
  25. 其他新增内容

    • ES2019 还对现有 API 进行了其他一些调整。
      • Array.prototype.sort()稳定了,意味着相同的对象在输出中不会被重新排序。
      • 由于单独的 UTF-16 代理对字符不能使用 UTF-8 编码,JSON.stringify() 在 ES2019 以前会返回 UTF-16 码元,现在则改为返回转义序列,也是有效的 Unicode。
      • ES2019 以前,U+2028 LINE SEPARATOR 和 U+2029 PARAGRAPH SEPARATOR 在 JSON 字符串中都有效,但在 ECMAScript 字符串中则无效。ES2019 实现了 ECMAScript 字符串与 JSON 字符串的兼容。
      • ES2019 以前,浏览器厂商可以自由决定 Function.prototype.toString()返回什么。ES2019要求这个方法尽可能返回函数的源代码,否则返回{ [native code] }。
《JavaScript高级程序设计》读书笔记 28 《JavaScript高级程序设计》读书笔记 28 - 迭代器 阅读详情

相关推荐

《JavaScript高级程序设计》读书笔记 18

《JavaScript高级程序设计》读书笔记 18 - 引用类型之Date类型

qq_34911907的博客 1167

ECMAScript 2019(ES10 或 ES2019)新的特性

ECMAScript 2019(ES10 或 ES2019)引入了一些新的特性,下面我们详细探讨这些新特性,并给出相应的示例代码。

大剑师兰特的GIS世界 1346

《JavaScript高级程序设计》读书笔记 01

《JavaScript高级程序设计》读书笔记-01

qq_34911907的博客 860

ES2019 重点总结

1.Array.prototype.flat() Array.prototype.flat()用于将嵌套的数组“拉平”,变成一维的数组。该方法返回一个新数组,对原数据没有影响。flat(depth),flat()默认只会“拉平”一层,如果想要“拉平”多层的嵌套数组,可以将flat()方法的参数写成一个整数,表示想要拉平的层数,depth默认为1。 const arr1 = [1, 2, [3, 4]]; arr1.flat(); // [1, 2, 3, 4] const arr2 = [1, 2, [3

qq_39852145的博客 365

实验六 存储器实验

只读存储器(ROM)是一种在正常工作时其存储的数据固定不变,其中的数据只能读出,不能写入,即使断电也能够保留数据,要想在只读存储器中存入或改变数据,必须具备特定的条件。当地址为00000101时,会分别在数据位宽为8,16,32的只读寄存器中找到地址为00000101所对应的十进制地址位置,也就是地址为5的数据,并将其分别以8位,16位,32位输出。因此,输出保持为0。因此,当异步清零信号为1时,无论其他输入信号是什么,触发器的输出都会被强制清零,输出为0。1)寄存器输入0011,使能端1,异步清零0。

wenmou1111的博客 3008

Vivado 2018.3 安装步骤及 license 获取

本文的主要内容是介绍 Vivado 2018.3 版本的安装步骤及其 license 的获取与加载。

西岸贤 4万+

ECMAScript 2018(ES2018):异步编程与正则表达式的深度进化

发布时间:2018年6月,由ECMA International正式发布,标准编号为ECMA-262 9th Edition。

2301_76380626的博客 699

波束管理 Beam Management

Beam Management in 5G NR   波束管理,是5G NR中基于信道质量来动态选择每个UE和gNB之间以什么方向和频率的波束beam来进行通信。   背景   5G NR(New Radio)支持非常高的数据速率和更低的延迟。5G NR支持FR1和FR2频段,FR1为亚6 GHz(450至6000 MHz);FR2为毫米波段(24.25 GHz至52.6 GHz)。   由于毫米波频带使用非常高的频率,因此会导致传播损耗和其他损耗。为了补偿损失,在这种频率下定向通信是必不可少的。

最忆是江南的博客 5828

ES2019新特性你知道哪些?

编者按:本文译者奇舞团前端开发工程师刘冰晶。随着ES2019新增特性的发布,ECMAScript标准又迎来了更新。如今,这些特性已经可以用在node、Chrome、Fir...

奇舞周刊 2540

ADC实现模数转换Multisim电路仿真——硬件工程师笔记

8位模数转换器(ADC)是将模拟信号转换为8位数字信号的电子器件,具有256级量化能力。其工作原理分为采样、量化和编码三个阶段,关键参数包括分辨率、采样率、精度、线性度和信噪比。常见型号有ADC0804、ADC0808等,广泛应用于数据采集、音频处理、通信系统和消费电子产品中。典型应用时需要配置参考电压、模拟输入和数字输出引脚,并通过仿真实验验证转换效果(如-10V对应输出0,10V对应255)。硬件工程师需掌握其原理和参数选择,相关笔试面试资料可在优快云博客获取。

XU157303764的博客 1512

无法加载文件:C:\Users\Lenovo\AppData\Roaming\npm\cnpm.ps1,因为在此系统上禁止运行脚本编程

当您遇到类似于"无法加载文件:C:\Users\Lenovo\AppData\Roaming\npm\cnpm.ps1,因为在此系统上禁止运行脚本编程"的错误消息时,请按照上述步骤来解决问题。当您尝试加载文件C:\Users\Lenovo\AppData\Roaming\npm\cnpm.ps1时,可能会遇到类似于"无法加载文件:C:\Users\Lenovo\AppData\Roaming\npm\cnpm.ps1,因为在此系统上禁止运行脚本编程"的错误消息。请注意,更改执行策略可能会带来一些安全风险。

PixelInk的博客 1923

尝鲜 ES2019 的新功能

ECMAScript 每年都会发布一个新版本,其中的提案是已经正式通过的,并分发给开发者和用户。本文将讨论该语言的最新版本,以及它又具有了什么新功能。 ES10/ES2019 在本次更新中有很大的改进。它引入了一些新的函数和方法,使开发者能够编写更少的代码,并提高工作效率。

前端先锋 656

【头歌】链栈的基本操作及应用

另外,在算法的开始和结束时,栈都应该是空的,所以匹配到最后还要判断栈是否为空,若空,则说明匹配成功,返回1。其中表达式只包含三种括号,花括号{}、中括号[]、圆括号(),即它仅由 (、)、[、]、{、}六个字符组成。预期输出: 栈中元素依次为:12 47 5 8 6 92 45 63 75 38 4 29 弹出的栈顶元素 e=29 栈空否:0(1:空 0:否) 栈顶元素 e=4 栈的长度为11 清空栈后,栈空否:1(1:空 0:否)// 若栈不空,则用e返回S的栈顶元素,并返回OK;

qq_39977056的博客 4385

JavaScript高级程序设计 第4版(中文高清)扫描版

1. JavaScript组成 核心ECMAScript 文档对象模型DOM 浏览器对象模型BOM 1.2.1 ECMAScript 定义语言的基础 规定了语言的组成部分:语法、类型、语句、关键字、保留字、操作符、对象 js nodejs 都实现了ECMAScript 1.2.2 DOM 文档对象模型 Document Object Model 针对XML但经扩展用于HTML的应用程序编程接口(API) 把整个页面映射为多层节点结构,每个节点包含不同类型的数据。 借助DOM API,可删除,添加,替换,

bsegebr的博客 1万+

HyperLynx(三十一)高速串行总线仿真(三)

(5)选择 “File”→ “Open Touchstone”,打开路径 C:\Adv_HL_Tmg\SERDES_Interface\models,选中connector.s4p,单击打开,如图所示。接下来,找出将要分配模型的S参数连接。(12)单击“Assign”按钮,选择模型类型为“Touchstone models”,在库中选择“connector.s4p”,如图所示。(14)单击“OK”按钮,选中“connector.s4p”这一行,单击“Connection Editor”按钮,如图所示。

小幽余生不加糖 3368

从一只龙虾到一支团队:OpenClaw 单 Bot 多 Agent 配置实践

单 Bot 多 Agent只有一个对外的聊天入口(飞书 Bot)内部有多个独立的 AI Agent,各司其职主 Agent(总指挥)负责接收任务并分配给子 Agent子 Agent 完成任务后将结果返回给主 Agent角色Agent ID职责使用场景🎯 总指挥main-agent统筹协调,任务分发接收所有用户请求✍️ 笔杆子内容创作公众号、博客、小红书🔬 参谋canmou深度研究竞品分析、市场调研📋 运营官operations运营管理邮件、日历、社交媒体。

Maynor的博客 1084

javascript高级程序设计 javascript权威指南

这篇文章主要介绍了javascript高级程序设计 javascript权威指南,具有一定借鉴价值,需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获,下面让小编带着大家一起了解一下。

chatgpt001的博客 1241

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

你可能已经知道的 ES 2018 和 2019

本文首发于我的博客。 标准这事儿吧…… ES 2019(ES 10)标准于年前正式发布,借此机会,我们来看看都有哪些特性有幸转正吧。顺带把 ES 2018 的内容也补一下。 ECMAScript 标准的制定过程,自 2015 年大改,至今已经是第 5 个年头了,想必大家都心里有数了。与 Java 等语言不同,JS 并非先制定标准再开始使用,恰恰相反,是大家先用着,觉得合适的,才收录进标准。标准的存...

weixin_34293902的博客 988

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

JavaScript高级程序设计(第5版):扎实的基本功是唯一捷径

不论从事什么,真正的高手都是把基本功练到炉火纯青的人,只有熟悉每个细节,熟练每个动作,才能在情况多变的实战中如肌肉记忆般灵活应对,从容不迫。学习JavaScript的最佳书籍是什么,不论十年前还是现在,都会得到一个答案 —《JavaScript高级程序设计》(红宝书)。

灵感干货铺 1604

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

【JavaScript】《JavaScript高级程序设计 (第4版) 》笔记-附录C-JavaScript 库和框架

JavaScript 库和框架。

江湖人称菠萝包 1062

JavaScript 红宝书第4版上市啦!「文末送几本给大家」

文末有活动人的一生中总要读几本经典书,在这个“经典”泛滥的年代,什么才是权威的代表,我想大概是一本的书的口碑,能积累下上佳口碑的书,往往也是能经得住时间推敲的。比如这本:我相信所有前端开...

小生方勤 2938

【免费下载】 《JavaScript高级程序设计(第4版)》资源下载:深入探索JavaScript的必备指南

《JavaScript高级程序设计(第4版)》资源下载:深入探索JavaScript的必备指南 【下载地址】JavaScript高级程序设计第4版资源下载分享 JavaScript高级程序设计(第4版) 资源下载 项目地址: ht...

gitblog_06688的博客 745

【JavaScript】《JavaScript高级程序设计 (第4版) 》笔记-附录D-JavaScript 工具

Emscripten 与 LLVM。构建工具、自动化系统和任务运行器。编译/转译工具及静态类型系统。JavaScript 工具。

江湖人称菠萝包 1150

红宝书电子版_JavaScript 经典红宝书,几代前端人的入门选择

文末有活动人的一生中总要读几本经典书,在这个“经典”泛滥的年代,什么才是权威的代表,我想大概是一本的书的口碑,能积累下上佳口碑的书,往往也是能经得住时间推敲的。比如这本:我相信所有前端开发者的案头都有这样一本书。这本书最早的版本第 2 版可以追溯到 2010 年,有时候虽然觉得 2010 年离我们很近,但是却已经有十年之久了。这本书前前后后帮助几代前端人从入门到进阶,给大家留下不可磨灭的...

weixin_39724469的博客 2669

《JavaScript高级程序设计》阅读笔记 四

包含:第九章,第十章,第十二章 说两句:用块引用就是图好看。 说两句:随兴趣而来,期约与异步函数先放放。 ES6新增的代理和反射为开发者提供了拦截并向基本操作嵌入额外行为的能力。 代理基础 1.可以给目标对象定义一个关联的代理对象,而这个代理对象可以作为抽象的目标对象来使用。 2.代理通过Proxy构造函数创建,接受两个参数,目标对象和处理程序对象。 3.定义捕获器(trap)get 捕获器就是处理程序对象中定义的基本操作拦截器。 可以用get(目标对象,要查询的属性,代理对象)()捕获

加油呀 1148

《JavaScript 高级程序设计(第 4 版)》推荐

在 JavaScript 编程领域,若要挑选一本兼具深度与广度,能够全方位助力开发者提升技能的佳作,《JavaScript 高级程序设计(第 4 版)》无疑是不二之选。它犹如一座知识宝库,为 JavaScript 开发者打开了一扇通往深入学习与高效实践的大门。

Amon的专栏 692
上一篇: 【JavaScript】《JavaScript高级程序设计 (第4版) 》笔记-Chapter28-最佳实践
下一篇: 【JavaScript】《JavaScript高级程序设计 (第4版) 》笔记-附录B-严格模式
江湖人称菠萝包
博客等级 码龄10年 762粉丝 314原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值