Javascript 从错误中恢复

在我因为鲁莽的尝试而被责骂之前，让我告诉你，在现实生活中我不会这么做，这是一个学术问题

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

例如，如果您想调用

.slice（）

方法，而我没有方法，那么

窗口.onerror

处理程序会为我启动它

不管怎样，我一直在玩这个

另外（也许我应该开始一个新的问题）我可以改变我的构造函数以获取未指定数量的参数吗

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

---

这不是我想要的

当你问一个学术问题时，我想浏览器兼容性不是问题。如果它确实不是，我想为它介绍harmony代理

onerror

不是很好的做法，因为它只是在某个地方发生错误时引发的事件。如果可能的话，它只能作为最后的手段。（我知道您说过无论如何都不会使用它，但是，

onerror

对开发人员不是很友好。）

基本上，代理使您能够拦截JavaScript中的大多数基本操作——最显著的是获取此处有用的任何属性。在这种情况下，您可以拦截获取

.slice

的过程

请注意，默认情况下代理是“黑洞”。它们与任何对象都不对应（例如，在代理上设置属性只是调用

set

trap（拦截器）；实际存储必须由您自己完成）。但是有一个“转发处理程序”可以将所有内容路由到一个普通对象（当然也可以是一个实例），这样代理就可以像普通对象一样工作。通过扩展处理程序（在本例中是

get

部分），您可以非常轻松地通过以下方式路由

Array.prototype

方法

因此，每当提取任何属性（名称为

name

）时，代码路径如下所示：

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"

尝试返回

inst[name]

否则，请尝试返回一个函数，该函数在实例上应用

Array.prototype[name]

，并为该函数提供给定参数

否则，只需返回

undefined

如果您想使用代理，可以使用最新版本的V8，例如在chrome的夜间构建中（确保以

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"

---

转发处理程序位于

---

听起来您似乎在考虑javascript，顺便说一句，使用try-catch块捕获异常通常更优雅、更可靠。

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