diff --git a/docs/class-extends.md b/docs/class-extends.md
new file mode 100644
index 0000000..89e3bec
--- /dev/null
+++ b/docs/class-extends.md
@@ -0,0 +1,682 @@
+# Class 的继承
+
+## 简介
+
+Class 可以通过`extends`关键字实现继承，这比 ES5 的通过修改原型链实现继承，要清晰和方便很多。
+
+```javascript
+class Point {
+}
+
+class ColorPoint extends Point {
+}
+```
+
+上面代码定义了一个`ColorPoint`类，该类通过`extends`关键字，继承了`Point`类的所有属性和方法。但是由于没有部署任何代码，所以这两个类完全一样，等于复制了一个`Point`类。下面，我们在`ColorPoint`内部加上代码。
+
+```javascript
+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`对象，而是继承父类的`this`对象，然后对其进行加工。如果不调用`super`方法，子类就得不到`this`对象。
+
+```javascript
+class Point { /* ... */ }
+
+class ColorPoint extends Point {
+  constructor() {
+  }
+}
+
+let cp = new ColorPoint(); // ReferenceError
+```
+
+上面代码中，`ColorPoint`继承了父类`Point`，但是它的构造函数没有调用`super`方法，导致新建实例时报错。
+
+ES5 的继承，实质是先创造子类的实例对象`this`，然后再将父类的方法添加到`this`上面（`Parent.apply(this)`）。ES6 的继承机制完全不同，实质是先创造父类的实例对象`this`（所以必须先调用`super`方法），然后再用子类的构造函数修改`this`。
+
+如果子类没有定义`constructor`方法，这个方法会被默认添加，代码如下。也就是说，不管有没有显式定义，任何一个子类都有`constructor`方法。
+
+```javascript
+class ColorPoint extends Point {
+}
+
+// 等同于
+class ColorPoint extends Point {
+  constructor(...args) {
+    super(...args);
+  }
+}
+```
+
+另一个需要注意的地方是，在子类的构造函数中，只有调用`super`之后，才可以使用`this`关键字，否则会报错。这是因为子类实例的构建，是基于对父类实例加工，只有`super`方法才能返回父类实例。
+
+```javascript
+class Point {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+class ColorPoint extends Point {
+  constructor(x, y, color) {
+    this.color = color; // ReferenceError
+    super(x, y);
+    this.color = color; // 正确
+  }
+}
+```
+
+上面代码中，子类的`constructor`方法没有调用`super`之前，就使用`this`关键字，结果报错，而放在`super`方法之后就是正确的。
+
+下面是生成子类实例的代码。
+
+```javascript
+let cp = new ColorPoint(25, 8, 'green');
+
+cp instanceof ColorPoint // true
+cp instanceof Point // true
+```
+
+上面代码中，实例对象`cp`同时是`ColorPoint`和`Point`两个类的实例，这与 ES5 的行为完全一致。
+
+## Object.getPrototypeOf()
+
+`Object.getPrototypeOf`方法可以用来从子类上获取父类。
+
+```javascript
+Object.getPrototypeOf(ColorPoint) === Point
+// true
+```
+
+因此，可以使用这个方法判断，一个类是否继承了另一个类。
+
+## super 关键字
+
+`super`这个关键字，既可以当作函数使用，也可以当作对象使用。在这两种情况下，它的用法完全不同。
+
+第一种情况，`super`作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次`super`函数。
+
+```javascript
+class A {}
+
+class B extends A {
+  constructor() {
+    super();
+  }
+}
+```
+
+上面代码中，子类`B`的构造函数之中的`super()`，代表调用父类的构造函数。这是必须的，否则 JavaScript 引擎会报错。
+
+注意，`super`虽然代表了父类`A`的构造函数，但是返回的是子类`B`的实例，即`super`内部的`this`指的是`B`，因此`super()`在这里相当于`A.prototype.constructor.call(this)`。
+
+```javascript
+class A {
+  constructor() {
+    console.log(new.target.name);
+  }
+}
+class B extends A {
+  constructor() {
+    super();
+  }
+}
+new A() // A
+new B() // B
+```
+
+上面代码中，`new.target`指向当前正在执行的函数。可以看到，在`super()`执行时，它指向的是子类`B`的构造函数，而不是父类`A`的构造函数。也就是说，`super()`内部的`this`指向的是`B`。
+
+作为函数时，`super()`只能用在子类的构造函数之中，用在其他地方就会报错。
+
+```javascript
+class A {}
+
+class B extends A {
+  m() {
+    super(); // 报错
+  }
+}
+```
+
+上面代码中，`super()`用在`B`类的`m`方法之中，就会造成句法错误。
+
+第二种情况，`super`作为对象时，在普通方法中，指向父类的原型对象；在静态方法中，指向父类。
+
+```javascript
+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`调用的。
+
+```javascript
+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`就引用不到它。
+
+如果属性定义在父类的原型对象上，`super`就可以取到。
+
+```javascript
+class A {}
+A.prototype.x = 2;
+
+class B extends A {
+  constructor() {
+    super();
+    console.log(super.x) // 2
+  }
+}
+
+let b = new B();
+```
+
+上面代码中，属性`x`是定义在`A.prototype`上面的，所以`super.x`可以取到它的值。
+
+ES6 规定，通过`super`调用父类的方法时，`super`会绑定子类的`this`。
+
+```javascript
+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()`会绑定子类`B`的`this`，导致输出的是`2`，而不是`1`。也就是说，实际上执行的是`super.print.call(this)`。
+
+由于绑定子类的`this`，所以如果通过`super`对某个属性赋值，这时`super`就是`this`，赋值的属性会变成子类实例的属性。
+
+```javascript
+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`将指向父类，而不是父类的原型对象。
+
+```javascript
+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`的时候，必须显式指定是作为函数、还是作为对象使用，否则会报错。
+
+```javascript
+class A {}
+
+class B extends A {
+  constructor() {
+    super();
+    console.log(super); // 报错
+  }
+}
+```
+
+上面代码中，`console.log(super)`当中的`super`，无法看出是作为函数使用，还是作为对象使用，所以 JavaScript 引擎解析代码的时候就会报错。这时，如果能清晰地表明`super`的数据类型，就不会报错。
+
+```javascript
+class A {}
+
+class B extends A {
+  constructor() {
+    super();
+    console.log(super.valueOf() instanceof B); // true
+  }
+}
+
+let b = new B();
+```
+
+上面代码中，`super.valueOf()`表明`super`是一个对象，因此就不会报错。同时，由于`super`绑定`B`的`this`，所以`super.valueOf()`返回的是一个`B`的实例。
+
+最后，由于对象总是继承其他对象的，所以可以在任意一个对象中，使用`super`关键字。
+
+```javascript
+var obj = {
+  toString() {
+    return "MyObject: " + super.toString();
+  }
+};
+
+obj.toString(); // MyObject: [object Object]
+```
+
+## 类的 prototype 属性和\_\_proto\_\_属性
+
+大多数浏览器的 ES5 实现之中，每一个对象都有`__proto__`属性，指向对应的构造函数的`prototype`属性。Class 作为构造函数的语法糖，同时有`prototype`属性和`__proto__`属性，因此同时存在两条继承链。
+
+（1）子类的`__proto__`属性，表示构造函数的继承，总是指向父类。
+
+（2）子类`prototype`属性的`__proto__`属性，表示方法的继承，总是指向父类的`prototype`属性。
+
+```javascript
+class A {
+}
+
+class B extends A {
+}
+
+B.__proto__ === A // true
+B.prototype.__proto__ === A.prototype // true
+```
+
+上面代码中，子类`B`的`__proto__`属性指向父类`A`，子类`B`的`prototype`属性的`__proto__`属性指向父类`A`的`prototype`属性。
+
+这样的结果是因为，类的继承是按照下面的模式实现的。
+
+```javascript
+class A {
+}
+
+class B {
+}
+
+// B 的实例继承 A 的实例
+Object.setPrototypeOf(B.prototype, A.prototype);
+
+// B 的实例继承 A 的静态属性
+Object.setPrototypeOf(B, A);
+
+const b = new B();
+```
+
+《对象的扩展》一章给出过`Object.setPrototypeOf`方法的实现。
+
+```javascript
+Object.setPrototypeOf = function (obj, proto) {
+  obj.__proto__ = proto;
+  return obj;
+}
+```
+
+因此，就得到了上面的结果。
+
+```javascript
+Object.setPrototypeOf(B.prototype, A.prototype);
+// 等同于
+B.prototype.__proto__ = A.prototype;
+
+Object.setPrototypeOf(B, A);
+// 等同于
+B.__proto__ = A;
+```
+
+这两条继承链，可以这样理解：作为一个对象，子类（`B`）的原型（`__proto__`属性）是父类（`A`）；作为一个构造函数，子类（`B`）的原型（`prototype`属性）是父类的实例。
+
+```javascript
+Object.create(A.prototype);
+// 等同于
+B.prototype.__proto__ = A.prototype;
+```
+
+### extends 的继承目标
+
+`extends`关键字后面可以跟多种类型的值。
+
+```javascript
+class B extends A {
+}
+```
+
+上面代码的`A`，只要是一个有`prototype`属性的函数，就能被`B`继承。由于函数都有`prototype`属性（除了`Function.prototype`函数），因此`A`可以是任意函数。
+
+下面，讨论三种特殊情况。
+
+第一种特殊情况，子类继承`Object`类。
+
+```javascript
+class A extends Object {
+}
+
+A.__proto__ === Object // true
+A.prototype.__proto__ === Object.prototype // true
+```
+
+这种情况下，`A`其实就是构造函数`Object`的复制，`A`的实例就是`Object`的实例。
+
+第二种特殊情况，不存在任何继承。
+
+```javascript
+class A {
+}
+
+A.__proto__ === Function.prototype // true
+A.prototype.__proto__ === Object.prototype // true
+```
+
+这种情况下，A作为一个基类（即不存在任何继承），就是一个普通函数，所以直接继承`Function.prototype`。但是，`A`调用后返回一个空对象（即`Object`实例），所以`A.prototype.__proto__`指向构造函数（`Object`）的`prototype`属性。
+
+第三种特殊情况，子类继承`null`。
+
+```javascript
+class A extends null {
+}
+
+A.__proto__ === Function.prototype // true
+A.prototype.__proto__ === undefined // true
+```
+
+这种情况与第二种情况非常像。`A`也是一个普通函数，所以直接继承`Function.prototype`。但是，A调用后返回的对象不继承任何方法，所以它的`__proto__`指向`Function.prototype`，即实质上执行了下面的代码。
+
+```javascript
+class C extends null {
+  constructor() { return Object.create(null); }
+}
+```
+
+### 实例的 \_\_proto\_\_ 属性
+
+子类实例的`__proto__`属性的`__proto__`属性，指向父类实例的`__proto__`属性。也就是说，子类的原型的原型，是父类的原型。
+
+```javascript
+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__`属性，可以修改父类实例的行为。
+
+```javascript
+p2.__proto__.__proto__.printName = function () {
+  console.log('Ha');
+};
+
+p1.printName() // "Ha"
+```
+
+上面代码在`ColorPoint`的实例`p2`上向`Point`类添加方法，结果影响到了`Point`的实例`p1`。
+
+## 原生构造函数的继承
+
+原生构造函数是指语言内置的构造函数，通常用来生成数据结构。ECMAScript 的原生构造函数大致有下面这些。
+
+- Boolean()
+- Number()
+- String()
+- Array()
+- Date()
+- Function()
+- RegExp()
+- Error()
+- Object()
+
+以前，这些原生构造函数是无法继承的，比如，不能自己定义一个`Array`的子类。
+
+```javascript
+function MyArray() {
+  Array.apply(this, arguments);
+}
+
+MyArray.prototype = Object.create(Array.prototype, {
+  constructor: {
+    value: MyArray,
+    writable: true,
+    configurable: true,
+    enumerable: true
+  }
+});
+```
+
+上面代码定义了一个继承Array的`MyArray`类。但是，这个类的行为与`Array`完全不一致。
+
+```javascript
+var colors = new MyArray();
+colors[0] = "red";
+colors.length  // 0
+
+colors.length = 0;
+colors[0]  // "red"
+```
+
+之所以会发生这种情况，是因为子类无法获得原生构造函数的内部属性，通过`Array.apply()`或者分配给原型对象都不行。原生构造函数会忽略`apply`方法传入的`this`，也就是说，原生构造函数的`this`无法绑定，导致拿不到内部属性。
+
+ES5 是先新建子类的实例对象`this`，再将父类的属性添加到子类上，由于父类的内部属性无法获取，导致无法继承原生的构造函数。比如，`Array`构造函数有一个内部属性`[[DefineOwnProperty]]`，用来定义新属性时，更新`length`属性，这个内部属性无法在子类获取，导致子类的`length`属性行为不正常。
+
+下面的例子中，我们想让一个普通对象继承`Error`对象。
+
+```javascript
+var e = {};
+
+Object.getOwnPropertyNames(Error.call(e))
+// [ 'stack' ]
+
+Object.getOwnPropertyNames(e)
+// []
+```
+
+上面代码中，我们想通过`Error.call(e)`这种写法，让普通对象`e`具有`Error`对象的实例属性。但是，`Error.call()`完全忽略传入的第一个参数，而是返回一个新对象，`e`本身没有任何变化。这证明了`Error.call(e)`这种写法，无法继承原生构造函数。
+
+ES6 允许继承原生构造函数定义子类，因为 ES6 是先新建父类的实例对象`this`，然后再用子类的构造函数修饰`this`，使得父类的所有行为都可以继承。下面是一个继承`Array`的例子。
+
+```javascript
+class MyArray extends Array {
+  constructor(...args) {
+    super(...args);
+  }
+}
+
+var arr = new MyArray();
+arr[0] = 12;
+arr.length // 1
+
+arr.length = 0;
+arr[0] // undefined
+```
+
+上面代码定义了一个`MyArray`类，继承了`Array`构造函数，因此就可以从`MyArray`生成数组的实例。这意味着，ES6 可以自定义原生数据结构（比如`Array`、`String`等）的子类，这是 ES5 无法做到的。
+
+上面这个例子也说明，`extends`关键字不仅可以用来继承类，还可以用来继承原生的构造函数。因此可以在原生数据结构的基础上，定义自己的数据结构。下面就是定义了一个带版本功能的数组。
+
+```javascript
+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.revert();
+x // [1, 2]
+```
+
+上面代码中，`VersionedArray`结构会通过`commit`方法，将自己的当前状态存入`history`属性，然后通过`revert`方法，可以撤销当前版本，回到上一个版本。除此之外，`VersionedArray`依然是一个数组，所有原生的数组方法都可以在它上面调用。
+
+下面是一个自定义`Error`子类的例子。
+
+```javascript
+class ExtendableError extends Error {
+  constructor(message) {
+    super();
+    this.message = message;
+    this.stack = (new Error()).stack;
+    this.name = this.constructor.name;
+  }
+}
+
+class MyError extends ExtendableError {
+  constructor(m) {
+    super(m);
+  }
+}
+
+var myerror = new MyError('ll');
+myerror.message // "ll"
+myerror instanceof Error // true
+myerror.name // "MyError"
+myerror.stack
+// Error
+//     at MyError.ExtendableError
+//     ...
+```
+
+注意，继承`Object`的子类，有一个[行为差异](http://stackoverflow.com/questions/36203614/super-does-not-pass-arguments-when-instantiating-a-class-extended-from-object)。
+
+```javascript
+class NewObj extends Object{
+  constructor(){
+    super(...arguments);
+  }
+}
+var o = new NewObj({attr: true});
+console.log(o.attr === true);  // false
+```
+
+上面代码中，`NewObj`继承了`Object`，但是无法通过`super`方法向父类`Object`传参。这是因为ES6改变了`Object`构造函数的行为，一旦发现`Object`方法不是通过`new Object()`这种形式调用，ES6 规定`Object`构造函数会忽略参数。
+
+## Mixin 模式的实现
+
+Mixin 模式指的是，将多个类的接口“混入”（mix in）另一个类。它在 ES6 的实现如下。
+
+```javascript
+function mix(...mixins) {
+  class Mix {}
+
+  for (let mixin of mixins) {
+    copyProperties(Mix, mixin);
+    copyProperties(Mix.prototype, mixin.prototype);
+  }
+
+  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`函数，可以将多个对象合成为一个类。使用的时候，只要继承这个类即可。
+
+```javascript
+class DistributedEdit extends mix(Loggable, Serializable) {
+  // ...
+}
+```
+
diff --git a/docs/class.md b/docs/class.md
index 6fc4e4d..a3ce576 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1,10 +1,8 @@
-# Class
+# Class 的基本语法
 
-## Class基本语法
+## 简介
 
-### 概述
-
-在 JavaScript 语言中，生成实例对象的传统方法是通过构造函数。下面是一个例子。
+JavaScript 语言中，生成实例对象的传统方法是通过构造函数。下面是一个例子。
 
 ```javascript
 function Point(x, y) {
@@ -21,7 +19,9 @@ var p = new Point(1, 2);
 
 上面这种写法跟传统的面向对象语言（比如 C++ 和 Java）差异很大，很容易让新学习这门语言的程序员感到困惑。
 
-ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过`class`关键字，可以定义类。基本上，ES6 的`class`可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的`class`写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的代码用 ES6 的`class`改写，就是下面这样。
+ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过`class`关键字，可以定义类。
+
+基本上，ES6 的`class`可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的`class`写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。上面的代码用 ES6 的`class`改写，就是下面这样。
 
 ```javascript
 //定义类
@@ -37,11 +37,11 @@ class Point {
 }
 ```
 
-上面代码定义了一个“类”，可以看到里面有一个`constructor`方法，这就是构造方法，而`this`关键字则代表实例对象。也就是说，ES5的构造函数`Point`，对应ES6的`Point`类的构造方法。
+上面代码定义了一个“类”，可以看到里面有一个`constructor`方法，这就是构造方法，而`this`关键字则代表实例对象。也就是说，ES5 的构造函数`Point`，对应 ES6 的`Point`类的构造方法。
 
 `Point`类除了构造方法，还定义了一个`toString`方法。注意，定义“类”的方法的时候，前面不需要加上`function`这个关键字，直接把函数定义放进去了就可以了。另外，方法之间不需要逗号分隔，加了会报错。
 
-ES6的类，完全可以看作构造函数的另一种写法。
+ES6 的类，完全可以看作构造函数的另一种写法。
 
 ```javascript
 class Point {
@@ -67,19 +67,19 @@ var b = new Bar();
 b.doStuff() // "stuff"
 ```
 
-构造函数的`prototype`属性，在ES6的“类”上面继续存在。事实上，类的所有方法都定义在类的`prototype`属性上面。
+构造函数的`prototype`属性，在 ES6 的“类”上面继续存在。事实上，类的所有方法都定义在类的`prototype`属性上面。
 
 ```javascript
 class Point {
-  constructor(){
+  constructor() {
     // ...
   }
 
-  toString(){
+  toString() {
     // ...
   }
 
-  toValue(){
+  toValue() {
     // ...
   }
 }
@@ -87,8 +87,9 @@ class Point {
 // 等同于
 
 Point.prototype = {
-  toString(){},
-  toValue(){}
+  constructor() {},
+  toString() {},
+  toValue() {},
 };
 ```
 
@@ -101,7 +102,7 @@ let b = new B();
 b.constructor === B.prototype.constructor // true
 ```
 
-上面代码中，`b`是B类的实例，它的`constructor`方法就是B类原型的`constructor`方法。
+上面代码中，`b`是`B`类的实例，它的`constructor`方法就是`B`类原型的`constructor`方法。
 
 由于类的方法都定义在`prototype`对象上面，所以类的新方法可以添加在`prototype`对象上面。`Object.assign`方法可以很方便地一次向类添加多个方法。
 
@@ -118,7 +119,7 @@ Object.assign(Point.prototype, {
 });
 ```
 
-`prototype`对象的`constructor`属性，直接指向“类”的本身，这与ES5的行为是一致的。
+`prototype`对象的`constructor`属性，直接指向“类”的本身，这与 ES5 的行为是一致的。
 
 ```javascript
 Point.prototype.constructor === Point // true
@@ -143,7 +144,7 @@ Object.getOwnPropertyNames(Point.prototype)
 // ["constructor","toString"]
 ```
 
-上面代码中，`toString`方法是`Point`类内部定义的方法，它是不可枚举的。这一点与ES5的行为不一致。
+上面代码中，`toString`方法是`Point`类内部定义的方法，它是不可枚举的。这一点与 ES5 的行为不一致。
 
 ```javascript
 var Point = function (x, y) {
@@ -160,13 +161,14 @@ Object.getOwnPropertyNames(Point.prototype)
 // ["constructor","toString"]
 ```
 
-上面代码采用ES5的写法，`toString`方法就是可枚举的。
+上面代码采用 ES5 的写法，`toString`方法就是可枚举的。
 
 类的属性名，可以采用表达式。
 
 ```javascript
-let methodName = "getArea";
-class Square{
+let methodName = 'getArea';
+
+class Square {
   constructor(length) {
     // ...
   }
@@ -179,14 +181,28 @@ class Square{
 
 上面代码中，`Square`类的方法名`getArea`，是从表达式得到的。
 
-### constructor方法
+## 严格模式
+
+类和模块的内部，默认就是严格模式，所以不需要使用`use strict`指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。
+
+考虑到未来所有的代码，其实都是运行在模块之中，所以 ES6 实际上把整个语言升级到了严格模式。
+
+## constructor 方法
 
 `constructor`方法是类的默认方法，通过`new`命令生成对象实例时，自动调用该方法。一个类必须有`constructor`方法，如果没有显式定义，一个空的`constructor`方法会被默认添加。
 
 ```javascript
-constructor() {}
+class Point {
+}
+
+// 等同于
+class Point {
+  constructor() {}
+}
 ```
 
+上面代码中，定义了一个空的类`Point`，JavaScript 引擎会自动为它添加一个空的`constructor`方法。
+
 `constructor`方法默认返回实例对象（即`this`），完全可以指定返回另外一个对象。
 
 ```javascript
@@ -202,7 +218,7 @@ new Foo() instanceof Foo
 
 上面代码中，`constructor`函数返回一个全新的对象，结果导致实例对象不是`Foo`类的实例。
 
-类的构造函数，不使用`new`是没法调用的，会报错。这是它跟普通构造函数的一个主要区别，后者不用`new`也可以执行。
+类必须使用`new`调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用`new`也可以执行。
 
 ```javascript
 class Foo {
@@ -215,11 +231,15 @@ Foo()
 // TypeError: Class constructor Foo cannot be invoked without 'new'
 ```
 
-### 类的实例对象
+## 类的实例对象
 
-生成类的实例对象的写法，与ES5完全一样，也是使用`new`命令。如果忘记加上`new`，像函数那样调用`Class`，将会报错。
+生成类的实例对象的写法，与 ES5 完全一样，也是使用`new`命令。前面说过，如果忘记加上`new`，像函数那样调用`Class`，将会报错。
 
 ```javascript
+class Point {
+  // ...
+}
+
 // 报错
 var point = Point(2, 3);
 
@@ -227,7 +247,7 @@ var point = Point(2, 3);
 var point = new Point(2, 3);
 ```
 
-与ES5一样，实例的属性除非显式定义在其本身（即定义在`this`对象上），否则都是定义在原型上（即定义在`class`上）。
+与 ES5 一样，实例的属性除非显式定义在其本身（即定义在`this`对象上），否则都是定义在原型上（即定义在`class`上）。
 
 ```javascript
 //定义类
@@ -254,9 +274,9 @@ point.hasOwnProperty('toString') // false
 point.__proto__.hasOwnProperty('toString') // true
 ```
 
-上面代码中，`x`和`y`都是实例对象`point`自身的属性（因为定义在`this`变量上），所以`hasOwnProperty`方法返回`true`，而`toString`是原型对象的属性（因为定义在`Point`类上），所以`hasOwnProperty`方法返回`false`。这些都与ES5的行为保持一致。
+上面代码中，`x`和`y`都是实例对象`point`自身的属性（因为定义在`this`变量上），所以`hasOwnProperty`方法返回`true`，而`toString`是原型对象的属性（因为定义在`Point`类上），所以`hasOwnProperty`方法返回`false`。这些都与 ES5 的行为保持一致。
 
-与ES5一样，类的所有实例共享一个原型对象。
+与 ES5 一样，类的所有实例共享一个原型对象。
 
 ```javascript
 var p1 = new Point(2,3);
@@ -266,9 +286,9 @@ p1.__proto__ === p2.__proto__
 //true
 ```
 
-上面代码中，`p1`和`p2`都是Point的实例，它们的原型都是Point.prototype，所以`__proto__`属性是相等的。
+上面代码中，`p1`和`p2`都是`Point`的实例，它们的原型都是`Point.prototype`，所以`__proto__`属性是相等的。
 
-这也意味着，可以通过实例的`__proto__`属性为Class添加方法。
+这也意味着，可以通过实例的`__proto__`属性为“类”添加方法。
 
 ```javascript
 var p1 = new Point(2,3);
@@ -283,30 +303,9 @@ var p3 = new Point(4,2);
 p3.printName() // "Oops"
 ```
 
-上面代码在`p1`的原型上添加了一个`printName`方法，由于`p1`的原型就是`p2`的原型，因此`p2`也可以调用这个方法。而且，此后新建的实例`p3`也可以调用这个方法。这意味着，使用实例的`__proto__`属性改写原型，必须相当谨慎，不推荐使用，因为这会改变Class的原始定义，影响到所有实例。
+上面代码在`p1`的原型上添加了一个`printName`方法，由于`p1`的原型就是`p2`的原型，因此`p2`也可以调用这个方法。而且，此后新建的实例`p3`也可以调用这个方法。这意味着，使用实例的`__proto__`属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例。
 
-### 不存在变量提升
-
-Class不存在变量提升（hoist），这一点与ES5完全不同。
-
-```javascript
-new Foo(); // ReferenceError
-class Foo {}
-```
-
-上面代码中，`Foo`类使用在前，定义在后，这样会报错，因为ES6不会把类的声明提升到代码头部。这种规定的原因与下文要提到的继承有关，必须保证子类在父类之后定义。
-
-```javascript
-{
-  let Foo = class {};
-  class Bar extends Foo {
-  }
-}
-```
-
-上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而`let`命令是不提升的，所以导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
-
-### Class表达式
+## Class 表达式
 
 与函数一样，类也可以使用表达式的形式定义。
 
@@ -318,7 +317,7 @@ const MyClass = class Me {
 };
 ```
 
-上面代码使用表达式定义了一个类。需要注意的是，这个类的名字是`MyClass`而不是`Me`，`Me`只在Class的内部代码可用，指代当前类。
+上面代码使用表达式定义了一个类。需要注意的是，这个类的名字是`MyClass`而不是`Me`，`Me`只在 Class 的内部代码可用，指代当前类。
 
 ```javascript
 let inst = new MyClass();
@@ -326,7 +325,7 @@ inst.getClassName() // Me
 Me.name // ReferenceError: Me is not defined
 ```
 
-上面代码表示，`Me`只在Class内部有定义。
+上面代码表示，`Me`只在 Class 内部有定义。
 
 如果类的内部没用到的话，可以省略`Me`，也就是可以写成下面的形式。
 
@@ -334,7 +333,7 @@ Me.name // ReferenceError: Me is not defined
 const MyClass = class { /* ... */ };
 ```
 
-采用Class表达式，可以写出立即执行的Class。
+采用 Class 表达式，可以写出立即执行的 Class。
 
 ```javascript
 let person = new class {
@@ -352,7 +351,28 @@ person.sayName(); // "张三"
 
 上面代码中，`person`是一个立即执行的类的实例。
 
-### 私有方法
+## 不存在变量提升
+
+类不存在变量提升（hoist），这一点与 ES5 完全不同。
+
+```javascript
+new Foo(); // ReferenceError
+class Foo {}
+```
+
+上面代码中，`Foo`类使用在前，定义在后，这样会报错，因为 ES6 不会把类的声明提升到代码头部。这种规定的原因与下文要提到的继承有关，必须保证子类在父类之后定义。
+
+```javascript
+{
+  let Foo = class {};
+  class Bar extends Foo {
+  }
+}
+```
+
+上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而`let`命令是不提升的，所以导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
+
+## 私有方法
 
 私有方法是常见需求，但 ES6 不提供，只能通过变通方法模拟实现。
 
@@ -419,7 +439,51 @@ export default class myClass{
 
 上面代码中，`bar`和`snaf`都是`Symbol`值，导致第三方无法获取到它们，因此达到了私有方法和私有属性的效果。
 
-### this的指向
+## 私有属性
+
+与私有方法一样，ES6 不支持私有属性。目前，有一个[提案](https://github.com/tc39/proposal-private-fields)，为`class`加了私有属性。方法是在属性名之前，使用`#`表示。
+
+```javascript
+class Point {
+  #x;
+
+  constructor(x = 0) {
+    #x = +x;
+  }
+
+  get x() { return #x }
+  set x(value) { #x = +value }
+}
+```
+
+上面代码中，`#x`就表示私有属性`x`，在`Point`类之外是读取不到这个属性的。还可以看到，私有属性与实例的属性是可以同名的（比如，`#x`与`get x()`）。
+
+私有属性可以指定初始值，在构造函数执行时进行初始化。
+
+```javascript
+class Point {
+  #x = 0;
+  constructor() {
+    #x; // 0
+  }
+}
+```
+
+之所以要引入一个新的前缀`#`表示私有属性，而没有采用`private`关键字，是因为 JavaScript 是一门动态语言，使用独立的符号似乎是唯一的可靠方法，能够准确地区分一种属性是否为私有属性。另外，Ruby 语言使用`@`表示私有属性，ES6 没有用这个符号而使用`#`，是因为`@`已经被留给了 Decorator。
+
+该提案只规定了私有属性的写法。但是，很自然地，它也可以用来写私有方法。
+
+```javascript
+class Foo {
+  #a;
+  #b;
+  #sum() { return #a + #b; }
+  printSum() { console.log(#sum()); }
+  constructor(a, b) { #a = a; #b = b; }
+}
+```
+
+## this 的指向
 
 类的方法内部如果含有`this`，它默认指向类的实例。但是，必须非常小心，一旦单独使用该方法，很可能报错。
 
@@ -491,15 +555,9 @@ function selfish (target) {
 const logger = selfish(new Logger());
 ```
 
-### 严格模式
+## name 属性
 
-类和模块的内部，默认就是严格模式，所以不需要使用`use strict`指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。
-
-考虑到未来所有的代码，其实都是运行在模块之中，所以ES6实际上把整个语言升级到了严格模式。
-
-### name属性
-
-由于本质上，ES6的类只是ES5的构造函数的一层包装，所以函数的许多特性都被`Class`继承，包括`name`属性。
+由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被`Class`继承，包括`name`属性。
 
 ```javascript
 class Point {}
@@ -508,644 +566,9 @@ Point.name // "Point"
 
 `name`属性总是返回紧跟在`class`关键字后面的类名。
 
-## Class的继承
+## Class 的取值函数（getter）和存值函数（setter）
 
-### 基本用法
-
-Class之间可以通过`extends`关键字实现继承，这比ES5的通过修改原型链实现继承，要清晰和方便很多。
-
-```javascript
-class ColorPoint extends Point {}
-```
-
-上面代码定义了一个`ColorPoint`类，该类通过`extends`关键字，继承了`Point`类的所有属性和方法。但是由于没有部署任何代码，所以这两个类完全一样，等于复制了一个`Point`类。下面，我们在`ColorPoint`内部加上代码。
-
-```javascript
-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`对象，而是继承父类的`this`对象，然后对其进行加工。如果不调用`super`方法，子类就得不到`this`对象。
-
-```javascript
-class Point { /* ... */ }
-
-class ColorPoint extends Point {
-  constructor() {
-  }
-}
-
-let cp = new ColorPoint(); // ReferenceError
-```
-
-上面代码中，`ColorPoint`继承了父类`Point`，但是它的构造函数没有调用`super`方法，导致新建实例时报错。
-
-ES5的继承，实质是先创造子类的实例对象`this`，然后再将父类的方法添加到`this`上面（`Parent.apply(this)`）。ES6的继承机制完全不同，实质是先创造父类的实例对象`this`（所以必须先调用`super`方法），然后再用子类的构造函数修改`this`。
-
-如果子类没有定义`constructor`方法，这个方法会被默认添加，代码如下。也就是说，不管有没有显式定义，任何一个子类都有`constructor`方法。
-
-```javascript
-constructor(...args) {
-  super(...args);
-}
-```
-
-另一个需要注意的地方是，在子类的构造函数中，只有调用`super`之后，才可以使用`this`关键字，否则会报错。这是因为子类实例的构建，是基于对父类实例加工，只有`super`方法才能返回父类实例。
-
-```javascript
-class Point {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-  }
-}
-
-class ColorPoint extends Point {
-  constructor(x, y, color) {
-    this.color = color; // ReferenceError
-    super(x, y);
-    this.color = color; // 正确
-  }
-}
-```
-
-上面代码中，子类的`constructor`方法没有调用`super`之前，就使用`this`关键字，结果报错，而放在`super`方法之后就是正确的。
-
-下面是生成子类实例的代码。
-
-```javascript
-let cp = new ColorPoint(25, 8, 'green');
-
-cp instanceof ColorPoint // true
-cp instanceof Point // true
-```
-
-上面代码中，实例对象`cp`同时是`ColorPoint`和`Point`两个类的实例，这与ES5的行为完全一致。
-
-### 类的prototype属性和\_\_proto\_\_属性
-
-大多数浏览器的ES5实现之中，每一个对象都有`__proto__`属性，指向对应的构造函数的prototype属性。Class作为构造函数的语法糖，同时有prototype属性和`__proto__`属性，因此同时存在两条继承链。
-
-（1）子类的`__proto__`属性，表示构造函数的继承，总是指向父类。
-
-（2）子类`prototype`属性的`__proto__`属性，表示方法的继承，总是指向父类的`prototype`属性。
-
-```javascript
-class A {
-}
-
-class B extends A {
-}
-
-B.__proto__ === A // true
-B.prototype.__proto__ === A.prototype // true
-```
-
-上面代码中，子类`B`的`__proto__`属性指向父类`A`，子类`B`的`prototype`属性的`__proto__`属性指向父类`A`的`prototype`属性。
-
-这样的结果是因为，类的继承是按照下面的模式实现的。
-
-```javascript
-class A {
-}
-
-class B {
-}
-
-// B的实例继承A的实例
-Object.setPrototypeOf(B.prototype, A.prototype);
-const b = new B();
-
-// B的实例继承A的静态属性
-Object.setPrototypeOf(B, A);
-const b = new B();
-```
-
-《对象的扩展》一章给出过`Object.setPrototypeOf`方法的实现。
-
-```javascript
-Object.setPrototypeOf = function (obj, proto) {
-  obj.__proto__ = proto;
-  return obj;
-}
-```
-
-因此，就得到了上面的结果。
-
-```javascript
-Object.setPrototypeOf(B.prototype, A.prototype);
-// 等同于
-B.prototype.__proto__ = A.prototype;
-
-Object.setPrototypeOf(B, A);
-// 等同于
-B.__proto__ = A;
-```
-
-这两条继承链，可以这样理解：作为一个对象，子类（`B`）的原型（`__proto__`属性）是父类（`A`）；作为一个构造函数，子类（`B`）的原型（`prototype`属性）是父类的实例。
-
-```javascript
-Object.create(A.prototype);
-// 等同于
-B.prototype.__proto__ = A.prototype;
-```
-
-### Extends 的继承目标
-
-`extends`关键字后面可以跟多种类型的值。
-
-```javascript
-class B extends A {
-}
-```
-
-上面代码的`A`，只要是一个有`prototype`属性的函数，就能被`B`继承。由于函数都有`prototype`属性（除了`Function.prototype`函数），因此`A`可以是任意函数。
-
-下面，讨论三种特殊情况。
-
-第一种特殊情况，子类继承Object类。
-
-```javascript
-class A extends Object {
-}
-
-A.__proto__ === Object // true
-A.prototype.__proto__ === Object.prototype // true
-```
-
-这种情况下，`A`其实就是构造函数`Object`的复制，`A`的实例就是`Object`的实例。
-
-第二种特殊情况，不存在任何继承。
-
-```javascript
-class A {
-}
-
-A.__proto__ === Function.prototype // true
-A.prototype.__proto__ === Object.prototype // true
-```
-
-这种情况下，A作为一个基类（即不存在任何继承），就是一个普通函数，所以直接继承`Function.prototype`。但是，`A`调用后返回一个空对象（即`Object`实例），所以`A.prototype.__proto__`指向构造函数（`Object`）的`prototype`属性。
-
-第三种特殊情况，子类继承`null`。
-
-```javascript
-class A extends null {
-}
-
-A.__proto__ === Function.prototype // true
-A.prototype.__proto__ === undefined // true
-```
-
-这种情况与第二种情况非常像。`A`也是一个普通函数，所以直接继承`Function.prototype`。但是，A调用后返回的对象不继承任何方法，所以它的`__proto__`指向`Function.prototype`，即实质上执行了下面的代码。
-
-```javascript
-class C extends null {
-  constructor() { return Object.create(null); }
-}
-```
-
-### Object.getPrototypeOf()
-
-`Object.getPrototypeOf`方法可以用来从子类上获取父类。
-
-```javascript
-Object.getPrototypeOf(ColorPoint) === Point
-// true
-```
-
-因此，可以使用这个方法判断，一个类是否继承了另一个类。
-
-### super 关键字
-
-`super`这个关键字，既可以当作函数使用，也可以当作对象使用。在这两种情况下，它的用法完全不同。
-
-第一种情况，`super`作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次`super`函数。
-
-```javascript
-class A {}
-
-class B extends A {
-  constructor() {
-    super();
-  }
-}
-```
-
-上面代码中，子类`B`的构造函数之中的`super()`，代表调用父类的构造函数。这是必须的，否则 JavaScript 引擎会报错。
-
-注意，`super`虽然代表了父类`A`的构造函数，但是返回的是子类`B`的实例，即`super`内部的`this`指的是`B`，因此`super()`在这里相当于`A.prototype.constructor.call(this)`。
-
-```javascript
-class A {
-  constructor() {
-    console.log(new.target.name);
-  }
-}
-class B extends A {
-  constructor() {
-    super();
-  }
-}
-new A() // A
-new B() // B
-```
-
-上面代码中，`new.target`指向当前正在执行的函数。可以看到，在`super()`执行时，它指向的是子类`B`的构造函数，而不是父类`A`的构造函数。也就是说，`super()`内部的`this`指向的是`B`。
-
-作为函数时，`super()`只能用在子类的构造函数之中，用在其他地方就会报错。
-
-```javascript
-class A {}
-
-class B extends A {
-  m() {
-    super(); // 报错
-  }
-}
-```
-
-上面代码中，`super()`用在`B`类的`m`方法之中，就会造成句法错误。
-
-第二种情况，`super`作为对象时，在普通方法中，指向父类的原型对象；在静态方法中，指向父类。
-
-```javascript
-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`调用的。
-
-```javascript
-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`就引用不到它。
-
-如果属性定义在父类的原型对象上，`super`就可以取到。
-
-```javascript
-class A {}
-A.prototype.x = 2;
-
-class B extends A {
-  constructor() {
-    super();
-    console.log(super.x) // 2
-  }
-}
-
-let b = new B();
-```
-
-上面代码中，属性`x`是定义在`A.prototype`上面的，所以`super.x`可以取到它的值。
-
-ES6 规定，通过`super`调用父类的方法时，`super`会绑定子类的`this`。
-
-```javascript
-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()`会绑定子类`B`的`this`，导致输出的是`2`，而不是`1`。也就是说，实际上执行的是`super.print.call(this)`。
-
-由于绑定子类的`this`，所以如果通过`super`对某个属性赋值，这时`super`就是`this`，赋值的属性会变成子类实例的属性。
-
-```javascript
-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`将指向父类，而不是父类的原型对象。
-
-```javascript
-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`的时候，必须显式指定是作为函数、还是作为对象使用，否则会报错。
-
-```javascript
-class A {}
-
-class B extends A {
-  constructor() {
-    super();
-    console.log(super); // 报错
-  }
-}
-```
-
-上面代码中，`console.log(super)`当中的`super`，无法看出是作为函数使用，还是作为对象使用，所以 JavaScript 引擎解析代码的时候就会报错。这时，如果能清晰地表明`super`的数据类型，就不会报错。
-
-```javascript
-class A {}
-
-class B extends A {
-  constructor() {
-    super();
-    console.log(super.valueOf() instanceof B); // true
-  }
-}
-
-let b = new B();
-```
-
-上面代码中，`super.valueOf()`表明`super`是一个对象，因此就不会报错。同时，由于`super`绑定`B`的`this`，所以`super.valueOf()`返回的是一个`B`的实例。
-
-最后，由于对象总是继承其他对象的，所以可以在任意一个对象中，使用`super`关键字。
-
-```javascript
-var obj = {
-  toString() {
-    return "MyObject: " + super.toString();
-  }
-};
-
-obj.toString(); // MyObject: [object Object]
-```
-
-### 实例的\_\_proto\_\_属性
-
-子类实例的\_\_proto\_\_属性的\_\_proto\_\_属性，指向父类实例的\_\_proto\_\_属性。也就是说，子类的原型的原型，是父类的原型。
-
-```javascript
-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__`属性，可以修改父类实例的行为。
-
-```javascript
-p2.__proto__.__proto__.printName = function () {
-  console.log('Ha');
-};
-
-p1.printName() // "Ha"
-```
-
-上面代码在`ColorPoint`的实例`p2`上向`Point`类添加方法，结果影响到了`Point`的实例`p1`。
-
-## 原生构造函数的继承
-
-原生构造函数是指语言内置的构造函数，通常用来生成数据结构。ECMAScript的原生构造函数大致有下面这些。
-
-- Boolean()
-- Number()
-- String()
-- Array()
-- Date()
-- Function()
-- RegExp()
-- Error()
-- Object()
-
-以前，这些原生构造函数是无法继承的，比如，不能自己定义一个`Array`的子类。
-
-```javascript
-function MyArray() {
-  Array.apply(this, arguments);
-}
-
-MyArray.prototype = Object.create(Array.prototype, {
-  constructor: {
-    value: MyArray,
-    writable: true,
-    configurable: true,
-    enumerable: true
-  }
-});
-```
-
-上面代码定义了一个继承Array的`MyArray`类。但是，这个类的行为与`Array`完全不一致。
-
-```javascript
-var colors = new MyArray();
-colors[0] = "red";
-colors.length  // 0
-
-colors.length = 0;
-colors[0]  // "red"
-```
-
-之所以会发生这种情况，是因为子类无法获得原生构造函数的内部属性，通过`Array.apply()`或者分配给原型对象都不行。原生构造函数会忽略`apply`方法传入的`this`，也就是说，原生构造函数的`this`无法绑定，导致拿不到内部属性。
-
-ES5是先新建子类的实例对象`this`，再将父类的属性添加到子类上，由于父类的内部属性无法获取，导致无法继承原生的构造函数。比如，Array构造函数有一个内部属性`[[DefineOwnProperty]]`，用来定义新属性时，更新`length`属性，这个内部属性无法在子类获取，导致子类的`length`属性行为不正常。
-
-下面的例子中，我们想让一个普通对象继承`Error`对象。
-
-```javascript
-var e = {};
-
-Object.getOwnPropertyNames(Error.call(e))
-// [ 'stack' ]
-
-Object.getOwnPropertyNames(e)
-// []
-```
-
-上面代码中，我们想通过`Error.call(e)`这种写法，让普通对象`e`具有`Error`对象的实例属性。但是，`Error.call()`完全忽略传入的第一个参数，而是返回一个新对象，`e`本身没有任何变化。这证明了`Error.call(e)`这种写法，无法继承原生构造函数。
-
-ES6允许继承原生构造函数定义子类，因为ES6是先新建父类的实例对象`this`，然后再用子类的构造函数修饰`this`，使得父类的所有行为都可以继承。下面是一个继承`Array`的例子。
-
-```javascript
-class MyArray extends Array {
-  constructor(...args) {
-    super(...args);
-  }
-}
-
-var arr = new MyArray();
-arr[0] = 12;
-arr.length // 1
-
-arr.length = 0;
-arr[0] // undefined
-```
-
-上面代码定义了一个`MyArray`类，继承了`Array`构造函数，因此就可以从`MyArray`生成数组的实例。这意味着，ES6可以自定义原生数据结构（比如Array、String等）的子类，这是ES5无法做到的。
-
-上面这个例子也说明，`extends`关键字不仅可以用来继承类，还可以用来继承原生的构造函数。因此可以在原生数据结构的基础上，定义自己的数据结构。下面就是定义了一个带版本功能的数组。
-
-```javascript
-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.revert();
-x // [1, 2]
-```
-
-上面代码中，`VersionedArray`结构会通过`commit`方法，将自己的当前状态存入`history`属性，然后通过`revert`方法，可以撤销当前版本，回到上一个版本。除此之外，`VersionedArray`依然是一个数组，所有原生的数组方法都可以在它上面调用。
-
-下面是一个自定义`Error`子类的例子。
-
-```javascript
-class ExtendableError extends Error {
-  constructor(message) {
-    super();
-    this.message = message;
-    this.stack = (new Error()).stack;
-    this.name = this.constructor.name;
-  }
-}
-
-class MyError extends ExtendableError {
-  constructor(m) {
-    super(m);
-  }
-}
-
-var myerror = new MyError('ll');
-myerror.message // "ll"
-myerror instanceof Error // true
-myerror.name // "MyError"
-myerror.stack
-// Error
-//     at MyError.ExtendableError
-//     ...
-```
-
-注意，继承`Object`的子类，有一个[行为差异](http://stackoverflow.com/questions/36203614/super-does-not-pass-arguments-when-instantiating-a-class-extended-from-object)。
-
-```javascript
-class NewObj extends Object{
-  constructor(){
-    super(...arguments);
-  }
-}
-var o = new NewObj({attr: true});
-console.log(o.attr === true);  // false
-```
-
-上面代码中，`NewObj`继承了`Object`，但是无法通过`super`方法向父类`Object`传参。这是因为ES6改变了`Object`构造函数的行为，一旦发现`Object`方法不是通过`new Object()`这种形式调用，ES6规定`Object`构造函数会忽略参数。
-
-## Class的取值函数（getter）和存值函数（setter）
-
-与ES5一样，在Class内部可以使用`get`和`set`关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为。
+与 ES5 一样，在“类”的内部可以使用`get`和`set`关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为。
 
 ```javascript
 class MyClass {
@@ -1171,7 +594,7 @@ inst.prop
 
 上面代码中，`prop`属性有对应的存值函数和取值函数，因此赋值和读取行为都被自定义了。
 
-存值函数和取值函数是设置在属性的descriptor对象上的。
+存值函数和取值函数是设置在属性的 Descriptor 对象上的。
 
 ```javascript
 class CustomHTMLElement {
@@ -1189,12 +612,14 @@ class CustomHTMLElement {
 }
 
 var descriptor = Object.getOwnPropertyDescriptor(
-  CustomHTMLElement.prototype, "html");
+  CustomHTMLElement.prototype, "html"
+);
+
 "get" in descriptor  // true
 "set" in descriptor  // true
 ```
 
-上面代码中，存值函数和取值函数是定义在`html`属性的描述对象上面，这与ES5完全一致。
+上面代码中，存值函数和取值函数是定义在`html`属性的描述对象上面，这与 ES5 完全一致。
 
 ## Class 的 Generator 方法
 
@@ -1253,7 +678,7 @@ class Foo {
 class Bar extends Foo {
 }
 
-Bar.classMethod(); // 'hello'
+Bar.classMethod() // 'hello'
 ```
 
 上面代码中，父类`Foo`有一个静态方法，子类`Bar`可以调用这个方法。
@@ -1273,12 +698,12 @@ class Bar extends Foo {
   }
 }
 
-Bar.classMethod();
+Bar.classMethod() // "hello, too"
 ```
 
-## Class的静态属性和实例属性
+## Class 的静态属性和实例属性
 
-静态属性指的是Class本身的属性，即`Class.propname`，而不是定义在实例对象（`this`）上的属性。
+静态属性指的是 Class 本身的属性，即`Class.propName`，而不是定义在实例对象（`this`）上的属性。
 
 ```javascript
 class Foo {
@@ -1290,7 +715,7 @@ Foo.prop // 1
 
 上面的写法为`Foo`类定义了一个静态属性`prop`。
 
-目前，只有这种写法可行，因为ES6明确规定，Class内部只有静态方法，没有静态属性。
+目前，只有这种写法可行，因为 ES6 明确规定，Class 内部只有静态方法，没有静态属性。
 
 ```javascript
 // 以下两种写法都无效
@@ -1305,7 +730,7 @@ class Foo {
 Foo.prop // undefined
 ```
 
-ES7有一个静态属性的[提案](https://github.com/jeffmo/es-class-properties)，目前Babel转码器支持。
+ES7 有一个静态属性的[提案](https://github.com/jeffmo/es-class-properties)，目前 Babel 转码器支持。
 
 这个提案对实例属性和静态属性，都规定了新的写法。
 
@@ -1385,6 +810,7 @@ class MyClass {
 ```javascript
 // 老写法
 class Foo {
+  // ...
 }
 Foo.prop = 1;
 
@@ -1396,53 +822,9 @@ class Foo {
 
 上面代码中，老写法的静态属性定义在类的外部。整个类生成以后，再生成静态属性。这样让人很容易忽略这个静态属性，也不符合相关代码应该放在一起的代码组织原则。另外，新写法是显式声明（declarative），而不是赋值处理，语义更好。
 
-## 类的私有属性
-
-目前，有一个[提案](https://github.com/tc39/proposal-private-fields)，为`class`加了私有属性。方法是在属性名之前，使用`#`表示。
-
-```javascript
-class Point {
-  #x;
-
-  constructor(x = 0) {
-    #x = +x;
-  }
-
-  get x() { return #x }
-  set x(value) { #x = +value }
-}
-```
-
-上面代码中，`#x`就表示私有属性`x`，在`Point`类之外是读取不到这个属性的。还可以看到，私有属性与实例的属性是可以同名的（比如，`#x`与`get x()`）。
-
-私有属性可以指定初始值，在构造函数执行时进行初始化。
-
-```javascript
-class Point {
-  #x = 0;
-  constructor() {
-    #x; // 0
-  }
-}
-```
-
-之所以要引入一个新的前缀`#`表示私有属性，而没有采用`private`关键字，是因为 JavaScript 是一门动态语言，使用独立的符号似乎是唯一的可靠方法，能够准确地区分一种属性是私有属性。另外，Ruby 语言使用`@`表示私有属性，ES6 没有用这个符号而使用`#`，是因为`@`已经被留给了 Decorator。
-
-该提案只规定了私有属性的写法。但是，很自然地，它也可以用来写私有方法。
-
-```javascript
-class Foo {
-  #a;
-  #b;
-  #sum() { return #a + #b; }
-  printSum() { console.log(#sum()); }
-  constructor(a, b) { #a = a; #b = b; }
-}
-```
-
 ## new.target属性
 
-`new`是从构造函数生成实例的命令。ES6为`new`命令引入了一个`new.target`属性，（在构造函数中）返回`new`命令作用于的那个构造函数。如果构造函数不是通过`new`命令调用的，`new.target`会返回`undefined`，因此这个属性可以用来确定构造函数是怎么调用的。
+`new`是从构造函数生成实例的命令。ES6 为`new`命令引入了一个`new.target`属性，该属性一般用在在构造函数之中，返回`new`命令作用于的那个构造函数。如果构造函数不是通过`new`命令调用的，`new.target`会返回`undefined`，因此这个属性可以用来确定构造函数是怎么调用的。
 
 ```javascript
 function Person(name) {
@@ -1458,7 +840,7 @@ function Person(name) {
   if (new.target === Person) {
     this.name = name;
   } else {
-    throw new Error('必须使用new生成实例');
+    throw new Error('必须使用 new 生成实例');
   }
 }
 
@@ -1468,7 +850,7 @@ var notAPerson = Person.call(person, '张三');  // 报错
 
 上面代码确保构造函数只能通过`new`命令调用。
 
-Class内部调用`new.target`，返回当前Class。
+Class 内部调用`new.target`，返回当前 Class。
 
 ```javascript
 class Rectangle {
@@ -1529,39 +911,3 @@ var y = new Rectangle(3, 4);  // 正确
 
 注意，在函数外部，使用`new.target`会报错。
 
-## Mixin模式的实现
-
-Mixin模式指的是，将多个类的接口“混入”（mix in）另一个类。它在ES6的实现如下。
-
-```javascript
-function mix(...mixins) {
-  class Mix {}
-
-  for (let mixin of mixins) {
-    copyProperties(Mix, mixin);
-    copyProperties(Mix.prototype, mixin.prototype);
-  }
-
-  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`函数，可以将多个对象合成为一个类。使用的时候，只要继承这个类即可。
-
-```javascript
-class DistributedEdit extends mix(Loggable, Serializable) {
-  // ...
-}
-```
diff --git a/docs/let.md b/docs/let.md
index b46ae13..abea7be 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -1,10 +1,10 @@
-# let和const命令
+# let 和 const 命令
 
-## let命令
+## let 命令
 
 ### 基本用法
 
-ES6新增了`let`命令，用来声明变量。它的用法类似于`var`，但是所声明的变量，只在`let`命令所在的代码块内有效。
+ES6 新增了`let`命令，用来声明变量。它的用法类似于`var`，但是所声明的变量，只在`let`命令所在的代码块内有效。
 
 ```javascript
 {
@@ -21,10 +21,12 @@ b // 1
 `for`循环的计数器，就很合适使用`let`命令。
 
 ```javascript
-for (let i = 0; i < 10; i++) {}
+for (let i = 0; i < 10; i++) {
+  // ...
+}
 
 console.log(i);
-//ReferenceError: i is not defined
+// ReferenceError: i is not defined
 ```
 
 上面代码中，计数器`i`只在`for`循环体内有效，在循环体外引用就会报错。
@@ -41,9 +43,9 @@ for (var i = 0; i < 10; i++) {
 a[6](); // 10
 ```
 
-上面代码中，变量`i`是`var`声明的，在全局范围内都有效，所以全局只有一个变量`i`。每一次循环，变量`i`的值都会发生改变，而循环内被赋给数组`a`的`function`在运行时，会通过闭包读到这同一个变量`i`，导致最后输出的是最后一轮的`i`的值，也就是10。
+上面代码中，变量`i`是`var`命令声明的，在全局范围内都有效，所以全局只有一个变量`i`。每一次循环，变量`i`的值都会发生改变，而循环内被赋给数组`a`的函数内部的`console.log(i)`，里面的`i`指向的就是全局的`i`。也就是说，所有数组`a`的成员里面的`i`，指向的都是同一个`i`，导致运行时输出的是最后一轮的`i`的值，也就是10。
 
-而如果使用`let`，声明的变量仅在块级作用域内有效，最后输出的是6。
+如果使用`let`，声明的变量仅在块级作用域内有效，最后输出的是6。
 
 ```javascript
 var a = [];
@@ -69,7 +71,7 @@ for (let i = 0; i < 3; i++) {
 // abc
 ```
 
-上面代码输出了3次`abc`，这表明函数内部的变量`i`不同于循环变量`i`，有自己单独的作用域。
+上面代码正确运行，输出了3次`abc`。这表明函数内部的变量`i`与循环变量`i`不在同一个作用域，有各自单独的作用域。
 
 ### 不存在变量提升
 
diff --git a/sidebar.md b/sidebar.md
index 4017f30..507a3bd 100644
--- a/sidebar.md
+++ b/sidebar.md
@@ -24,7 +24,8 @@
 1. [Generator 函数的语法](#docs/generator)
 1. [Generator 函数的异步应用](#docs/generator-async)
 1. [async 函数](#docs/async)
-1. [Class](#docs/class)
+1. [Class 的基本语法](#docs/class)
+1. [Class 的继承](#docs/class-extends)
 1. [Decorator](#docs/decorator)
 1. [Module 的语法](#docs/module)
 1. [Module 的加载实现](#docs/module-loader)