在我因为尝试如此鲁莽的事情而大喊大叫之前,让我告诉你,我不会在现实生活中这样做,这是一个学术问题。
假设我正在编写一个库,我希望我的对象能够根据需要编写方法。
例如,如果您想调用.slice()
方法,而我没有方法,则window.onerror
处理程序会为我启动
无论如何,我玩这个here
window.onerror = function(e) {
var method = /'(.*)'$/.exec(e)[1];
console.log(method); // slice
return Array.prototype[method].call(this, arguments); // not even almost gonna work
};
var myLib = function(a, b, c) {
if (this == window) return new myLib(a, b, c);
this[1] = a; this[2] = b; this[3] = c;
return this;
};
var obj = myLib(1,2,3);
console.log(obj.slice(1));
另外(也许我应该开始一个新问题)我可以更改构造函数以获取未指定数量的args吗?
var myLib = function(a, b, c) {
if (this == window) return new myLib.apply(/* what goes here? */, arguments);
this[1] = a; this[2] = b; this[3] = c;
return this;
};
BTW我知道我可以用
加载我的对象['slice', 'push', '...'].forEach(function() { myLib.prototype[this] = [][this]; });
这不是我想要的
答案 0 :(得分:4)
当您提出学术问题时,我认为浏览器兼容性不是问题。如果确实没有,我想为此介绍和谐代理。 onerror
不是一个很好的做法,因为它只是在某处发生错误时引发的事件。如果有的话,它应该只作为最后的手段使用。 (我知道你说你还是不用它,但onerror
对开发人员不太友好。)
基本上,代理使您能够拦截JavaScript中的大多数基本操作 - 最值得注意的是获取任何有用的属性。在这种情况下,您可以拦截获取.slice
的过程。
请注意,默认情况下代理是“黑洞”。它们与任何对象都不对应(例如,在代理上设置属性只调用set
陷阱(拦截器);您必须自己实际存储)。但是有一个“转发处理程序”可用于将所有内容路由到普通对象(或当然的实例),以便代理表现为普通对象。通过扩展处理程序(在本例中为get
部分),您可以非常轻松地通过以下方式路由Array.prototype
方法。
因此,每当任何属性(名称为name
)被提取时,代码路径如下:
inst[name]
。Array.prototype[name]
。undefined
。如果您想使用代理,可以使用最新版本的V8,例如在每晚构建的Chromium中(确保以chrome --js-flags="--harmony"
运行)。同样,代理不能用于“正常”使用,因为它们相对较新,改变了JavaScript的许多基本部分,实际上还没有正式指定(仍然是草稿)。
这是一个简单的图表(inst
实际上是实例被包装的代理)。请注意,它只说明获取属性;由于未经修改的转发处理程序,所有其他操作都由代理简单地传递。
代理代码如下:
function Test(a, b, c) {
this[0] = a;
this[1] = b;
this[2] = c;
this.length = 3; // needed for .slice to work
}
Test.prototype.foo = "bar";
Test = (function(old) { // replace function with another function
// that returns an interceptor proxy instead
// of the actual instance
return function() {
var bind = Function.prototype.bind,
slice = Array.prototype.slice,
args = slice.call(arguments),
// to pass all arguments along with a new call:
inst = new(bind.apply(old, [null].concat(args))),
// ^ is ignored because of `new`
// which forces `this`
handler = new Proxy.Handler(inst); // create a forwarding handler
// for the instance
handler.get = function(receiver, name) { // overwrite `get` handler
if(name in inst) { // just return a property on the instance
return inst[name];
}
if(name in Array.prototype) { // otherwise try returning a function
// that calls the appropriate method
// on the instance
return function() {
return Array.prototype[name].apply(inst, arguments);
};
}
};
return Proxy.create(handler, Test.prototype);
};
})(Test);
var test = new Test(123, 456, 789),
sliced = test.slice(1);
console.log(sliced); // [456, 789]
console.log("2" in test); // true
console.log("2" in sliced); // false
console.log(test instanceof Test); // true
// (due to second argument to Proxy.create)
console.log(test.foo); // "bar"
转发处理程序位于the official harmony wiki。
Proxy.Handler = function(target) {
this.target = target;
};
Proxy.Handler.prototype = {
// Object.getOwnPropertyDescriptor(proxy, name) -> pd | undefined
getOwnPropertyDescriptor: function(name) {
var desc = Object.getOwnPropertyDescriptor(this.target, name);
if (desc !== undefined) { desc.configurable = true; }
return desc;
},
// Object.getPropertyDescriptor(proxy, name) -> pd | undefined
getPropertyDescriptor: function(name) {
var desc = Object.getPropertyDescriptor(this.target, name);
if (desc !== undefined) { desc.configurable = true; }
return desc;
},
// Object.getOwnPropertyNames(proxy) -> [ string ]
getOwnPropertyNames: function() {
return Object.getOwnPropertyNames(this.target);
},
// Object.getPropertyNames(proxy) -> [ string ]
getPropertyNames: function() {
return Object.getPropertyNames(this.target);
},
// Object.defineProperty(proxy, name, pd) -> undefined
defineProperty: function(name, desc) {
return Object.defineProperty(this.target, name, desc);
},
// delete proxy[name] -> boolean
delete: function(name) { return delete this.target[name]; },
// Object.{freeze|seal|preventExtensions}(proxy) -> proxy
fix: function() {
// As long as target is not frozen, the proxy won't allow itself to be fixed
if (!Object.isFrozen(this.target)) {
return undefined;
}
var props = {};
Object.getOwnPropertyNames(this.target).forEach(function(name) {
props[name] = Object.getOwnPropertyDescriptor(this.target, name);
}.bind(this));
return props;
},
// == derived traps ==
// name in proxy -> boolean
has: function(name) { return name in this.target; },
// ({}).hasOwnProperty.call(proxy, name) -> boolean
hasOwn: function(name) { return ({}).hasOwnProperty.call(this.target, name); },
// proxy[name] -> any
get: function(receiver, name) { return this.target[name]; },
// proxy[name] = value
set: function(receiver, name, value) {
this.target[name] = value;
return true;
},
// for (var name in proxy) { ... }
enumerate: function() {
var result = [];
for (var name in this.target) { result.push(name); };
return result;
},
// Object.keys(proxy) -> [ string ]
keys: function() { return Object.keys(this.target); }
};