Question

在我因为尝试如此鲁莽的事情而大喊大叫之前，让我告诉你，我不会在现实生活中这样做，这是一个学术问题。

假设我正在编写一个库，我希望我的对象能够根据需要编写方法。

例如，如果您想调用.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]; });

这不是我想要的

Answer 1

当您提出学术问题时，我认为浏览器兼容性不是问题。如果确实没有，我想为此介绍和谐代理。 onerror不是一个很好的做法，因为它只是在某处发生错误时引发的事件。如果有的话，它应该只作为最后的手段使用。（我知道你说你还是不用它，但onerror对开发人员不太友好。）

基本上，代理使您能够拦截JavaScript中的大多数基本操作 - 最值得注意的是获取任何有用的属性。在这种情况下，您可以拦截获取.slice的过程。

请注意，默认情况下代理是“黑洞”。它们与任何对象都不对应（例如，在代理上设置属性只调用set陷阱（拦截器）;您必须自己实际存储）。但是有一个“转发处理程序”可用于将所有内容路由到普通对象（或当然的实例），以便代理表现为普通对象。通过扩展处理程序（在本例中为get部分），您可以非常轻松地通过以下方式路由Array.prototype方法。

因此，每当任何属性（名称为name）被提取时，代码路径如下：

尝试返回inst[name]。
否则，尝试返回一个函数，该函数在具有给定参数的实例上应用Array.prototype[name]。
否则，只需返回undefined。

如果您想使用代理，可以使用最新版本的V8，例如在每晚构建的Chromium中（确保以chrome --js-flags="--harmony"运行）。同样，代理不能用于“正常”使用，因为它们相对较新，改变了JavaScript的许多基本部分，实际上还没有正式指定（仍然是草稿）。

这是一个简单的图表（inst实际上是实例被包装的代理）。请注意，它只说明获取属性;由于未经修改的转发处理程序，所有其他操作都由代理简单地传递。

proxy diagram

代理代码如下：

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); }
};

从错误中恢复

1 个答案: