Meta programming

这篇文章需要技术复核。如何帮忙。

这篇文章需要文法复核。如何帮忙。

这篇翻译不完整。请帮忙从英语翻译这篇文章

从ECMAScript6开始,JavaScript就开始支持ProxyReflect对象,允许你拦截并定制基础语言操作行为(比如,属性查找,赋值,枚举,函数调用,等等)。通过这两个对象,你可以在JavaScript元级别(meta level)编程。

代理(Proxies)

从ECMAScript6开始引进Proxy对象允许你解释特定操作和实现定制行为。例如获取一个对象的某个属性:

var handler = {
  get: function(target, name){
    return name in target ? target[name] : 42;
}};
var p = new Proxy({}, handler);
p.a = 1;
console.log(p.a, p.b); // 1, 42

Proxy(代理)对象定义一个target和一个handle,handle实现了一个get捕捉方法。通过这个方法,被代理的对象对于未定义的属性,不再返回undefined,而是返回一个42的数字。

更多例子参见 Proxy 引用页

术语

在讨论代理Proxy的功能时,以下这些术语将会被使用到。T

handler
Placeholder object which contains traps.
traps
该方法提供属性访问. 和操作系统中的traps的概念类似.
target(目标)
生成代理虚拟化的对象。它经常被作为代理的后端存储使用。
Object which the proxy virtualizes. It is often used as storage backend for the proxy. Invariants (semantics that remain unchanged) regarding object non-extensibility or non-configurable properties are verified against the target.
invariants(常量)
语义上,当实现固定的操作而不发生改变的量叫做不变量(常量)。如果你违反了管理者制定的常量,将会抛出一个TypeError这样的错误。

Handlers and traps

以下表格中总结了Proxy对象可用的traps。详细的解释说明和例子请看reference pages

Handler / trap Interceptions Invariants
handler.getPrototypeOf() Object.getPrototypeOf()
Reflect.getPrototypeOf()
__proto__
Object.prototype.isPrototypeOf()
instanceof
getPrototypeOf method must return an object or null.

If target is not extensible, Object.getPrototypeOf(proxy) method must return the same value as Object.getPrototypeOf(target).
handler.setPrototypeOf() Object.setPrototypeOf()
Reflect.setPrototypeOf()

If target is not extensible, the prototype parameter must be the same value as Object.getPrototypeOf(target).

handler.isExtensible()

Object.isExtensible()

Reflect.isExtensible()

Object.isExtensible(proxy) must return the same value as Object.isExtensible(target).

handler.preventExtensions()

Object.preventExtensions()

Reflect.preventExtensions()

Object.preventExtensions(proxy) only returns true if Object.isExtensible(proxy) is false.

handler.getOwnPropertyDescriptor()

Object.getOwnPropertyDescriptor()

Reflect.getOwnPropertyDescriptor()

getOwnPropertyDescriptor must return an object or undefined.

A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.

A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible.

A property cannot be reported as existent, if it does not exists as an own property of the target object and the target object is not extensible.

A property cannot be reported as non-configurable, if it does not exists as an own property of the target object or if it exists as a configurable own property of the target object.

The result of Object.getOwnPropertyDescriptor(target) can be applied to the target object using Object.defineProperty and will not throw an exception.

handler.defineProperty()

Object.defineProperty()

Reflect.defineProperty()

A property cannot be added, if the target object is not extensible.

A property cannot be added as or modified to be non-configurable, if it does not exists as a non-configurable own property of the target object.

A property may not be non-configurable, if a corresponding configurable property of the target object exists.

If a property has a corresponding target object property then Object.defineProperty(target, prop, descriptor) will not throw an exception.

In strict mode, a false return value from the defineProperty handler will throw a TypeError exception.

handler.has()

Property query: foo in proxy

Inherited property query: foo in Object.create(proxy)

Reflect.has()

A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.

A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible.

handler.get()

Property access: proxy[foo]and proxy.bar

Inherited property access: Object.create(proxy)[foo]

Reflect.get()

The value reported for a property must be the same as the value of the corresponding target object property if the target object property is a non-writable, non-configurable data property.

The value reported for a property must be undefined if the corresponding target object property is non-configurable accessor property that has undefined as its [[Get]] attribute.

handler.set()

Property assignment: proxy[foo] = bar and proxy.foo = bar

Inherited property assignment: Object.create(proxy)[foo] = bar

Reflect.set()

Cannot change the value of a property to be different from the value of the corresponding target object property if the corresponding target object property is a non-writable, non-configurable data property.

Cannot set the value of a property if the corresponding target object property is a non-configurable accessor property that has undefined as its [[Set]] attribute.

In strict mode, a false return value from the set handler will throw a TypeError exception.

handler.deleteProperty()

Property deletion: delete proxy[foo] and delete proxy.foo

Reflect.deleteProperty()

A property cannot be deleted, if it exists as a non-configurable own property of the target object.
handler.enumerate()

Property enumeration / for...in: for (var name in proxy) {...}

Reflect.enumerate()

The enumerate method must return an object.
handler.ownKeys()

Object.getOwnPropertyNames()
Object.getOwnPropertySymbols()
Object.keys()
Reflect.ownKeys()

The result of ownKeys is a List.

The Type of each result List element is either String or Symbol.

The result List must contain the keys of all non-configurable own properties of the target object.

If the target object is not extensible, then the result List must contain all the keys of the own properties of the target object and no other values.

handler.apply()

proxy(..args)

Function.prototype.apply() and Function.prototype.call()

Reflect.apply()

There are no invariants for the handler.apply method.
handler.construct()

new proxy(...args)
Reflect.construct()

The result must be an Object.

Revocable Proxy

Proxy.revocable()方法被用来创建可撤销的代理对象。这意味着代理可以通过撤销函数来撤销并且关掉代理。后来,代理上的任意的操作都会导致TypeError.

 

var revocable = Proxy.revocable({}, {
  get: function(target, name) {
    return "[[" + name + "]]";
  }
});
var proxy = revocable.proxy;
console.log(proxy.foo); // "[[foo]]"

revocable.revoke();

console.log(proxy.foo); // TypeError is thrown
proxy.foo = 1           // TypeError again
delete proxy.foo;       // still TypeError
typeof proxy            // "object", typeof doesn't trigger any trap

反射(Reflection)

Reflect 式一个可提供JavaScript操作判断的内建对象。该方法和 代理句柄(proxy handlers)类似,但需要注意的是Reflect方法并不是一个函数对象。

反射帮助实现从处理器到目标的默认转发操作, 但是Reflect方法还没有在Firefox浏览器中实现

使用Reflect.has()举例, you get the in operator as a function:

Reflect.has(Object, "assign"); // true

文档标签和贡献者

 此页面的贡献者: hpcherry, zyMacro, cughudson_1, acekingke, binhex, FredWe
 最后编辑者: hpcherry,