從錯誤中恢復

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

也發揮各地（也許我應該開始一個新的問題），我可以改變我的構造函數採取未指定數量的參數？

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。

如果你要玩的代理，你可以在Chromium的每晚構建使用最新版本V8，例如（確保爲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); } 
};