Chiamare la funzione dynamic con parametri dinamici in Javascript

Sto cercando un trucco per questo. So come chiamare una funzione dynamic e arbitraria in Javascript, passando parametri specifici, qualcosa del genere:

function mainfunc (func, par1, par2){ window[func](par1, par2); } function calledfunc(par1, par2){ // Do stuff here } mainfunc('calledfunc','hello','bye'); 

So come passare parametri facoltativi e illimitati usando la raccolta di argomenti [] all’interno di mainfunc , ma non riesco a capire come inviare un numero arbitrario di parametri a mainfunc per essere inviato a callfunc dynamicmente; come posso realizzare qualcosa di simile, ma con un numero qualsiasi di argomenti opzionali (non usando quel brutto if-else )? :

 function mainfunc (func){ if(arguments.length == 3) window[func](arguments[1], arguments[2]); elseif(arguments.length == 4) window[func](arguments[1], arguments[2], arguments[3]); elseif(arguments.length == 5) window[func](arguments[1], arguments[2], arguments[3], arguments[4]); } function calledfunc1(par1, par2){ // Do stuff here } function calledfunc2(par1, par2, par3){ // Do stuff here } mainfunc('calledfunc1','hello','bye'); mainfunc('calledfunc2','hello','bye','goodbye'); 

Usa il metodo apply di una funzione: –

 function mainfunc (func){ window[func].apply(null, Array.prototype.slice.call(arguments, 1)); } 

Edit : Mi sembra che questo sarebbe molto più utile con un leggero ritouch: –

 function mainfunc (func){ this[func].apply(this, Array.prototype.slice.call(arguments, 1)); } 

Funzionerà al di fuori del browser (predefinito per lo spazio globale). L’uso della chiamata su mainfunc funzionerebbe anche: –

 function target(a) { alert(a) } var o = { suffix: " World", target: function(s) { alert(s + this.suffix); } }; mainfunc("target", "Hello"); mainfunc.call(o, "target", "Hello"); 

Il tuo codice funziona solo per funzioni globali, es. membri dell’object window . Per usarlo con funzioni arbitrarie, passa la funzione stessa al posto del suo nome come stringa:

 function dispatch(fn, args) { fn = (typeof fn == "function") ? fn : window[fn]; // Allow fn to be a function object or the name of a global function return fn.apply(this, args || []); // args is optional, use an empty array by default } function f1() {} function f2() { var f = function() {}; dispatch(f, [1, 2, 3]); } dispatch(f1, ["foobar"]); dispatch("f1", ["foobar"]); f2(); // calls inner-function "f" in "f2" dispatch("f", [1, 2, 3]); // doesn't work since "f" is local in "f2" 

Puoi usare .apply()

Devi specificare this … Suppongo che tu possa usare this all’interno di mainfunc .

 function mainfunc (func) { var args = new Array(); for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); window[func].apply(this, args); } 

Ecco di cosa hai bisogno:

 function mainfunc (){ window[Array.prototype.shift.call(arguments)].apply(null, arguments); } 

Il primo argomento è usato come nome della funzione e tutti quelli rimanenti sono usati come argomenti per la funzione chiamata …

Siamo in grado di utilizzare il metodo shift per restituire e quindi eliminare il primo valore dall’array degli argomenti. Si noti che l’abbiamo chiamato dal prototipo di Array poiché, in senso stretto, ‘arguments’ non è un array reale e quindi non eredita il metodo shift come farebbe un array normale.


Puoi anche chiamare il metodo Shift in questo modo:

 [].shift.call(arguments); 

Il modo più semplice potrebbe essere:

 var func='myDynamicFunction_'+myHandler; var arg1 = 100, arg2 = 'abc'; window[func].apply(null,[arg1, arg2]); 

Supponendo che la funzione objective sia già associata a un object “finestra”.

Se vuoi passare con “argomenti” pochi altri, devi creare l’array di tutti gli argomenti insieme, cioè in questo modo:

 var Log = { log: function() { var args = ['myarg here']; for(i=0; i 

Ora sto usando questo:

 Dialoglar.Confirm = function (_title, _question, callback_OK) { var confirmArguments = arguments; bootbox.dialog({ title: "" + _title + "", message: _question, buttons: { success: { label: "OK", className: "btn-success", callback: function () { if (typeof(callback_OK) == "function") { callback_OK.apply(this,Array.prototype.slice.call(confirmArguments, 3)); } } }, danger: { label: "Cancel", className: "btn-danger", callback: function () { $(this).hide(); } } } }); }; 
 function a(a, b) { return a + b }; function call_a() { return a.apply(a, Array.prototype.slice.call(arguments, 0)); } console.log(call_a(1, 2)) 

console: 3

Non potresti semplicemente passare l’array degli arguments ?

 function mainfunc (func){ // remove the first argument containing the function name arguments.shift(); window[func].apply(null, arguments); } function calledfunc1(args){ // Do stuff here } function calledfunc2(args){ // Do stuff here } mainfunc('calledfunc1','hello','bye'); mainfunc('calledfunc2','hello','bye','goodbye'); 

Nel caso qualcuno stia ancora cercando una chiamata di funzione dynamic con parametri dinamici –

 callFunction("aaa('hello', 'world')"); function callFunction(func) { try { eval(func); } catch (e) { } } function aaa(a, b) { alert(a + ' ' + b); }