Setter per una proprietà dinamica in javascript

Question

Mi chiedo se è possibile avere un setter per una proprietà dinamica in Javascript?

Quindi questo:

var myobj = new MyObj(); 

myobj.a_custom_prop = 'something'; 

chiamerei una funzione in grado di recuperare 'a_custom_prop' e 'qualcosa di'

Per essere chiari, vorrei una funzione simile a:

MyObj.property.define = function (prop, value) { }; 

da chiamare in questo modo:

myobj.prop = value; 

invece di:

myobj.define('prop', value); 

Sapendo che il nome della proprietà non è relativa alla statica myobj, altrimenti avrei usato:

Object.defineProperty(MyObj.prototype, 'a_custom_prop', { 
    set: function (value) { /*...*/ } 
}); 

Answer 1

Quello che si desidera è simile a method missing in Ruby, dove si definisce una funzione che gestirà le chiamate a metodi non definiti.

Come si può leggere qui: Does Javascript have something like Ruby's method_missing feature? JavaScript non ha ancora qualcosa di simile, ma c'è una proposta di ES6: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

Answer 2

Non potresti usare qualcosa di simile?

function MyObj(){ 
... 
this.dynamicPropertyName = 'something'; 
... 
} 
MyObj.prototype.setThatProp = function(i){ 
this[this.dynamicPropertyName] = i; 
} 
... 
var myObj = new MyObj(); 
myObj.setThatProp(5); 

EDIT:

O qualcosa di simile:

MyObj.prototype.__defineSetter__('prop', function(val){ this[this.dynamicPropertyName] = val; }); 
... 
var myObj = new MyObj(); 
myObj.prop = 5; 

Esempio utilizzo:

Answer 3

No, non è attualmente possibile.

Answer 4

Come Yoshi ha dichiarato in un commento, potrebbe essere possibile utilizzare Object.observe() dal Bozza ES7.

Tuttavia non è esattamente un "setter catch-all" perché verrà attivato solo dopo la proprietà è stata modificata, non prima. Quindi, se per esempio si desidera memorizzare la proprietà da qualche altra parte, sarà necessario farlo delete. Poiché la richiamata observe è asincrona, verrà eseguita dopo il callstack corrente, il che significa che il nuovo valore può essere immediatamente utilizzato prima di essere modificato.

Inoltre, Chrome solo per ora.

Il seguente frammento esegue alcune manipolazioni sull'oggetto tramite l'impostazione nativa e utilizza Object.observe.Si registra nel seguente ordine:

1. ho aggiunto questo valore: foobar
2. Il callback recupera: foobar
3. Valore della foo.bar dopo la cancellazione: undefined

Qui va:

var foo = {}; 

Object.observe(foo, function(changes) { 
    var lastChanges = changes[changes.length - 1], 
     newValue = lastChanges.object[lastChanges.name]; 

    console.log('The callback retrieves: ' + newValue); 
    delete lastChanges.object[lastChanges.name]; 
}, ['add']); 

foo.bar = 'foobar'; //Log n°2 
console.log('I added this value: ' + foo.bar); //Log n°1 
setTimeout(function() { 
    console.log('Value of foo.bar after deletion: ' + foo.bar); //Log n°3 
}, 0); //Execute after the observe callback 

---

A causa del fac Che sia nella bozza ES7, la precedente potrebbe essere completamente sbagliata a seconda di quando leggi questo.