350个特性看透ES6

- 日理万妓 2023-07-20 05:33 15阅读 0赞

# 350个特性看透ES6 #

### 介绍 ###

*  ES6（也称为Harmony，`es-next`ES2015）是该语言的最新最终定稿规范
 *  该ES6规范是在完成**2015年6月**，*（因此ES2015）*
 *  规范的将来版本将遵循该`ES[YYYY]`模式，例如ES2016 for ES7
    
     *  **年度发布时间表**，不会让您**失望的**功能会影响下一班火车
     *  由于ES6早于该决定，因此我们大多数人仍将其称为ES6。
     *  从ES2016（ES7）开始，我们应该开始使用该`ES[YYYY]`模式来引用较新的版本
     *  命名方案的首要原因是迫使浏览器供应商迅速实施最新功能

## ##

### Babel ###

*  要使ES6今天开始工作，您需要一个**JavaScript到JavaScript的** *编译器*
 *  转运者在这里停留
    
     *  它们使您可以将最新版本的代码编译为该语言的旧版本。
     *  随着浏览器支持的改善，我们将把ES2016和ES2017转换为ES6及更高版本
     *  我们需要更好的源映射功能
     *  它们是当今在生产中运行ES6源代码的最可靠方法*（尽管浏览器获得了ES5）*
 *  Babel *（翻译员）*具有杀手级功能：**可读的输出**
 *  用于[`babel`][babel]将ES6转换为ES5进行静态构建
 *  使用[`babelify`][babelify]纳入`babel`到你的[咕嘟咕嘟，咕噜，或`npm run`][npm run]构建过程
 *  使用Node.js `v4.x.x`或更高版本，因为它们具有不错的ES6支持，这要归功于`v8`
 *  使用`babel-node`与任何版本`node`，因为它transpiles模块到ES5
 *  Babel拥有一个蓬勃发展的生态系统，已经支持某些ES2016，并具有插件支持
 *  阅读[ES6工具简史][ES6]

## ##

### 分配解构 ###

*  `var {foo} = pony` 相当于 `var foo = pony.foo`
 *  `var {foo: baz} = pony` 相当于 `var baz = pony.foo`
 *  您可以提供默认值，`var {foo='bar'} = baz`收益率`foo: 'bar'`如果`baz.foo`是`undefined`
 *  您可以根据需要提取任意数量的属性（带别名或不带别名）
    
     *  `var {foo, bar: baz} = {foo: 0, bar: 1}`让你`foo: 0`和`baz: 1`
 *  您可以更深入。`var {foo: {bar}} = { foo: { bar: 'baz' } }`让你`bar: 'baz'`
 *  您也可以使用别名。`var {foo: {bar: deep}} = { foo: { bar: 'baz' } }`让你`deep: 'baz'`
 *  找不到的属性`undefined`照常产生，例如：`var {foo} = {}`
 *  找不到的深层嵌套属性会产生错误，例如： `var {foo: {bar}} = {}`
 *  它也适用于数组，`[a, b] = [0, 1]`收益率`a: 0`和`b: 1`
 *  您可以跳过数组中的项目`[a, , b] = [0, 1, 2]`，，获取`a: 0`和`b: 2`
 *  您可以不使用*“ aux”*变量进行交换，`[a, b] = [b, a]`
 *  您还可以在函数参数中使用解构
    
     *  分配默认值，例如 `function foo (bar=2) {}`
     *  这些默认值也可以是对象 `function foo (bar={ a: 1, b: 2 }) {}`
     *  `bar`完全破坏，就像`function foo ({ a=1, b=2 }) {}`
     *  如果未提供任何内容，则默认为空对象，例如 `function foo ({ a=1, b=2 } = {}) {}`
 *  [深入][Link 1]阅读[ES6 JavaScript分解][Link 1]

## ##

### 传播算子和剩余参数 ###

*  其余参数更好 `arguments`
    
     *  您可以在方法签名中声明它，例如 `function foo (...everything) {}`
     *  `everything` 是一个数组，所有参数都传递给 `foo`
     *  您可以在之前命名一些参数`...everything`，例如`function foo (bar, ...rest) {}`
     *  命名参数不包括在内 `...rest`
     *  `...rest` 必须是列表中的最后一个参数
 *  扩展运算符比魔术更好，也用`...`语法 表示
    
     *  避免`.apply`在调用方法时，`fn(...[1, 2, 3])`等效于`fn(1, 2, 3)`
     *  串联比较容易 `[1, 2, ...[3, 4, 5], 6, 7]`
     *  将类似数组或可迭代对象的类型转换为数组，例如 `[...document.querySelectorAll('img')]`
     *  在[解构时][Link 2]也很有用，`[a, , ...rest] = [1, 2, 3, 4, 5]`产量`a: 1`和`rest: [3, 4, 5]`
     *  使`new`\+ `.apply`毫不费力，`new Date(...[2015, 31, 8])`
 *  [深入][Link 3]阅读[ES6传播和黄油][Link 3]

