diff --git a/docs/class.md b/docs/class.md
index 2594c36..b644ffc 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -436,7 +436,44 @@ B.__proto__ === A // true
 B.prototype.__proto__ === A.prototype // true
 ```
 
-上面代码中，子类B的`__proto__`属性指向父类A，子类B的prototype属性的__proto__属性指向父类A的prototype属性。
+上面代码中，子类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);
+```
+
+《对象的扩展》一章给出过`Object.setPrototypeOf`方法的实现。
+
+```
+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属性）是父类的实例。
 
@@ -446,7 +483,20 @@ B.prototype = new A();
 B.prototype.__proto__ = A.prototype;
 ```
 
-此外，考虑三种特殊情况。第一种特殊情况，子类继承Object类。
+### Extends 的继承目标
+
+extends关键字后面可以跟多种类型的值。
+
+```javascript
+class B extends A {
+}
+```
+
+上面代码的A，只要是一个有prototype属性的函数，就能被B继承。由于函数都有prototype属性，因此A可以是任意函数。
+
+下面，讨论三种特殊情况。
+
+第一种特殊情况，子类继承Object类。
 
 ```javascript
 class A extends Object {
@@ -497,6 +547,37 @@ Object.getPrototypeOf(ColorPoint) === Point
 // true
 ```
 
+因此，可以使用这个方法判断，一个类是否继承了另一个类。
+
+### super关键字
+
+上面讲过，在子类中，super关键字代表父类实例。
+
+```javascript
+class B extends A {
+  get m() {
+    return this._p * super._p;
+  }
+  set m() {
+    throw new Error('该属性只读');
+  }
+}
+```
+
+上面代码中，子类通过super关键字，调用父类的实例。
+
+由于，对象总是继承其他对象的，所以可以在任意一个对象中，使用super关键字。
+
+```javascript
+var obj = {
+  toString() {
+    return "MyObject: " + super.toString();
+  }
+}
+
+obj.toString(); // MyObject: [object Object]
+```
+
 ### 实例的\_\_proto\_\_属性
 
 子类实例的\_\_proto\_\_属性的\_\_proto\_\_属性，指向父类实例的\_\_proto\_\_属性。也就是说，子类的原型的原型，是父类的原型。
@@ -509,7 +590,9 @@ p2.__proto__ === p1.__proto // false
 p2.__proto__.__proto__ === p1.__proto__ // true
 ```
 
-通过子类实例的\_\_proto\_\_属性，可以修改父类实例的行为。
+上面代码中，ColorPoint继承了Point，导致前者原型的原型是后者的原型。
+
+因此，通过子类实例的`__proto__.__proto__`属性，可以修改父类实例的行为。
 
 ```javascript
 p2.__proto__.__proto__.printName = function () {
@@ -521,7 +604,7 @@ p1.printName() // "Ha"
 
 上面代码在ColorPoint的实例p2上向Point类添加方法，结果影响到了Point的实例p1。
 
-### 原生构造函数的继承
+## 原生构造函数的继承
 
 原生构造函数是指语言内置的构造函数，通常用来生成数据结构，比如`Array()`。以前，这些原生构造函数是无法继承的，即不能自己定义一个Array的子类。
 
@@ -572,13 +655,51 @@ arr[0] // undefined
 
 上面代码定义了一个MyArray类，继承了Array构造函数，因此就可以从MyArray生成数组的实例。这意味着，ES6可以自定义原生数据结构（比如Array、String等）的子类，这是ES5无法做到的。
 
-上面这个例子也说明，extends关键字不仅可以用来继承类，还可以用来继承原生的构造函数。下面是一个自定义Error子类的例子。
+上面这个例子也说明，extends关键字不仅可以用来继承类，还可以用来继承原生的构造函数。因此可以在原生数据结构的基础上，定义自己的数据结构。下面就是定义了一个带版本功能的数组。
 
 ```javascript
-class MyError extends Error {
+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]);
+  }
+}
+```
+
+上面代码中，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;
+  }
 }
 
-throw new MyError('Something happened!');
+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
+//     ...
 ```
 
 ## class的取值函数（getter）和存值函数（setter）
@@ -823,3 +944,39 @@ 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/object.md b/docs/object.md
index a4919a8..7062fa9 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -93,24 +93,24 @@ ES6允许字面量定义对象时，用方法二（表达式）作为对象的
 let propKey = 'foo';
 
 let obj = {
-   [propKey]: true,
-   ['a'+'bc']: 123
+  [propKey]: true,
+  ['a'+'bc']: 123
 };
 ```
 
 下面是另一个例子。
 
 ```javascript
-var lastWord = "last word";
+var lastWord = 'last word';
 
 var a = {
-    "first word": "hello",
-    [lastWord]: "world"
+  'first word': 'hello',
+  [lastWord]: 'world'
 };
 
-a["first word"] // "hello"
+a['first word'] // "hello"
 a[lastWord] // "world"
-a["last word"] // "world"
+a['last word'] // "world"
 ```
 
 表达式还可以用于定义方法名。
