从错误中恢复

Question

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

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

例如,如果你想调用一个.slice()方法,而我没有一个方法,那么window.onerror处理程序会为我启动它

无论如何,我在这里玩这个

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

顺便说一句,我知道我可以加载我的对象

['slice', 'push', '...'].forEach(function() { myLib.prototype[this] = [][this]; });

那不是我想要的

Answer 1

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

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

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

因此，每当获取任何属性（具有 name name）时，代码路径如下：

1. 尝试返回inst[name]。
2. 否则，尝试返回一个适用于具有Array.prototype[name]给定参数的实例的函数。
3. 否则，就返回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"

转发处理程序可在官方 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); }
};