## ##

### 箭头函数 ###

*  声明函数的简洁方式 `param => returnValue`
 *  在做类似功能的事情时很有用 `[1, 2].map(x => x * 2)`
 *  有几种口味可供选择，可能会让您习惯一些
    
     *  `p1 => expr` 可以使用单个参数
     *  `p1 => expr``return`对提供的`expr`表达式有一个隐式语句
     *  要隐式返回对象，请将其包装在括号中，`() => ({ foo: 'bar' })`否则会**出现错误**
     *  当您有零个，两个或更多参数时，需要括号，`() => expr`或者`(p1, p2) => expr`
     *  右侧的括号代表一个代码块，可以包含多个语句， `() => {}`
     *  使用代码块时，没有隐式`return`，您必须提供它-`() => { return 'foo' }`
 *  您不能静态地命名箭头函数，但是现在运行时可以更好地为大多数方法推断名称
 *  箭头函数绑定到其词法范围
    
     *  `this``this`与父范围中的上下文相同
     *  `this`不能使用`.call`，`.apply`或类似的*“反射”型*方法进行修改
 *  [深入][Link 4]阅读[ES6箭头功能][Link 4]

## ##

### 模板文字 ###

*  除了`"`和\`' 外，还可以使用\`\`\`（反引号）声明字符串。
 *  用反引号括起来的字符串是*模板文字*
 *  模板文字可以是多行
 *  模板文字允许插值，例如变量是`ponyfoo.com is ${rating}`哪里`rating`
 *  您可以在插值中使用任何有效的JavaScript表达式，例如`${2 * 3}`或`${foo()}`
 *  您可以使用标记的模板来更改表达式的内插方式
    
     *  `fn`为`fn`foo，$ \{bar\}和$ \{baz\} 添加前缀
     *  `fn` 被调用一次 `template, ...expressions`
     *  `template`是`['foo, ', ' and ', '']`和`expressions`是`[bar, baz]`
     *  的结果`fn`成为模板文字的值
     *  可能的用例包括表达式的输入清理，参数解析等。
 *  模板文字几乎严格比单引号或双引号引起来的字符串更好
 *  [深入][Link 5]阅读[ES6模板文字][Link 5]

## ##

### 对象文字 ###

*  代替`{ foo: foo }`，您可以做`{ foo }`–称为*属性值的简写*
 *  计算的属性名称`{ [prefix + 'Foo']: 'bar' }`，其中`prefix: 'moz'`产生`{ mozFoo: 'bar' }`
 *  您不能将计算出的属性名称和属性值速记组合在一起，`{ [foo] }`无效
 *  可以使用其他更简洁的语法声明对象文字中的方法定义， `{ foo () {} }`
 *  参见[`Object`][Object]节
 *  [深入][Link 6]阅读[ES6对象文字功能][Link 6]

## ##

### 原型 ###

*  不是*“传统”*类，而是在原型继承之上的语法糖
 *  类似于声明对象的语法， `class Foo {}`
 *  实例方法*- `new Foo().bar`\-*使用的是短申报[对象文本][Link 7]语法，`class Foo { bar () {} }`
 *  静态方法*– `Foo.isPonyFoo()`–*需要`static`关键字前缀，`class Foo { static isPonyFoo () {} }`
 *  构造方法 `class Foo { constructor () { /* initialize instance */ } }`
 *  使用简单语法的原型继承 `class PonyFoo extends Foo {}`
 *  [深入][Link 8]阅读[ES6类][Link 8]

### let和const ###

*  `let`并且`const`是`var`声明变量时的替代方法
 *  `let` 是块作用域的，而不是词法范围的 `function`
 *  `let`被[提升][Link 9]到块的顶部，而`var`声明被提升到函数的顶部
 *  “临时死区” – TDZ的简称
    
     *  从`let foo`声明的块的开头开始
     *  `let foo`在用户代码中放置该语句的*结尾（此处无关紧要）*
     *  尝试访问`foo`TDZ 或在TDZ内进行分配*（在`let foo`到达该语句之前）会*导致错误
     *  在声明变量之前对其进行操作时，有助于防止神秘的错误
 *  `const` 也受TDZ语义的块作用域，提升和约束
 *  `const` 变量必须使用初始化程序声明， `const foo = 'bar'`
 *  `const`初始化后分配给，失败时会无声地（或在严格模式下**大声地** *除外*）
 *  `const` 变量不会使分配的值不变
    
     *  `const foo = { bar: 'baz' }`意味着`foo`将始终引用右侧对象
     *  `const foo = { bar: 'baz' }; foo.bar = 'boo'` 不会扔
 *  声明相同名称的变量将引发
 *  旨在修复在您重新分配变量并丢失其他地方传递的引用的错误
 *  在ES6中，**功能是块作用域的**
    
     *  防止通过吊装泄漏窥探范围内的机密， `{ let _foo = 'secret', bar = () => _foo; }`
     *  在大多数情况下都不会破坏用户代码，通常情况下无论如何都不会破坏用户代码
 *  阅读[ES6 Let，Const和“临时死区”（TDZ）的深度][ES6 Let_Const_TDZ]

### `symbol` ###

* ES6中的新原始类型
 * 您可以使用创建自己的符号 `var symbol = Symbol()`
 * 您可以添加说明以进行调试，例如 `Symbol('ponyfoo')`
 * 符号是不变的且唯一的。`Symbol()`，`Symbol()`，`Symbol('foo')`并且`Symbol('foo')`都不同
 * 符号的类型为`symbol`，因此：`typeof Symbol() === 'symbol'`
 * 您还可以使用以下命令创建全局符号 `Symbol.for(key)`
 
 * 如果提供的符号`key`已经存在，您将获得该符号
 * 否则，还将使用`key`描述作为新符号
 * `Symbol.keyFor(symbol)`是反函数，取a `symbol`并返回其`key`
 * 全局符号**尽可能具有全局性**，即*跨领域*。单个注册表用于在运行时中查找这些符号
 
 * `window` 语境
 * `eval` 语境
 * `<iframe>`上下文 `Symbol.for('foo') === iframe.contentWindow.Symbol.for('foo')`
 * 还有“知名”符号
 
 * 不在全局注册表中，可通过访问`Symbol[name]`，例如：`Symbol.iterator`
 * 跨领域的意思 `Symbol.iterator === iframe.contentWindow.Symbol.iterator`
 * 通过说明书中使用来定义协议中，如[*可迭代*协议][Link 10]在`Symbol.iterator`
 * 他们**实际上**并不**知名** -用口语来说
 * 遍历符号属性很困难，但并非不可能，而且绝对不是私有的
 
 * 所有ES6之前的“反射”方法都将符号隐藏起来
 * 可通过以下方式访问符号 `Object.getOwnPropertySymbols`
 * 您不会偶然发现它们，但如果*积极寻找，***就会**找到它们
 * [深入][Link 11]阅读[ES6符号][Link 11]

### 迭代器 ###

*  迭代器和可迭代协议定义了如何迭代任何对象，而不仅仅是数组和类似数组的对象
 *  一个众所周知的`Symbol`用于将迭代器分配给任何对象
 *  `var foo = { [Symbol.iterator]: iterable}`， 要么 `foo[Symbol.iterator] = iterable`
 *  的`iterable`是返回的方法`iterator`，其具有对象`next`方法
 *  该`next`方法返回具有两个属性的对象，`value`并且`done`
    
     *  该`value`属性指示要迭代的序列中的当前值
     *  该`done`属性指示是否还有其他项目要迭代
 *  具有`[Symbol.iterator]`值的对象是*可迭代的*，因为它们订阅了可迭代协议
 *  在ES6中`Array`，某些内置插件（例如，`String`或`arguments`）以及`NodeList`浏览器默认是可迭代的
 *  可迭代对象可以使用进行循环`for..of`，例如`for (let el of document.querySelectorAll('a'))`
 *  可以使用散布运算符来合成可迭代对象，例如 `[...document.querySelectorAll('a')]`
 *  您还可以`Array.from(document.querySelectorAll('a'))`用于将可迭代序列合成为数组
 *  迭代器是*惰性的*，并且产生无限序列的迭代器仍可以导致有效程序
 *  要小心，不要试图用合成的无限序列`...`或`Array.from`作为**会**导致无限循环
 *  [深入][Link 12]了解[ES6迭代器][Link 12]

### `generator` ###

*  生成器函数是一种特殊的*迭代器*，可以使用以下`function* generator () {}`语法进行声明：
 *  生成器函数用于`yield`发出元素序列
 *  生成器函数还可以`yield*`用于委派给另一个生成器函数*–或任何可迭代对象*
 *  生成器函数返回遵循*迭代**器*和*迭代器*协议 的生成器对象
    
     *  给定`g = generator()`，`g`因为这`g[Symbol.iterator]`是一种方法，所以遵守可迭代协议
     *  给定`g = generator()`，`g`坚持使用迭代器协议，因为它`g.next`是一种方法
     *  生成器对象的迭代器`g`是生成器本身：`g[Symbol.iterator]() === g`
 *  使用提取值`Array.from(g)`，`[...g]`，`for (let item of g)`，或只调用`g.next()`
 *  在四种不同情况下，生成器函数的执行被挂起，记住最后一个位置
    
     *  甲`yield`表达序列中返回的下一个值
     *  一条`return`语句返回序列中的最后一个值
     *  一条`throw`语句完全停止了生成器中的执行
     *  到达发电机功能信号的末端 `{ done: true }`
 *  一旦`g`序列已经结束，`g.next()`只是返回`{ done: true }`，并没有影响
 *  使异步流感到同步很容易
    
     *  采取用户提供的发电机功能
     *  发生异步操作时，用户代码被挂起
     *  调用`g.next()`，在用户代码中暂停执行
 *  [深入][Link 13]了解[ES6生成器][Link 13]

## ##

### `Promise` ###

*  遵循[`Promises/A+`][Promises_A]规范，在ES6标准化之前在野外广泛实施*（例如[`bluebird`][bluebird]）*
 *  承诺就像一棵树。使用`p.then(handler)`和添加分支`p.catch(handler)`
 *  与创造新的`p`承诺`new Promise((resolve, reject) => { /* resolver */ })`
    
     *  该`resolve(value)`回调将履行与所提供的承诺`value`
     *  该`reject(reason)`回调将拒绝`p`与`reason`错误
     *  您可以异步调用这些方法，从而阻止承诺树的更深层分支
 *  每次呼叫`p.then`并`p.catch`创建另一个诺言，该诺言在`p`结算时被阻止
 *  在承诺开始时*挂起*状态，并**定居**时，他们要么*履行*或*拒绝*
 *  承诺只能解决一次，然后解决。已兑现的承诺解除了更深层次的分支
 *  您可以根据需要在任意数量的分支上兑现尽可能多的承诺
 *  每个分支将执行一个`.then`或多个`.catch`处理程序，从不执行
 *  一个`.then`回调，可以返回一个值变换先前分支的结果
 *  一个`.then`回调可以返回它的另一个承诺阻止
 *  `p.catch(fn).catch(fn)` 不会做您想要做的-除非您想要做的是在错误处理程序中捕获错误
 *  [`Promise.resolve(value)`][Promise.resolve_value] 创建提供的承诺 `value`
 *  [`Promise.reject(reason)`][Promise.resolve_value] 创建一个被提供的拒绝的承诺 `reason`
 *  [`Promise.all(...promises)`][Promise.all_...promises]创建一个承诺，当所有条件`...promises`都满足或其中之一被拒绝时就解决
 *  [`Promise.race(...promises)`][Promise.all_...promises]创建一个承诺，只要其中一个解决，就`...promises`可以解决
 *  使用[Promisees][]（承诺可视化游乐场）来更好地了解承诺
 *  [深入][Link 14]阅读[ES6承诺][Link 14]

## ##

### 地图 ###

*  替换了使用普通JavaScript对象创建哈希图的常见模式
    
     *  避免了用户提供的密钥的安全性问题
     *  允许键为任意值，您甚至可以将DOM元素或函数用作`key`条目的
 *  `Map`遵守*[迭代][Link 10]*协议
 *  创建一个`map`使用`new Map()`
 *  初始化地图与`iterable`像`[[key1, value1], [key2, value2]]`在`new Map(iterable)`
 *  使用`map.set(key, value)`添加条目
 *  使用`map.get(key)`来获得入门
 *  检查`key`使用`map.has(key)`
 *  删除条目 `map.delete(key)`
 *  `map`使用`for (let [key, value] of map)`，传播算子`Array.from`等进行迭代
 *  [深入][Link 15]阅读[ES6地图][Link 15]

## ##

### `WeakMap` ###

*  与相似`Map`，但不完全相同
 *  `WeakMap`没有迭代，这样你就不会得到枚举的方法一样`.forEach`，`.clear`和别人对你的了`Map`
 *  `WeakMap`键必须是引用类型。您不能将符号，数字或字符串之类的值类型用作键
 *  `WeakMap``key`唯一引用了所引用变量的条目将受到垃圾回收
 *  最后一点意味着`WeakMap`可以很好地保留对象的元数据，而这些对象仍在使用中
 *  您可以避免内存泄漏，而无需进行手动引用计数– `WeakMap`就像[`IDisposable`][IDisposable]在.NET中一样
 *  [深入][Link 16]阅读[ES6 WeakMaps][Link 16]

### `Set` ###

*  与相似`Map`，但不完全相同
 *  `Set` 没有键，只有值
 *  `set.set(value)`看起来不正确，所以我们`set.add(value)`改为
 *  集不能有重复的值，因为这些值也用作键
 *  [深入][Link 17]阅读[ES6集][Link 17]

### `WeakSet` ###

*  `WeakSet`是`Set`和之间的杂种`WeakMap`
 *  A `WeakSet`是一个不能迭代且没有枚举方法的集合
 *  `WeakSet` 值必须是引用类型
 *  `WeakSet` 对于指示引用是否正在积极使用的元数据表可能很有用
 *  [深入][Link 18]阅读[ES6弱集][Link 18]

### `Proxy` ###

*  使用创建代理`new Proxy(target, handler)`，其中`target`任何对象`handler`都是配置
 *  a的默认行为`proxy`充当基础`target`对象的传递
 *  处理程序确定如何在`target`常规对象属性访问语义之上访问基础对象
 *  您放弃对的引用，`proxy`并严格控制如何`target`与之交互
 *  处理程序也称为陷阱，这些术语可互换使用
 *  您可以使用以下方式创建**可撤销的**代理`Proxy.revocable(target, handler)`
    
     *  该方法返回具有`proxy`和`revoke`属性的对象
     *  您可以为了方便而[破坏][Link 19] `var {proxy, revoke} = Proxy.revocable(target, handler)`
     *  您可以将`proxy`所有配置与`new Proxy(target, handler)`
     *  之后`revoke()`被调用时，`proxy`将**抛出**的*任何操作*，使其在方便的时候你不能相信消费者
 *  [`get`][get]–陷阱`proxy.prop`和`proxy['prop']`
 *  [`set`][set]–陷阱`proxy.prop = value`和`proxy['prop'] = value`
 *  [`has`][has]–陷阱`in`算子
 *  [`deleteProperty`][deleteProperty]–陷阱`delete`算子
 *  [`defineProperty`][defineProperty]–陷阱`Object.defineProperty`和声明性替代
 *  [`enumerate`][enumerate]–陷阱`for..in`循环
 *  [`ownKeys`][ownKeys]–陷阱`Object.keys`和相关方法
 *  [`apply`][apply]–陷阱*函数调用*
 *  [`construct`][construct]–限制`new`操作员的使用
 *  [`getPrototypeOf`][getPrototypeOf] –捕获内部呼叫 `[[GetPrototypeOf]]`
 *  [`setPrototypeOf`][setPrototypeOf] –陷阱呼叫 `Object.setPrototypeOf`
 *  [`isExtensible`][isExtensible] –陷阱呼叫 `Object.isExtensible`
 *  [`preventExtensions`][preventExtensions] –陷阱呼叫 `Object.preventExtensions`
 *  [`getOwnPropertyDescriptor`][getOwnPropertyDescriptor] –陷阱呼叫 `Object.getOwnPropertyDescriptor`
 *  [深入][Link 20]阅读[ES6代理][Link 20]
 *  [深入][Link 21]阅读[ES6代理陷阱][Link 21]
 *  了解[更多深入][Link 22]了解[ES6代理陷阱][Link 22]

## ##

### 反射 ###

*  `Reflection`是`Math`ES6中新的静态内置（认为）
 *  `Reflection`方法具有合理的内部，例如，`Reflect.defineProperty`返回布尔值而不是抛出
 *  `Reflection`每个代理陷阱处理程序都有一个方法，它们代表每个陷阱的默认行为
 *  展望未来，新的反射方法`Object.keys`将与`Reflection`命名空间相同
 *  阅读《[ES6深度思考》][ES6 1]

### `Number` ###

*  `0b`对二进制文件使用前缀，`0o`对八进制整数文字使用前缀
 *  `Number.isNaN`而`Number.isFinite`像他们的全球同名，但他们*不*把输入到`Number`
 *  `Number.parseInt`并`Number.parseFloat`与他们的全球同名完全相同
 *  `Number.isInteger`检查输入是否为`Number`不带小数部分的值
 *  `Number.EPSILON`帮助找出两个数字之间可忽略的差异–例如`0.1 + 0.2`和`0.3`
 *  `Number.MAX_SAFE_INTEGER` 是可以安全且精确地用JavaScript表示的最大整数
 *  `Number.MIN_SAFE_INTEGER` 是可以安全且精确地用JavaScript表示的最小整数
 *  `Number.isSafeInteger` 检查整数是否在这些范围内，可以安全且准确地表示
 *  阅读[ES6 `Number`深度改进][ES6_Number]

### `Math` ###

* [`Math.sign`][Math.sign] –数字的符号功能
 * [`Math.trunc`][Math.trunc] –数字的整数部分
 * [`Math.cbrt`][Math.cbrt] –价值的立方根，或 `∛‾value`
 * [`Math.expm1`][Math.expm1]\- `e`在`value`零下`1`，或`evalue - 1`
 * [`Math.log1p`][Math.log1p]– `value + 1`或的自然对数`_ln_(value + 1)`
 * [`Math.log10`][Math.log10]–以`value`或10为底的对数`_log_10(value)`
 * [`Math.log2`][Math.log2]– `value`或的以2为底的对数`_log_2(value)`
 * [`Math.sinh`][Math.sinh] –双曲正弦数
 * [`Math.cosh`][Math.cosh] –双曲余弦数
 * [`Math.tanh`][Math.tanh] –数字的双曲正切
 * [`Math.asinh`][Math.asinh] –数字的双曲反正弦
 * [`Math.acosh`][Math.acosh] –双曲余弦
 * [`Math.atanh`][Math.atanh] –数字的双曲反正切
 * [`Math.hypot`][Math.hypot] –平方和的平方根
 * [`Math.clz32`][Math.clz32] –数字的32位表示形式中的前导零位
 * [`Math.imul`][Math.imul]– *类似C的* 32位乘法
 * [`Math.fround`][Math.fround] –数字的最接近的单精度浮点表示
 * [深入][Link 23]阅读[ES6 `Math`添加][Link 23]

### `Array` ###

*  [`Array.from`][Array.from]– `Array`从类似数组`arguments`或可迭代对象的对象创建实例
 *  [`Array.of`][Array.of]–类似`new Array(...items)`，但没有特殊情况
 *  [`Array.prototype.copyWithin`][Array.prototype.copyWithin] –将一系列数组元素复制到数组中的其他位置
 *  [`Array.prototype.fill`][Array.prototype.fill] –用提供的值填充现有数组的所有元素
 *  [`Array.prototype.find`][Array.prototype.find] –返回满足回调的第一项
 *  [`Array.prototype.findIndex`][Array.prototype.findIndex] –返回满足回调的第一项的索引
 *  [`Array.prototype.keys`][Array.prototype.keys] –返回一个迭代器，该迭代器产生一个序列，该序列包含数组的键
 *  [`Array.prototype.values`][Array.prototype.values] –返回一个迭代器，该迭代器产生一个保存数组值的序列
 *  [`Array.prototype.entries`][Array.prototype.entries] –返回一个迭代器，该迭代器产生一个包含数组的键值对的序列
 *  [`Array.prototype[Symbol.iterator]`][Array.prototype_Symbol.iterator]–与[`Array.prototype.values`][Array.prototype.values]方法完全相同
 *  [深入][Link 24]阅读[ES6 `Array`扩展][Link 24]

### `Object` ###

*  [`Object.assign`][Object.assign] –对来自的属性进行递归的浅覆盖 `target, ...objects`
 *  [`Object.is`][Object.is]–像以`===`编程方式使用运算符一样，也`true`适用于`NaN`vs `NaN`和`+0`vs`-0`
 *  [`Object.getOwnPropertySymbols`][Object.getOwnPropertySymbols] –返回在对象上找到的所有自己的属性符号
 *  [`Object.setPrototypeOf`][Object.setPrototypeOf]–更改原型。相当于`target.__proto__`二传手
 *  另请参见“ [对象文字”][Link 7]部分
 *  阅读[ES6 `Object`深度更改][ES6_Object]

### 字符串和Unicode ###

*  字符串操作
    
     *  [`String.prototype.startsWith`][String.prototype.startsWith] –字符串是否以 `value`
     *  [`String.prototype.endsWith`][String.prototype.endsWith] –字符串是否结尾 `value`
     *  [`String.prototype.includes`][String.prototype.includes]–字符串是否包含`value`任何地方
     *  [`String.prototype.repeat`][String.prototype.repeat]–返回字符串重复`amount`次数
     *  [`String.prototype[Symbol.iterator]`][String.prototype_Symbol.iterator]–使您可以遍历一系列Unicode代码点*（非字符）*
 *  [统一码][Link 25]
    
     *  [`String.prototype.codePointAt`][String.prototype.codePointAt] –字符串中给定位置的代码点的以10为基的数字表示
     *  [`String.fromCodePoint`][String.fromCodePoint]–给定`...codepoints`，返回由其unicode表示形式组成的字符串
     *  [`String.prototype.normalize`][String.prototype.normalize] –返回字符串的unicode表示形式的规范化版本
 *  [深入][Link 26]阅读[ES6字符串和Unicode添加][Link 26]

### 模块系统 ###

*  ES6模块系统中默认情况下[严格模式][Link 27]已打开
 *  ES6模块是[`export`][export]API的文件
 *  [`export default value`][export default value] 导出默认绑定
 *  [`export var foo = 'bar'`][export var foo _ _bar] 导出命名绑定
 *  命名导出是[可以][Link 28]在导出它们的模块中[随时更改的][Link 28]绑定
 *  `export { foo, bar }`出口[已命名出口的清单][Link 29]
 *  `export { foo as ponyfoo }`别名出口为引用`ponyfoo`，而不是
 *  `export { foo as default }` 将命名的出口标记为默认出口
 *  作为[最佳实践][Link 30]，`export default api`在所有模块的末尾，其中`api`是一个对象，避免混乱，
 *  模块加载是特定于实现的，允许与CommonJS互操作
 *  [`import 'foo'`][import _foo]将`foo`模块加载到当前模块中
 *  [`import foo from 'ponyfoo'`][import foo from _ponyfoo]将默认导出分配给`ponyfoo`本地`foo`变量
 *  [`import {foo, bar} from 'baz'`][import _foo_ bar_ from _baz]命名出口进口`foo`和`bar`从`baz`模块
 *  `import {foo as bar} from 'baz'`导入名为export `foo`但别名为`bar`变量的导入
 *  `import {default} from 'foo'` 也导入默认导出
 *  `import {default as bar} from 'foo'` 导入默认导出别名为 `bar`
 *  `import foo, {bar, baz} from 'foo'`将默认值`foo`与命名导出混合在一起，`bar`并`baz`在一个声明中
 *  [`import * as foo from 'foo'`][import _ as foo from _foo] 导入名称空间对象
    
     *  包含以下所有已命名的出口 `foo[name]`
     *  `foo.default`如果在模块中声明了默认导出，则包含中的默认导出
 *  [深入][Link 31]阅读[ES6模块补充][Link 31]

是时候进行子弹头排毒了。再说一遍，我*确实警告过您*阅读[文章系列][Link 32]。别忘了订阅，甚至[可以使Pony Foo活着][Pony Foo]。另外，您是否刚刚尝试了[Konami代码][Konami]？

[babel]: http://babeljs.io/
[babelify]: https://github.com/babel/babelify
[npm run]: https://ponyfoo.com/articles/gulp-grunt-whatever
[ES6]: https://ponyfoo.com/articles/a-brief-history-of-es6-tooling
[Link 1]: https://ponyfoo.com/articles/es6-destructuring-in-depth
[Link 2]: https://github.com/xitu/gold-miner/blob/master/TODO/es6.md#assignment-destructuring
[Link 3]: https://ponyfoo.com/articles/es6-spread-and-butter-in-depth
[Link 4]: https://ponyfoo.com/articles/es6-arrow-functions-in-depth
[Link 5]: https://ponyfoo.com/articles/es6-template-strings-in-depth
[Object]: https://github.com/xitu/gold-miner/blob/master/TODO/es6.md#object
[Link 6]: https://ponyfoo.com/articles/es6-object-literal-features-in-depth
[Link 7]: https://github.com/xitu/gold-miner/blob/master/TODO/es6.md#object-literals
[Link 8]: https://ponyfoo.com/articles/es6-classes-in-depth
[Link 9]: https://ponyfoo.com/articles/javascript-variable-hoisting
[ES6 Let_Const_TDZ]: https://ponyfoo.com/articles/es6-let-const-and-temporal-dead-zone-in-depth
[Link 10]: https://github.com/xitu/gold-miner/blob/master/TODO/es6.md#iterators
[Link 11]: https://ponyfoo.com/articles/es6-symbols-in-depth
[Link 12]: https://ponyfoo.com/articles/es6-iterators-in-depth
[Link 13]: https://ponyfoo.com/articles/es6-generators-in-depth
[Promises_A]: https://promisesaplus.com/
[bluebird]: https://github.com/petkaantonov/bluebird
[Promise.resolve_value]: https://ponyfoo.com/articles/es6-promises-in-depth#using-promiseresolve-and-promisereject
[Promise.all_...promises]: https://ponyfoo.com/articles/es6-promises-in-depth#leveraging-promiseall-and-promiserace
[Promisees]: http://bevacqua.github.io/promisees/
[Link 14]: https://ponyfoo.com/articles/es6-promises-in-depth
[Link 15]: https://ponyfoo.com/articles/es6-maps-in-depth
[IDisposable]: https://msdn.microsoft.com/en-us/library/system.idisposable%28v=vs.110%29.aspx?f=255&MSPPError=-2147217396
[Link 16]: https://ponyfoo.com/articles/es6-weakmaps-sets-and-weaksets-in-depth#es6-weakmaps
[Link 17]: https://ponyfoo.com/articles/es6-weakmaps-sets-and-weaksets-in-depth#es6-sets
[Link 18]: https://ponyfoo.com/articles/es6-weakmaps-sets-and-weaksets-in-depth#es6-weaksets
[Link 19]: https://github.com/xitu/gold-miner/blob/master/TODO/es6.md#destructuring
[get]: https://ponyfoo.com/articles/es6-proxies-in-depth#get
[set]: https://ponyfoo.com/articles/es6-proxies-in-depth#set
[has]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth#has
[deleteProperty]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth#deleteproperty
[defineProperty]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth#defineproperty
[enumerate]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth#enumerate
[ownKeys]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth#ownkeys
[apply]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth#apply
[construct]: https://ponyfoo.com/articles/morees6-proxy-traps-in-depth#construct
[getPrototypeOf]: https://ponyfoo.com/articles/morees6-proxy-traps-in-depth#getprototypeof
[setPrototypeOf]: https://ponyfoo.com/articles/morees6-proxy-traps-in-depth#setprototypeof
[isExtensible]: https://ponyfoo.com/articles/morees6-proxy-traps-in-depth#isextensible
[preventExtensions]: https://ponyfoo.com/articles/morees6-proxy-traps-in-depth#preventextensions
[getOwnPropertyDescriptor]: https://ponyfoo.com/articles/morees6-proxy-traps-in-depth#getownpropertydescriptor
[Link 20]: https://ponyfoo.com/articles/es6-proxies-in-depth
[Link 21]: https://ponyfoo.com/articles/es6-proxy-traps-in-depth
[Link 22]: https://ponyfoo.com/articles/more-es6-proxy-traps-in-depth
[ES6 1]: https://ponyfoo.com/articles/es6-reflection-in-depth
[ES6_Number]: https://ponyfoo.com/articles/es6-number-improvements-in-depth
[Math.sign]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathsign
[Math.trunc]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathtrunc
[Math.cbrt]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathcbrt
[Math.expm1]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathexpm1
[Math.log1p]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathlog1p
[Math.log10]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathlog10
[Math.log2]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathlog2
[Math.sinh]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathsinh
[Math.cosh]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathcosh
[Math.tanh]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathtanh
[Math.asinh]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathasinh
[Math.acosh]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathacosh
[Math.atanh]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathatanh
[Math.hypot]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathhypot
[Math.clz32]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathclz32
[Math.imul]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathimul
[Math.fround]: https://ponyfoo.com/articles/es6-math-additions-in-depth#mathfround
[Link 23]: https://ponyfoo.com/articles/es6-math-additions-in-depth
[Array.from]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayfrom
[Array.of]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayof
[Array.prototype.copyWithin]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypecopywithin
[Array.prototype.fill]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypefill
[Array.prototype.find]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypefind
[Array.prototype.findIndex]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypefindindex
[Array.prototype.keys]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypekeys
[Array.prototype.values]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypevalues
[Array.prototype.entries]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototypeentries
[Array.prototype_Symbol.iterator]: https://ponyfoo.com/articles/es6-array-extensions-in-depth#arrayprototype-symboliterator
[Link 24]: https://ponyfoo.com/articles/es6-array-extensions-in-depth
[Object.assign]: https://ponyfoo.com/articles/es6-object-changes-in-depth#objectassign
[Object.is]: https://ponyfoo.com/articles/es6-object-changes-in-depth#objectis
[Object.getOwnPropertySymbols]: https://ponyfoo.com/articles/es6-object-changes-in-depth#objectgetownpropertysymbols
[Object.setPrototypeOf]: https://ponyfoo.com/articles/es6-object-changes-in-depth#objectsetprototypeof
[ES6_Object]: https://ponyfoo.com/articles/es6-object-changes-in-depth
[String.prototype.startsWith]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototypestartswith
[String.prototype.endsWith]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototypeendswith
[String.prototype.includes]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototypeincludes
[String.prototype.repeat]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototyperepeat
[String.prototype_Symbol.iterator]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototype-symboliterator
[Link 25]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#unicode
[String.prototype.codePointAt]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototypecodepointat
[String.fromCodePoint]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringfromcodepoint%60
[String.prototype.normalize]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth#stringprototypenormalize
[Link 26]: https://ponyfoo.com/articles/es6-strings-and-unicode-in-depth
[Link 27]: https://ponyfoo.com/articles/es6-modules-in-depth#strict-mode
[export]: https://ponyfoo.com/articles/es6-modules-in-depth#export
[export default value]: https://ponyfoo.com/articles/es6-modules-in-depth#exporting-a-default-binding
[export var foo _ _bar]: https://ponyfoo.com/articles/es6-modules-in-depth#named-exports
[Link 28]: https://ponyfoo.com/articles/es6-modules-in-depth#bindings-not-values
[Link 29]: https://ponyfoo.com/articles/es6-modules-in-depth#exporting-lists
[Link 30]: https://ponyfoo.com/articles/es6-modules-in-depth#best-practices-and-export
[import _foo]: https://ponyfoo.com/articles/es6-modules-in-depth#import
[import foo from _ponyfoo]: https://ponyfoo.com/articles/es6-modules-in-depth#importing-default-exports
[import _foo_ bar_ from _baz]: https://ponyfoo.com/articles/es6-modules-in-depth#importing-named-exports
[import _ as foo from _foo]: https://ponyfoo.com/articles/es6-modules-in-depth#import-all-the-things
[Link 31]: https://ponyfoo.com/articles/es6-modules-in-depth
[Link 32]: https://ponyfoo.com/articles/tagged/es6-in-depth
[Pony Foo]: http://patreon.com/bevacqua
[Konami]: https://en.wikipedia.org/wiki/Konami_Code