Javascript - 捕獲對象屬性

Question

是否有可能在對象的（任何）屬性被訪問或嘗試訪問時捕獲？

例子：

我已創建自定義對象Foo

var Foo = (function(){ 
    var self = {}; 
    //... set a few properties 
    return self; 
})(); 

再有就是對Foo一些動作 - 有人試圖訪問屬性bar

Foo.bar 

有沒有辦法（原型，也許）來捕捉這個？ bar可能未定義在Foo上。我可以充分捕獲任何嘗試訪問未定義的屬性。

例如，如果bar上Foo不定，所以Foo.bar嘗試，是這樣的：

Foo.prototype.undefined = function(){ 
    var name = this.name; //name of property they attempted to access (bar) 
    Foo[name] = function(){ 
     //...do something 
    }; 
    return Foo[name]; 
} 

但功能不同，我的例子。

概念

Foo.* = function(){ 
} 

背景

如果我有一個自定義的功能，我可以聽每到這個函數被調用時（見下文）。只是想知道是否有可能通過財產訪問。

Foo = function(){}; 
Foo.prototype.call = function(thisArg){ 
    console.log(this, thisArg); 
    return this; 
} 

Answer 1

這將有可能在ECMAScript6，並可能現在在Firefox上使用新的proxy stuff。在那之前，不，恐怕沒有辦法掛鉤連鎖店。

我花了一段時間，但我終於找到my previous answer這個問題。查看代理等所有細節的答案。

下面是這個問題的答案代理例如：

var obj = new Proxy({}, { 
    get: function(target, name) { 
     if (!(name in target)) { 
      console.log("Getting non-existant property '" + name + "'"); 
      return undefined; 
     } 
     return target[name]; 
    }, 
    set: function(target, name, value) { 
     if (!(name in target)) { 
      console.log("Setting non-existant property '" + name + "', initial value: " + value); 
     } 
     target[name] = value; 
    } 
}); 

console.log("[before] obj.foo = " + obj.foo); 
obj.foo = "bar"; 
console.log("[after] obj.foo = " + obj.foo); 

Live Copy（目前僅適用於火狐） | Source

運行時，輸出：

Getting non-existant property 'foo' 
[before] obj.foo = undefined 
Setting non-existant property 'foo', initial value: bar 
[after] obj.foo = bar

Answer 2

隨着新添加的JavaScript defineProperties，defineGetter和defineSetter，你可以做有點類似。但是，仍然沒有真正的方法來隱藏對象的__properties__。我建議你看到這個article。

var obj = { 
    __properties__: { 
     a: 4 
    } 
} 
Object.defineProperties(obj, { 
    "b": { get: function() { return this.__properties__.a + 1; } }, 
    "c": { get: function (x) { this.__properties__.a = x/2; } } 
}); 

obj.b // 2 
obj.c // .5 

這是典型的那種模型應該在任何環境下工作

//lame example of a model 
var Model = function(a) { 
    this.__properties__ = {a: a}; 
} 

Model.prototype.get = function(item) { 
    //do processing 
    return this.__properties__[item]; 
} 

Model.prototype.set = function(item, val) { 
    //do processing 
    this.__properties__[item] = val; 
    return this; 
} 

var model = new Model(5); 
model.get("a") // => 5 

Answer 3

我你想調試東西的假設下寫這個。正如Crowder所說，這隻適用於較新的瀏覽器;所以它的非常有用測試代碼，做你不想要的東西。但是，我刪除它的生產代碼。

Object.defineProperty(Foo, 'bar', { 
    set: function() { 
    debugger; // Here is where I'll take a look in the developer console, figure out what's 
    // gone wrong, and then remove this whole block. 
    } 
}); 

看起來像megawac擊敗了我。您還可以在here的功能上找到一些Mozilla文檔。

Answer 4

正如提到的其他答案，目前沒有辦法攔截未定義的屬性。

雖然這可以接受嗎？

var myObj = (function() { 
    var props = { 
    foo : 'foo' 
    } 
    return { 
    getProp : function(propName) { return (propName in props) ? props[propName] : 'Nuh-uh!' } 
    } 
}()); 

console.log(myObj.getProp('foo')); // foo 
console.log(myObj.getProp('bar')); // Nuh-uh 

Answer 5

像已經回答的那樣，只能使用ECMAScript6中的Proxy對象。同時，根據您的需求和整體設計，您仍然可以通過實施類似的方式來實現這一目標。

E.g.

function WrappingProxy(object, noSuchMember) { 
    if (!this instanceof WrappingProxy) return new WrappingProxy(object); 

    this._object = object; 

    if (noSuchMember) this.noSuchMember = noSuchMember; 
} 

WrappingProxy.prototype = { 
    constructor: WrappingProxy, 

    get: function (propertyName) { 
     var obj = this._object; 

     if (propertyName in obj) return obj[propertyName]; 

     if (this.noSuchMember) this.noSuchMember(propertyName, 'property'); 
    }, 

    set: function (propertyName, value) { 
     return this._object[propertyName] = value; 
    }, 

    invoke: function (functionName) { 
     var obj = this._object, 
      args = Array.prototype.slice.call(arguments, 1); 

     if (functionName in obj) return obj[functionName].apply(obj, args); 

     if (this.noSuchMember) { 
      this.noSuchMember.apply(obj, [functionName, 'function'].concat(args)); 
     } 
    }, 

    object: function() { return this._object }, 

    noSuchMember: null 
}; 

var obj = new WrappingProxy({ 
     testProp: 'test', 
     testFunc: function (v) { 
      return v; 
     } 
    }, 
    //noSuchMember handler 
    function (name, type) { 
     console.log(name, type, arguments[2]); 
    } 
); 

obj.get('testProp'); //test 
obj.get('nonExistingProperty'); //undefined, call noSuchMember 
obj.invoke('testFunc', 'test'); //test 
obj.invoke('nonExistingFunction', 'test'); //undefined, call noSuchMember 

//accesing properties directly on the wrapped object is not monitored 
obj.object().nonExistingProperty;