一般来说，JavaScript 中对象的引用是_强引用_，这意味着只要你有对对象的引用，它就不会被垃圾回收。
const ref = { x: 42, y: 51 };
// 只要你可以访问到 `ref`（或其他对同一对象的引用），这个对象就不会被垃圾回收。
目前，WeakMap 和 WeakSet 是在 JavaScript 中以某种方式弱引用对象的唯一方式：将一个对象作为键添加到 WeakMap 或 WeakSet 中不会阻止它被垃圾回收。
const wm = new WeakMap();
{
const ref = {};
const metaData = 'foo';
wm.set(ref, metaData);
wm.get(ref);
// → metaData
}
// 我们在这个代码块作用域中不再拥有对 `ref` 的引用，因此它现在可以被垃圾回收，尽管它是 `wm` 中的一个键，而我们仍然可以访问到 `wm`。
假设你有一个由狗组成的数组，每只狗都有一个名字和一个评分。（如果这个例子听起来很奇怪，你应该知道有一个专门研究这个内容的 Twitter 帐号……别问！）
// 注意数组已经按 `name` 字母顺序预排序。
const doggos = [
{ name: 'Abby', rating: 12 },
{ name: 'Bandit', rating: 13 },
{ name: 'Choco', rating: 14 },
{ name: 'Daisy', rating: 12 },
{ name: 'Elmo', rating: 12 },
{ name: 'Falco', rating: 13 },
{ name: 'Ghost', rating: 14 },
];
// 按 `rating` 降序排序狗。
// （这个操作会原地更新 `doggos`。）
doggos.sort((a, b) => b.rating - a.rating);
JavaScript 的 Symbol 可以在创建时赋予一个描述：
const symbol = Symbol('foo');
// ^^^^^
以前，唯一可以通过编程方式访问这个描述的方法是通过 Symbol.prototype.toString() 间接实现：
const symbol = Symbol('foo');
// ^^^^^
symbol.toString();
// → 'Symbol(foo)'
// ^^^
symbol.toString().slice(7, -1); // 🤔
// → 'foo'
然而，这段代码看起来有些魔幻，不是非常自解释，并且违反了“表达意图，而非实现”的原则。此外，上面的技巧也无法区分没有描述的 symbol（即 Symbol()）和描述为空字符串的 symbol（即 Symbol('')）。
Object.fromEntries 是内置 JavaScript 库的一个很有用的补充。在解释它的作用之前，先了解一下已有的 Object.entries API 会有所帮助。
Object.entriesObject.entries API 已经存在了一段时间。
对于对象中的每个键值对，Object.entries 会返回一个数组，第一个元素是键，第二个元素是值。
Object.entries 在与 for-of 结合使用时尤为有用，因为它可以非常优雅地迭代对象中的所有键值对：
const object = { x: 42, y: 50 };
const entries = Object.entries(object);
// → [['x', 42], ['y', 50]]
for (const [key, value] of entries) {
console.log(`The value of ${key} is ${value}.`);
}
// 输出：
// The value of x is 42.
// The value of y is 50.
遗憾的是，想从 entries 的结果回到等价对象并不容易……直到现在！
Object.fromEntries新的 Object.fromEntries API 执行了 Object.entries 的逆操作。这使得根据条目重新构建对象变得更加简单：
const object = { x: 42, y: 50 };
const entries = Object.entries(object);
// → [['x', 42], ['y', 50]]
const result = Object.fromEntries(entries);
// → { x: 42, y: 50 }
一个常见的用例是转换对象。现在可以通过迭代其条目，然后使用你已经熟悉的数组方法来做到这一点：
const object = { x: 42, y: 50, abc: 9001 };
const result = Object.fromEntries(
Object.entries(object)
.filter(([ key, value ]) => key.length === 1)
.map(([ key, value ]) => [ key, value * 2 ])
);
// → { x: 84, y: 100 }
在这个示例中，我们用 filter 筛选出键长度为 1 的键值对，也就是 x 和 y，而排除了 abc。然后用 map 对剩余的条目进行操作，并为每个条目返回一个更新后的键值对。在本例中，我们通过将值乘以 2 来使每个值翻倍。最终得到的是一个只包含属性 x 和 y 的新对象，以及它们的新值。
自从 ES2015 引入 Promise 后，JavaScript 支持的 Promise 组合器只有两个：静态方法 Promise.all 和 Promise.race。
目前有两个新提案正在进行标准化过程：Promise.allSettled 和 Promise.any。随着这些新增内容，JavaScript 中将总共有四种 Promise 组合器，每种都支持不同的使用场景。
Array.prototype.flat这里的数组是多层嵌套的：它包含一个数组，而这个数组又包含另一个数组。
const array = [1, [2, [3]]];
// ^^^^^^^^^^^^^ 外层数组
// ^^^^^^^^ 内层数组
// ^^^ 最内层数组
Array#flat 返回给定数组的扁平化版本。
array.flat();
// → [1, 2, [3]]
// …等价于：
array.flat(1);
// → [1, 2, [3]]
大型数字字面量对人眼来说难以快速解析，特别是当数字中有大量重复数字时：
1000000000000
1019436871.42
为了提高可读性，一个新的JavaScript语言特性允许在数字字面量中使用下划线作为分隔符。因此，上述内容现在可以改写为按千分进行分组，例如：
通常会在字符串上重复应用相同的正则表达式以获取所有匹配项。在一定程度上，现在可以通过使用 String#match 方法来实现这一点。
在这个例子中，我们找到所有仅包含十六进制数字的单词，并记录每个匹配项：
const string = '魔术十六进制数字：DEADBEEF CAFE';
const regex = /\b\p{ASCII_Hex_Digit}+\b/gu;
for (const match of string.match(regex)) {
console.log(match);
}
// 输出:
//
// 'DEADBEEF'
// 'CAFE'
然而，这只会给你匹配的子字符串。通常，你不仅仅想要子字符串，还需要其他信息，比如每个子字符串的索引或者每个匹配中的捕获组。
通过编写你自己的循环，并自己记录匹配对象也可以实现这一点，但这有点麻烦而且不太方便：
const string = '魔术十六进制数字：DEADBEEF CAFE';
const regex = /\b\p{ASCII_Hex_Digit}+\b/gu;
let match;
while (match = regex.exec(string)) {
console.log(match);
}
// 输出:
//
// [ 'DEADBEEF', index: 19, input: '魔术十六进制数字：DEADBEEF CAFE' ]
// [ 'CAFE', index: 28, input: '魔术十六进制数字：DEADBEEF CAFE' ]
新的 String#matchAll API 使得这一过程比以往更加简单：你现在可以编写一个简单的 for-of 循环来获取所有的匹配对象。
const string = '魔术十六进制数字：DEADBEEF CAFE';
const regex = /\b\p{ASCII_Hex_Digit}+\b/gu;
for (const match of string.matchAll(regex)) {
console.log(match);
}
// 输出:
//
// [ 'DEADBEEF', index: 19, input: '魔术十六进制数字：DEADBEEF CAFE' ]
// [ 'CAFE', index: 28, input: '魔术十六进制数字：DEADBEEF CAFE' ]
String#matchAll 对于带有捕获组的正则表达式特别有用。它为每个匹配提供完整的信息，包括捕获组。
const string = '喜欢的 GitHub 仓库：tc39/ecma262 v8/v8.dev';
const regex = /\b(?<owner>[a-z0-9]+)\/(?<repo>[a-z0-9\.]+)\b/g;
for (const match of string.matchAll(regex)) {
console.log(`${match[0]} 在 ${match.index} 上，输入为 '${match.input}'`);
console.log(`→ 所有者: ${match.groups.owner}`);
console.log(`→ 仓库: ${match.groups.repo}`);
}
在JavaScript模块中，已经可以使用以下语法：
import * as utils from './utils.mjs';
然而，之前没有对称的export语法… 直到现在：
export * as utils from './utils.mjs';
多个提案扩展了现有的JavaScript类语法，新增了功能。本文解释了V8 v7.2和Chrome 72中的公共类字段的新语法，以及即将到来的私有类字段语法。
以下是一个创建名为IncreasingCounter的类实例的代码示例：
const counter = new IncreasingCounter();
counter.value;
// 输出 '获取当前值!'
// → 0
counter.increment();
counter.value;
// 输出 '获取当前值!'
// → 1
注意，访问value会执行一些代码（例如打印一条消息）然后返回结果。现在请思考，如何在JavaScript中实现这个类呢？🤔
以下是使用ES2015类语法实现IncreasingCounter的方法：
class IncreasingCounter {
constructor() {
this._count = 0;
}
get value() {
console.log('获取当前值!');
return this._count;
}
increment() {
this._count++;
}
}
该类在原型上安装了value的getter和一个increment方法。更有趣的是，类具有一个构造函数，该构造函数创建了一个实例属性_count并将其默认值设置为0。目前我们倾向于使用下划线前缀来表示_count不应该被类的使用者直接使用，但这只是一种约定，并不是一种真正的由语言强制执行的“私有”属性。