metodi arbitrari degli oggetti e le proprietà in JavaScript

Question

Sono sicuro che questo è stato definitivamente risposto prima, e ho provato a cercarlo .. forse i miei termini di ricerca sono sbagliate ...

Fondamentalmente ho un oggetto myObject e ho un insieme di proprietà e metodi definiti per questo. Quello che voglio fare è essere in grado di gestire chiamate/riferimenti a proprietà e metodi che non ho definito.

Per esempio, diciamo che ho questo:

var myObject = { 
    someProperty : 'foobar', 
    someFunction : function() { /* Do stuff */ } 
} 

Attualmente, se qualcuno cerca di effettuare una chiamata a myObject.someOtherFunction(), JavaScript urla e grida su di esso. Quello che voglio fare è impostare un modo per gestirlo automaticamente. Ad esempio, invece di JavaScript che genera un errore, il mio oggetto restituisce semplicemente false. È possibile?

Un altro modo di vedere le cose è questo:

var myObject = { 
    someFunction : function() { /* Do stuff */ } 
    magicBucket : function() { /* Do stuff */ } 
} 

Se chiamo myObject.someFunction(), ben definita e fa qualcosa. Quello che voglio che succeda è che, per esempio, se chiami myObject.someOtherFunction(), invece di JavaScript che genera un errore, chiamerebbe myObject.magicBucket().

Il motivo è che ho un client che utilizza una libreria di terze parti sul proprio sito. Vogliono smettere di usarlo, ma rimuoverlo completamente richiederà molto tempo e molti sforzi. Quindi, come soluzione a breve termine, volevano sapere se potevo creare un file fittizio che sostanzialmente non fa nulla. Bene, questa libreria utilizza diversi oggetti che hanno molti metodi. Potrei passare attraverso tutto e creare oggetti fittizi, ma ho pensato che forse ci potrebbe essere un semplice metodo "catch-all" per farlo.

Alcuni hanno menzionato controllando se il metodo esiste prima, avvolgendolo in una condizione o try..catch, ecc. Bene, il punto di questo è che in questo momento non riesco a toccare le chiamate effettive ai metodi. E poiché l'obiettivo generale è quello di rimuovere definitivamente la codifica, non è nemmeno applicabile.

Answer 1

No, non è possibile avere getter arbitrari in JavaScript. È possibile verificare se esiste una funzione prima di chiamare per prevenire l'errore però:

if (myObject.someOtherFunction) 
    myObject.someOtherFunction(); 

O, meglio, se non si sa che è necessariamente una funzione:

if (typeof myObject.someOtherFunction == 'function') 
    myObject.someOtherFunction(); 

Answer 2

si potrebbe creare un funzione wrapper in questo modo:

function callFunction(fn, args) { 
    var funct = this[fn]; 
    return (typeof funct == "function") 
     ? funct.apply(this, args) 
     : false; 
} 

e chiamare con:

callFunction("blah", [1, 2, 3]); 
>>> false 

Un esempio:

this.foo = function(a, b) { 
    console.log(a); 
    return b; 
} 
callFunction("foo", [1, 2, 3]); 
>>> 1 
>>> 2 # return value 

Answer 3

C'è una proprietà speciale chiamato __noSuchMethod__ che fa esattamente quello che hai appena descritto. Tuttavia è una proprietà non standard. Funziona solo su Firefox. Ecco come lo usi:

var o = { 
    __noSuchMethod__: function (name, args) { 
     alert(name); // prints the name of the method 
     alert(args); // prints the array of arguments 
    } 
}; 

o.abc(1, 2, 3); // OUTPUT: abc 1,2,3 

Il futuro tuttavia sono proxy objects.Il seguente è un breve tutorial sui proxy: Proxy Tutorial

Answer 4

Un aggiornamento su proxy, qui è un array infinito:

$ var squares = new Proxy([], {get:(target,key) => key*key}); 
$ squares[2] 
4 
$ Array.isArray(squares) 
true 
Unfortunately: 
$ squares.length 
NaN // Want Infinity. 

E un oggetto fittizio:

$ x = new Proxy({}, {get:(target,key) => console.error("The computer says no", key)}) 
$ x.laugh 
The computer says no laugh 

Quest'ultimo aiuterebbe PO fare un oggetto fittizio, anche se ci vorrebbe un po 'di magia nera per scoprire quale tipo di manichino restituire.

Un up-to data di riferimento: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Proxy