从错误中恢复

时间:2012-02-01 18:28:25

标签: javascript error-handling constructor onerror

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

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

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

这不是我想要的

1 个答案:

答案 0 :(得分:4)

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

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

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

因此,每当任何属性(名称为name)被提取时,代码路径如下:

  1. 尝试返回inst[name]
  2. 否则,尝试返回一个函数,该函数在具有给定参数的实例上应用Array.prototype[name]
  3. 否则,只需返回undefined
  4. 如果您想使用代理,可以使用最新版本的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); }
    };