javascript - 从错误中恢复

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

顺便说一句，我知道我可以用

加载我的对象

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

这不是我要的

Answer 1

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

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

请注意，默认情况下，代理是“黑洞”。它们不对应于任何对象(例如，在代理上设置属性只调用 set 陷阱(拦截器)；实际存储你必须自己做)。但是有一个“转发处理程序”可用，它将所有内容路由到一个普通对象(或者当然是一个实例)，这样代理就可以像一个普通对象一样工作。通过扩展处理程序(在本例中为 get 部分)，您可以很容易地按如下方式路由 Array.prototype 方法。

因此，无论何时获取任何属性(名称为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"

---

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