@@ -122,7 +122,7 @@ let obj = {
   }
 };
 
-console.log(obj.hello()); // hi
+obj.hello() // hi
 ```
 
 ## 方法的name属性
@@ -150,9 +150,11 @@ var doSomething = function() {
   // ...
 };
 
-console.log(doSomething.bind().name);   // "bound doSomething"
+doSomething.bind().name
+// "bound doSomething"
 
-console.log((new Function()).name);     // "anonymous"
+(new Function()).name
+// "anonymous"
 ```
 
 有两种特殊情况：bind方法创造的函数，name属性返回“bound”加上原函数的名字；Function构造函数创造的函数，name属性返回“anonymous”。
@@ -393,450 +395,6 @@ Object.getPrototypeOf(rec) === Rectangle.prototype
 // false
 ```
 
-## Proxy
-
-### 概述
-
-Proxy用于修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种“元编程”（meta programming），即对编程语言进行编程。
-
-Proxy可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy这个词的原意是代理，用在这里表示由它来“代理”某些操作，可以译为“代理器”。
-
-```javascript
-var obj = new Proxy({}, {
-  get: function (target, key, receiver) {
-    console.log(`getting ${key}!`);
-    return Reflect.get(target, key, receiver);
-  },
-  set: function (target, key, value, receiver) {
-    console.log(`setting ${key}!`);
-    return Reflect.set(target, key, value, receiver);
-  }
-});
-```
-
-上面代码对一个空对象架设了一层拦截，重定义了属性的读取（get）和设置（set）行为。这里暂时不解释具体的语法，只看运行结果。对设置了拦截行为的对象obj，去读写它的属性，就会得到下面的结果。
-
-```javascript
-obj.count = 1
-//  setting count!
-++obj.count
-//  getting count!
-//  setting count!
-//  2
-```
-
-上面代码说明，Proxy实际上重载（overload）了点运算符，即用自己的定义覆盖了语言的原始定义。
-
-ES6原生提供Proxy构造函数，用来生成Proxy实例。
-
-```javascript
-var proxy = new Proxy(target, handler)
-```
-
-Proxy对象的所用用法，都是上面这种形式，不同的只是handler参数的写法。其中，`new Proxy()`表示生成一个Proxy实例，target参数表示所要拦截的目标对象，handler参数也是一个对象，用来定制拦截行为。
-
-下面是另一个拦截读取属性行为的例子。
-
-```javascript
-var proxy = new Proxy({}, {
-  get: function(target, property) {
-    return 35;
-  }
-});
-
-proxy.time // 35
-proxy.name // 35
-proxy.title // 35
-```
-
-上面代码中，作为构造函数，Proxy接受两个参数。第一个参数是所要代理的目标对象（上例是一个空对象），即如果没有Proxy的介入，操作原来要访问的就是这个对象；第二个参数是一个配置对象，对于每一个被代理的操作，需要提供一个对应的处理函数，该函数将拦截对应的操作。比如，上面代码中，配置对象有一个get方法，用来拦截对目标对象属性的访问请求。get方法的两个参数分别是目标对象和所要访问的属性。可以看到，由于拦截函数总是返回35，所以访问任何属性都得到35。
-
-注意，要使得Proxy起作用，必须针对Proxy实例（上例是proxy对象）进行操作，而不是针对目标对象（上例是空对象）进行操作。
-
-一个技巧是将Proxy对象，设置到`object.proxy`属性，从而可以在object对象上调用。
-
-```javascript
-var object = { proxy: new Proxy(target, handler) }
-```
-
-Proxy实例也可以作为其他对象的原型对象。
-
-```javascript
-var proxy = new Proxy({}, {
-  get: function(target, property) {
-    return 35;
-  }
-});
-
-let obj = Object.create(proxy);
-obj.time // 35
-```
-
-上面代码中，proxy对象是obj对象的原型，obj对象本身并没有time属性，所有根据原型链，会在proxy对象上读取该属性，导致被拦截。
-
-同一个拦截器函数，可以设置拦截多个操作。
-
-```javascript
-var handler = {
-  get: function(target, name) {
-    if (name === 'prototype') return Object.prototype;
-    return 'Hello, '+ name;
-  },
-  apply: function(target, thisBinding, args) { return args[0]; },
-  construct: function(target, args) { return args[1]; }
-};
-
-var fproxy = new Proxy(function(x,y) {
-  return x+y;
-},  handler);
-
-fproxy(1,2); // 1
-new fproxy(1,2); // 2
-fproxy.prototype; // Object.prototype
-fproxy.foo; // 'Hello, foo'
-```
-
-下面是Proxy支持的拦截操作一览。
-
-对于可以设置、但没有设置拦截的操作，则直接落在目标对象上，按照原先的方式产生结果。
-
-**（1）get(target, propKey, receiver)**
-
-拦截对象属性的读取，比如`proxy.foo`和`proxy['foo']`，返回类型不限。最后一个参数receiver可选，当target对象设置了propKey属性的get函数时，receiver对象会绑定get函数的this对象。
-
-**（2）set(target, propKey, value, receiver)**
-
-拦截对象属性的设置，比如`proxy.foo = v`或`proxy['foo'] = v`，返回一个布尔值。
-
-**（3）has(target, propKey)**
-
-拦截`propKey in proxy`的操作，返回一个布尔值。
-
-**（4）deleteProperty(target, propKey)**
-
-拦截`delete proxy[propKey]`的操作，返回一个布尔值。
-
-**（5）enumerate(target)**
-
-拦截`for (var x in proxy)`，返回一个遍历器。
-
-**（6）hasOwn(target, propKey)**
-
-拦截`proxy.hasOwnProperty('foo')`，返回一个布尔值。
-
-**（7）ownKeys(target)**
-
-拦截`Object.getOwnPropertyNames(proxy)`、`Object.getOwnPropertySymbols(proxy)`、`Object.keys(proxy)`，返回一个数组。该方法返回对象所有自身的属性，而`Object.keys()`仅返回对象可遍历的属性。
-
-**（8）getOwnPropertyDescriptor(target, propKey)**
-
-拦截`Object.getOwnPropertyDescriptor(proxy, propKey)`，返回属性的描述对象。
-
-**（9）defineProperty(target, propKey, propDesc)**
-
-拦截`Object.defineProperty(proxy, propKey, propDesc）`、`Object.defineProperties(proxy, propDescs)`，返回一个布尔值。
-
-**（10）preventExtensions(target)**
-
-拦截`Object.preventExtensions(proxy)`，返回一个布尔值。
-
-**（11）getPrototypeOf(target)**
-
-拦截`Object.getPrototypeOf(proxy)`，返回一个对象。
-
-**（12）isExtensible(target)**
-
-拦截`Object.isExtensible(proxy)`，返回一个布尔值。
-
-**（13）setPrototypeOf(target, proto)**
-
-拦截`Object.setPrototypeOf(proxy, proto)`，返回一个布尔值。
-
-如果目标对象是函数，那么还有两种额外操作可以拦截。
-
-**（14）apply(target, object, args)**
-
-拦截Proxy实例作为函数调用的操作，比如`proxy(...args)`、`proxy.call(object, ...args)`、`proxy.apply(...)`。
-
-**（15）construct(target, args, proxy)**
-
-拦截Proxy实例作为构造函数调用的操作，比如new proxy(...args)。
-
-下面是其中几个重要拦截方法的详细介绍。
-
-### get()
-
-get方法用于拦截某个属性的读取操作。上文已经有一个例子，下面是另一个拦截读取操作的例子。
-
-```javascript
-var person = {
-  name: "张三"
-};
-
-var proxy = new Proxy(person, {
-  get: function(target, property) {
-    if (property in target) {
-      return target[property];
-    } else {
-      throw new ReferenceError("Property \"" + property + "\" does not exist.");
-    }
-  }
-});
-
-proxy.name // "张三"
-proxy.age // 抛出一个错误
-```
-
-上面代码表示，如果访问目标对象不存在的属性，会抛出一个错误。如果没有这个拦截函数，访问不存在的属性，只会返回undefined。
-
-利用proxy，可以将读取属性的操作（get），转变为执行某个函数。
-
-```javascript
-var pipe = (function () {
-  var pipe;
-  return function (value) {
-    pipe = [];
-    return new Proxy({}, {
-      get: function (pipeObject, fnName) {
-        if (fnName == "get") {
-          return pipe.reduce(function (val, fn) {
-            return fn(val);
-          }, value);
-        }
-        pipe.push(window[fnName]);
-        return pipeObject;
-      }
-    });
-  }
-}());
-
-var double = function (n) { return n*2 };
-var pow = function (n) { return n*n };
-var reverseInt = function (n) { return n.toString().split('').reverse().join('')|0 };
-
-pipe(3) . double . pow . reverseInt . get
-// 63
-```
-
-上面代码设置Proxy以后，达到了将函数名链式使用的效果。
-
-### set()
-
-set方法用来拦截某个属性的赋值操作。假定Person对象有一个age属性，该属性应该是一个不大于200的整数，那么可以使用Proxy对象保证age的属性值符合要求。
-
-```javascript
-
-let validator = {
-  set: function(obj, prop, value) {
-    if (prop === 'age') {
-      if (!Number.isInteger(value)) {
-        throw new TypeError('The age is not an integer');
-      }
-      if (value > 200) {
-        throw new RangeError('The age seems invalid');
-      }
-    }
-
-    // 对于age以外的属性，直接保存
-    obj[prop] = value;
-  }
-};
-
-let person = new Proxy({}, validator);
-
-person.age = 100;
-
-person.age // 100
-person.age = 'young' // 报错
-person.age = 300 // 报错
-
-```
-
-上面代码中，由于设置了存值函数set，任何不符合要求的age属性赋值，都会抛出一个错误。利用set方法，还可以数据绑定，即每当对象发生变化时，会自动更新DOM。
-
-### apply()
-
-apply方法拦截函数的调用、call和apply操作。
-
-```javascript
-
-var target = function () { return 'I am the target'; };
-var handler = {
-  apply: function (receiver, ...args) {
-    return 'I am the proxy';
-  }
-};
-
-var p = new Proxy(target, handler);
-
-p() === 'I am the proxy';
-// true
-
-```
-
-上面代码中，变量p是Proxy的实例，当它作为函数调用时（p()），就会被apply方法拦截，返回一个字符串。
-
-### ownKeys()
-
-ownKeys方法用来拦截Object.keys()操作。
-
-```javascript
-let target = {};
-
-let handler = {
-  ownKeys(target) {
-    return ['hello', 'world'];
-  }
-};
-
-let proxy = new Proxy(target, handler);
-
-Object.keys(proxy)
-// [ 'hello', 'world' ]
-```
-
-上面代码拦截了对于target对象的Object.keys()操作，返回预先设定的数组。
-
-### Proxy.revocable()
-
-Proxy.revocable方法返回一个可取消的Proxy实例。
-
-```javascript
-let target = {};
-let handler = {};
-
-let {proxy, revoke} = Proxy.revocable(target, handler);
-
-proxy.foo = 123;
-proxy.foo // 123
-
-revoke();
-proxy.foo // TypeError: Revoked
-```
-
-Proxy.revocable方法返回一个对象，该对象的proxy属性是Proxy实例，revoke属性是一个函数，可以取消Proxy实例。上面代码中，当执行revoke函数之后，再访问Proxy实例，就会抛出一个错误。
-
-## Reflect
-
-### 概述
-
-Reflect对象与Proxy对象一样，也是ES6为了操作对象而提供的新API。Reflect对象的设计目的有这样几个。
-
-（1） 将Object对象的一些明显属于语言层面的方法，放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。
-
-（2） 修改某些Object方法的返回结果，让其变得更合理。比如，`Object.defineProperty(obj, name, desc)`在无法定义属性时，会抛出一个错误，而`Reflect.defineProperty(obj, name, desc)`则会返回false。
-
-（3） 让Object操作都变成函数行为。某些Object操作是命令式，比如`name in obj`和`delete obj[name]`，而`Reflect.has(obj, name)`和`Reflect.deleteProperty(obj, name)`让它们变成了函数行为。
-
-（4）Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。
-
-```javascript
-Proxy(target, {
-  set: function(target, name, value, receiver) {
-    var success = Reflect.set(target,name, value, receiver);
-    if (success) {
-      log('property '+name+' on '+target+' set to '+value);
-    }
-    return success;
-  }
-});
-```
-
-上面代码中，Proxy方法拦截target对象的属性赋值行为。它采用Reflect.set方法将值赋值给对象的属性，然后再部署额外的功能。
-
-下面是get方法的例子。
-
-```javascript
-var loggedObj = new Proxy(obj, {
-  get: function(target, name) {
-    console.log("get", target, name);
-    return Reflect.get(target, name);
-  }
-});
-```
-
-### 方法
-
-Reflect对象的方法清单如下。
-
-- Reflect.getOwnPropertyDescriptor(target,name)
-- Reflect.defineProperty(target,name,desc)
-- Reflect.getOwnPropertyNames(target)
-- Reflect.getPrototypeOf(target)
-- Reflect.deleteProperty(target,name)
-- Reflect.enumerate(target)
-- Reflect.freeze(target)
-- Reflect.seal(target)
-- Reflect.preventExtensions(target)
-- Reflect.isFrozen(target)
-- Reflect.isSealed(target)
-- Reflect.isExtensible(target)
-- Reflect.has(target,name)
-- Reflect.hasOwn(target,name)
-- Reflect.keys(target)
-- Reflect.get(target,name,receiver)
-- Reflect.set(target,name,value,receiver)
-- Reflect.apply(target,thisArg,args)
-- Reflect.construct(target,args)
-
-上面这些方法的作用，大部分与Object对象的同名方法的作用都是相同的。下面是对其中几个方法的解释。
-
-（1）Reflect.get(target,name,receiver)
-
-查找并返回target对象的name属性，如果没有该属性，则返回undefined。
-
-如果name属性部署了读取函数，则读取函数的this绑定receiver。
-
-```javascript
-var obj = {
-  get foo() { return this.bar(); },
-  bar: function() { ... }
-}
-
-// 下面语句会让 this.bar()
-// 变成调用 wrapper.bar()
-Reflect.get(obj, "foo", wrapper);
-```
-
-（2）Reflect.set(target, name, value, receiver)
-
-设置target对象的name属性等于value。如果name属性设置了赋值函数，则赋值函数的this绑定receiver。
-
-（3）Reflect.has(obj, name)
-
-等同于`name in obj`。
-
-（4）Reflect.deleteProperty(obj, name)
-
-等同于`delete obj[name]`。
-
-（5）Reflect.construct(target, args)
-
-等同于`new target(...args)`，这提供了一种不使用new，来调用构造函数的方法。
-
-（6）Reflect.getPrototypeOf(obj)
-
-读取对象的\_\_proto\_\_属性，等同于`Object.getPrototypeOf(obj)`。
-
-（7）Reflect.setPrototypeOf(obj, newProto)
-
-设置对象的\_\_proto\_\_属性。注意，Object对象没有对应这个方法的方法。
-
-（8）Reflect.apply(fun,thisArg,args)
-
-等同于`Function.prototype.apply.call(fun,thisArg,args)`。一般来说，如果要绑定一个函数的this对象，可以这样写`fn.apply(obj, args)`，但是如果函数定义了自己的apply方法，就只能写成`Function.prototype.apply.call(fn, obj, args)`，采用Reflect对象可以简化这种操作。
-
-另外，需要注意的是，Reflect.set()、Reflect.defineProperty()、Reflect.freeze()、Reflect.seal()和Reflect.preventExtensions()返回一个布尔值，表示操作是否成功。它们对应的Object方法，失败时都会抛出错误。
-
-```javascript
-// 失败时抛出错误
-Object.defineProperty(obj, name, desc);
-// 失败时返回false
-Reflect.defineProperty(obj, name, desc);
-```
-
-上面代码中，Reflect.defineProperty方法的作用与Object.defineProperty是一样的，都是为对象定义一个属性。但是，Reflect.defineProperty方法失败时，不会抛出错误，只会返回false。
-
 ## Object.observe()，Object.unobserve()
 
 Object.observe方法用来监听对象（以及数组）的变化。一旦监听对象发生变化，就会触发回调函数。
diff --git a/docs/proxy.md b/docs/proxy.md
new file mode 100644
index 0000000..862932e
--- /dev/null
+++ b/docs/proxy.md
@@ -0,0 +1,443 @@
+# Proxy和Reflect
+
+## Proxy概述
+
+Proxy用于修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种“元编程”（meta programming），即对编程语言进行编程。
+
+Proxy可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy这个词的原意是代理，用在这里表示由它来“代理”某些操作，可以译为“代理器”。
+
+```javascript
+var obj = new Proxy({}, {
+  get: function (target, key, receiver) {
+    console.log(`getting ${key}!`);
+    return Reflect.get(target, key, receiver);
+  },
+  set: function (target, key, value, receiver) {
+    console.log(`setting ${key}!`);
+    return Reflect.set(target, key, value, receiver);
+  }
+});
+```
+
+上面代码对一个空对象架设了一层拦截，重定义了属性的读取（get）和设置（set）行为。这里暂时不解释具体的语法，只看运行结果。对设置了拦截行为的对象obj，去读写它的属性，就会得到下面的结果。
+
+```javascript
+obj.count = 1
+//  setting count!
+++obj.count
+//  getting count!
+//  setting count!
+//  2
+```
+
+上面代码说明，Proxy实际上重载（overload）了点运算符，即用自己的定义覆盖了语言的原始定义。
+
+ES6原生提供Proxy构造函数，用来生成Proxy实例。
+
+```javascript
+var proxy = new Proxy(target, handler)
+```
+
+Proxy对象的所用用法，都是上面这种形式，不同的只是handler参数的写法。其中，`new Proxy()`表示生成一个Proxy实例，target参数表示所要拦截的目标对象，handler参数也是一个对象，用来定制拦截行为。
+
+下面是另一个拦截读取属性行为的例子。
+
+```javascript
+var proxy = new Proxy({}, {
+  get: function(target, property) {
+    return 35;
+  }
+});
+
+proxy.time // 35
+proxy.name // 35
+proxy.title // 35
+```
+
+上面代码中，作为构造函数，Proxy接受两个参数。第一个参数是所要代理的目标对象（上例是一个空对象），即如果没有Proxy的介入，操作原来要访问的就是这个对象；第二个参数是一个配置对象，对于每一个被代理的操作，需要提供一个对应的处理函数，该函数将拦截对应的操作。比如，上面代码中，配置对象有一个get方法，用来拦截对目标对象属性的访问请求。get方法的两个参数分别是目标对象和所要访问的属性。可以看到，由于拦截函数总是返回35，所以访问任何属性都得到35。
+
+注意，要使得Proxy起作用，必须针对Proxy实例（上例是proxy对象）进行操作，而不是针对目标对象（上例是空对象）进行操作。
+
+一个技巧是将Proxy对象，设置到`object.proxy`属性，从而可以在object对象上调用。
+
+```javascript
+var object = { proxy: new Proxy(target, handler) }
+```
+
+Proxy实例也可以作为其他对象的原型对象。
+
+```javascript
+var proxy = new Proxy({}, {
+  get: function(target, property) {
+    return 35;
+  }
+});
+
+let obj = Object.create(proxy);
+obj.time // 35
+```
+
+上面代码中，proxy对象是obj对象的原型，obj对象本身并没有time属性，所有根据原型链，会在proxy对象上读取该属性，导致被拦截。
+
+同一个拦截器函数，可以设置拦截多个操作。
+
+```javascript
+var handler = {
+  get: function(target, name) {
+    if (name === 'prototype') return Object.prototype;
+    return 'Hello, '+ name;
+  },
+  apply: function(target, thisBinding, args) { return args[0]; },
+  construct: function(target, args) { return args[1]; }
+};
+
+var fproxy = new Proxy(function(x,y) {
+  return x+y;
+},  handler);
+
+fproxy(1,2); // 1
+new fproxy(1,2); // 2
+fproxy.prototype; // Object.prototype
+fproxy.foo; // 'Hello, foo'
+```
+
+下面是Proxy支持的拦截操作一览。
+
+对于可以设置、但没有设置拦截的操作，则直接落在目标对象上，按照原先的方式产生结果。
+
+**（1）get(target, propKey, receiver)**
+
+拦截对象属性的读取，比如`proxy.foo`和`proxy['foo']`，返回类型不限。最后一个参数receiver可选，当target对象设置了propKey属性的get函数时，receiver对象会绑定get函数的this对象。
+
+**（2）set(target, propKey, value, receiver)**
+
+拦截对象属性的设置，比如`proxy.foo = v`或`proxy['foo'] = v`，返回一个布尔值。
+
+**（3）has(target, propKey)**
+
+拦截`propKey in proxy`的操作，返回一个布尔值。
+
+**（4）deleteProperty(target, propKey)**
+
+拦截`delete proxy[propKey]`的操作，返回一个布尔值。
+
+**（5）enumerate(target)**
+
+拦截`for (var x in proxy)`，返回一个遍历器。
+
+**（6）hasOwn(target, propKey)**
+
+拦截`proxy.hasOwnProperty('foo')`，返回一个布尔值。
+
+**（7）ownKeys(target)**
+
+拦截`Object.getOwnPropertyNames(proxy)`、`Object.getOwnPropertySymbols(proxy)`、`Object.keys(proxy)`，返回一个数组。该方法返回对象所有自身的属性，而`Object.keys()`仅返回对象可遍历的属性。
+
+**（8）getOwnPropertyDescriptor(target, propKey)**
+
+拦截`Object.getOwnPropertyDescriptor(proxy, propKey)`，返回属性的描述对象。
+
+**（9）defineProperty(target, propKey, propDesc)**
+
+拦截`Object.defineProperty(proxy, propKey, propDesc）`、`Object.defineProperties(proxy, propDescs)`，返回一个布尔值。
+
+**（10）preventExtensions(target)**
+
+拦截`Object.preventExtensions(proxy)`，返回一个布尔值。
+
+**（11）getPrototypeOf(target)**
+
+拦截`Object.getPrototypeOf(proxy)`，返回一个对象。
+
+**（12）isExtensible(target)**
+
+拦截`Object.isExtensible(proxy)`，返回一个布尔值。
+
+**（13）setPrototypeOf(target, proto)**
+
+拦截`Object.setPrototypeOf(proxy, proto)`，返回一个布尔值。
+
+如果目标对象是函数，那么还有两种额外操作可以拦截。
+
+**（14）apply(target, object, args)**
+
+拦截Proxy实例作为函数调用的操作，比如`proxy(...args)`、`proxy.call(object, ...args)`、`proxy.apply(...)`。
+
+**（15）construct(target, args, proxy)**
+
+拦截Proxy实例作为构造函数调用的操作，比如new proxy(...args)。
+
+## Proxy实例的方法
+
+下面是其中几个重要拦截方法的详细介绍。
+
+### get()
+
+get方法用于拦截某个属性的读取操作。上文已经有一个例子，下面是另一个拦截读取操作的例子。
+
+```javascript
+var person = {
+  name: "张三"
+};
+
+var proxy = new Proxy(person, {
+  get: function(target, property) {
+    if (property in target) {
+      return target[property];
+    } else {
+      throw new ReferenceError("Property \"" + property + "\" does not exist.");
+    }
+  }
+});
+
+proxy.name // "张三"
+proxy.age // 抛出一个错误
+```
+
+上面代码表示，如果访问目标对象不存在的属性，会抛出一个错误。如果没有这个拦截函数，访问不存在的属性，只会返回undefined。
+
+利用proxy，可以将读取属性的操作（get），转变为执行某个函数。
+
+```javascript
+var pipe = (function () {
+  var pipe;
+  return function (value) {
+    pipe = [];
+    return new Proxy({}, {
+      get: function (pipeObject, fnName) {
+        if (fnName == "get") {
+          return pipe.reduce(function (val, fn) {
+            return fn(val);
+          }, value);
+        }
+        pipe.push(window[fnName]);
+        return pipeObject;
+      }
+    });
+  }
+}());
+
+var double = function (n) { return n*2 };
+var pow = function (n) { return n*n };
+var reverseInt = function (n) { return n.toString().split('').reverse().join('')|0 };
+
+pipe(3) . double . pow . reverseInt . get
+// 63
+```
+
+上面代码设置Proxy以后，达到了将函数名链式使用的效果。
+
+### set()
+
+set方法用来拦截某个属性的赋值操作。假定Person对象有一个age属性，该属性应该是一个不大于200的整数，那么可以使用Proxy对象保证age的属性值符合要求。
+
+```javascript
+
+let validator = {
+  set: function(obj, prop, value) {
+    if (prop === 'age') {
+      if (!Number.isInteger(value)) {
+        throw new TypeError('The age is not an integer');
+      }
+      if (value > 200) {
+        throw new RangeError('The age seems invalid');
+      }
+    }
+
+    // 对于age以外的属性，直接保存
+    obj[prop] = value;
+  }
+};
+
+let person = new Proxy({}, validator);
+
+person.age = 100;
+
+person.age // 100
+person.age = 'young' // 报错
+person.age = 300 // 报错
+
+```
+
+上面代码中，由于设置了存值函数set，任何不符合要求的age属性赋值，都会抛出一个错误。利用set方法，还可以数据绑定，即每当对象发生变化时，会自动更新DOM。
+
+### apply()
+
+apply方法拦截函数的调用、call和apply操作。
+
+```javascript
+
+var target = function () { return 'I am the target'; };
+var handler = {
+  apply: function (receiver, ...args) {
+    return 'I am the proxy';
+  }
+};
+
+var p = new Proxy(target, handler);
+
+p() === 'I am the proxy';
+// true
+
+```
+
+上面代码中，变量p是Proxy的实例，当它作为函数调用时（p()），就会被apply方法拦截，返回一个字符串。
+
+### ownKeys()
+
+ownKeys方法用来拦截Object.keys()操作。
+
+```javascript
+let target = {};
+
+let handler = {
+  ownKeys(target) {
+    return ['hello', 'world'];
+  }
+};
+
+let proxy = new Proxy(target, handler);
+
+Object.keys(proxy)
+// [ 'hello', 'world' ]
+```
+
+上面代码拦截了对于target对象的Object.keys()操作，返回预先设定的数组。
+
+## Proxy.revocable()
+
+Proxy.revocable方法返回一个可取消的Proxy实例。
+
+```javascript
+let target = {};
+let handler = {};
+
+let {proxy, revoke} = Proxy.revocable(target, handler);
+
+proxy.foo = 123;
+proxy.foo // 123
+
+revoke();
+proxy.foo // TypeError: Revoked
+```
+
+Proxy.revocable方法返回一个对象，该对象的proxy属性是Proxy实例，revoke属性是一个函数，可以取消Proxy实例。上面代码中，当执行revoke函数之后，再访问Proxy实例，就会抛出一个错误。
+
+## Reflect概述
+
+Reflect对象与Proxy对象一样，也是ES6为了操作对象而提供的新API。Reflect对象的设计目的有这样几个。
+
+（1） 将Object对象的一些明显属于语言层面的方法，放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。
+
+（2） 修改某些Object方法的返回结果，让其变得更合理。比如，`Object.defineProperty(obj, name, desc)`在无法定义属性时，会抛出一个错误，而`Reflect.defineProperty(obj, name, desc)`则会返回false。
+
+（3） 让Object操作都变成函数行为。某些Object操作是命令式，比如`name in obj`和`delete obj[name]`，而`Reflect.has(obj, name)`和`Reflect.deleteProperty(obj, name)`让它们变成了函数行为。
+
+（4）Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。
+
+```javascript
+Proxy(target, {
+  set: function(target, name, value, receiver) {
+    var success = Reflect.set(target,name, value, receiver);
+    if (success) {
+      log('property '+name+' on '+target+' set to '+value);
+    }
+    return success;
+  }
+});
+```
+
+上面代码中，Proxy方法拦截target对象的属性赋值行为。它采用Reflect.set方法将值赋值给对象的属性，然后再部署额外的功能。
+
+下面是get方法的例子。
+
+```javascript
+var loggedObj = new Proxy(obj, {
+  get: function(target, name) {
+    console.log("get", target, name);
+    return Reflect.get(target, name);
+  }
+});
+```
+
+## Reflect对象的方法
+
+Reflect对象的方法清单如下。
+
+- Reflect.getOwnPropertyDescriptor(target,name)
+- Reflect.defineProperty(target,name,desc)
+- Reflect.getOwnPropertyNames(target)
+- Reflect.getPrototypeOf(target)
+- Reflect.deleteProperty(target,name)
+- Reflect.enumerate(target)
+- Reflect.freeze(target)
+- Reflect.seal(target)
+- Reflect.preventExtensions(target)
+- Reflect.isFrozen(target)
+- Reflect.isSealed(target)
+- Reflect.isExtensible(target)
+- Reflect.has(target,name)
+- Reflect.hasOwn(target,name)
+- Reflect.keys(target)
+- Reflect.get(target,name,receiver)
+- Reflect.set(target,name,value,receiver)
+- Reflect.apply(target,thisArg,args)
+- Reflect.construct(target,args)
+
+上面这些方法的作用，大部分与Object对象的同名方法的作用都是相同的。下面是对其中几个方法的解释。
+
+**（1）Reflect.get(target,name,receiver)**
+
+查找并返回target对象的name属性，如果没有该属性，则返回undefined。
+
+如果name属性部署了读取函数，则读取函数的this绑定receiver。
+
+```javascript
+var obj = {
+  get foo() { return this.bar(); },
+  bar: function() { ... }
+}
+
+// 下面语句会让 this.bar()
+// 变成调用 wrapper.bar()
+Reflect.get(obj, "foo", wrapper);
+```
+
+**（2）Reflect.set(target, name, value, receiver)**
+
+设置target对象的name属性等于value。如果name属性设置了赋值函数，则赋值函数的this绑定receiver。
+
+**（3）Reflect.has(obj, name)**
+
+等同于`name in obj`。
+
+**（4）Reflect.deleteProperty(obj, name)**
+
+等同于`delete obj[name]`。
+
+**（5）Reflect.construct(target, args)**
+
+等同于`new target(...args)`，这提供了一种不使用new，来调用构造函数的方法。
+
+**（6）Reflect.getPrototypeOf(obj)**
+
+读取对象的\_\_proto\_\_属性，等同于`Object.getPrototypeOf(obj)`。
+
+**（7）Reflect.setPrototypeOf(obj, newProto)**
+
+设置对象的\_\_proto\_\_属性。注意，Object对象没有对应这个方法的方法。
+
+**（8）Reflect.apply(fun,thisArg,args)**
+
+等同于`Function.prototype.apply.call(fun,thisArg,args)`。一般来说，如果要绑定一个函数的this对象，可以这样写`fn.apply(obj, args)`，但是如果函数定义了自己的apply方法，就只能写成`Function.prototype.apply.call(fn, obj, args)`，采用Reflect对象可以简化这种操作。
+
+另外，需要注意的是，Reflect.set()、Reflect.defineProperty()、Reflect.freeze()、Reflect.seal()和Reflect.preventExtensions()返回一个布尔值，表示操作是否成功。它们对应的Object方法，失败时都会抛出错误。
+
+```javascript
+// 失败时抛出错误
+Object.defineProperty(obj, name, desc);
+// 失败时返回false
+Reflect.defineProperty(obj, name, desc);
+```
+
+上面代码中，Reflect.defineProperty方法的作用与Object.defineProperty是一样的，都是为对象定义一个属性。但是，Reflect.defineProperty方法失败时，不会抛出错误，只会返回false。
diff --git a/docs/reference.md b/docs/reference.md
index 47abdda..4efe1ef 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -114,18 +114,22 @@
 - Jafar Husain, [Asynchronous Generators for ES7](https://github.com/jhusain/asyncgenerator): Async函数的深入讨论
 - Nolan Lawson, [Taming the asynchronous beast with ES7](http://pouchdb.com/2015/03/05/taming-the-async-beast-with-es7.html): async函数通俗的实例讲解
 
-## Class与模块
+## Class
 
 - Sebastian Porto, [ES6 classes and JavaScript prototypes](https://reinteractive.net/posts/235-es6-classes-and-javascript-prototypes): ES6 Class的写法与ES5 Prototype的写法对比
 - Jack Franklin, [An introduction to ES6 classes](http://javascriptplayground.com/blog/2014/07/introduction-to-es6-classes-tutorial/): ES6 class的入门介绍
 - Axel Rauschmayer, [ECMAScript 6: new OOP features besides classes](http://www.2ality.com/2014/12/es6-oop.html)
 - Axel Rauschmayer, [Classes in ECMAScript 6 (final semantics)](http://www.2ality.com/2015/02/es6-classes-final.html): Class语法的详细介绍和设计思想分析
+- Eric Faust, [ES6 In Depth: Subclassing](https://hacks.mozilla.org/2015/08/es6-in-depth-subclassing/): Class语法的深入介绍
+
+## Decorator
+
 - Maximiliano Fierro, [Declarative vs Imperative](http://elmasse.github.io/js/decorators-bindings-es7.html): Decorators和Mixin介绍
 - Addy Osmani, [Exploring ES2016 Decorators](https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841): Decorator的深入介绍
 - Sebastian McKenzie, [Allow decorators for functions as well](https://github.com/wycats/javascript-decorators/issues/4): 为什么修饰器不能用于函数
 - Maximiliano Fierro, [Traits with ES7 Decorators](http://cocktailjs.github.io/blog/traits-with-es7-decorators.html): Trait的用法介绍
 
-## 模块
+## Module
 
 - Jack Franklin, [JavaScript Modules the ES6 Way](http://24ways.org/2014/javascript-modules-the-es6-way/): ES6模块入门
 - Axel Rauschmayer, [ECMAScript 6 modules: the final syntax](http://www.2ality.com/2014/09/es6-modules-final.html): ES6模块的介绍，以及与CommonJS规格的详细比较
diff --git a/sidebar.md b/sidebar.md
index 9c72668..e1e9a69 100644
--- a/sidebar.md
+++ b/sidebar.md
@@ -16,6 +16,7 @@
 1. [对象的扩展](#docs/object)
 1. [函数的扩展](#docs/function)
 1. [Symbol](#docs/symbol)
+1. [Proxy和Reflect](#docs/proxy)
 1. [Set和Map数据结构](#docs/set-map)
 1. [Iterator和for...of循环](#docs/iterator)
 1. [Generator函数](#docs/generator)