dinamicas - Llamada de función dinámica con parámetros dinámicos en Javascript

tablas dinamicas html javascript

Question

Esta pregunta ya tiene una respuesta aquí:

• Pasar una matriz como parámetro de función en JavaScript 7 respuestas
• Pasar argumentos a otra función de JavaScript [duplicar] 3 respuestas

Estoy buscando un truco sobre esto. Sé cómo llamar a una función dinámica y arbitraria en Javascript, pasando parámetros específicos, algo como esto:

function mainfunc (func, par1, par2){
    window[func](par1, par2);
}

function calledfunc(par1, par2){
    // Do stuff here
}

mainfunc(''calledfunc'',''hello'',''bye'');

Sé cómo pasar parámetros ilimitados opcionales usando la recolección de argumentos [] dentro de mainfunc , pero no sé cómo enviar un número arbitrario de parámetros a mainfunc para enviarlos a calledfunc dinámicamente; ¿Cómo puedo lograr algo como esto, pero con cualquier cantidad de argumentos opcionales (sin usar ese feo 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'');

Answer 1

¿No podrías pasar la matriz de arguments largo?

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

Answer 2

Ahora estoy usando esto:

Dialoglar.Confirm = function (_title, _question, callback_OK) {
    var confirmArguments = arguments;
    bootbox.dialog({
        title: "<b>" + _title + "</b>",
        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();
                }
            }
        }
    });
};

Answer 3

En caso de que alguien todavía esté buscando una llamada de función dinámica con parámetros dinámicos,

callFunction("aaa(''hello'', ''world'')");

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

Answer 4

Esto es lo que necesitas:

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

El primer argumento se usa como el nombre de la función y todos los restantes se usan como argumentos para la función llamada ...

Podemos usar el método shift para devolver y luego eliminar el primer valor de la matriz de argumentos. Tenga en cuenta que lo hemos llamado desde el prototipo de matriz, ya que, en sentido estricto, "argumentos" no es una matriz real y, por lo tanto, no hereda el método de shift como haría una matriz común.

También puede llamar al método shift de esta manera:

[].shift.call(arguments);

Answer 5

La forma más simple podría ser:

var func=''myDynamicFunction_''+myHandler;
var arg1 = 100, arg2 = ''abc'';

window[func].apply(null,[arg1, arg2]);

Asumiendo, esa función objetivo ya está unida a un objeto "ventana".

Answer 6

Puede usar .apply()

Necesitas especificar this ... Supongo que podrías usar this dentro de 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);
}

Answer 7

Si quiere pasar con "argumentos" algunos otros, debe crear la matriz de todos los argumentos juntos, es decir, así:

var Log = {
    log: function() {
        var args = [''myarg here''];
        for(i=0; i<arguments.length; i++) args = args.concat(arguments[i]);
        console.log.apply(this, args);
    }
}

Answer 8

Tu código solo funciona para funciones globales, es decir. miembros del objeto window . Para usarlo con funciones arbitrarias, pase la función en sí misma en lugar de su nombre como una cadena:

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"

Answer 9

Use el método de aplicar de una función:

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

Editar : Se me ocurre que esto sería mucho más útil con un ligero ajuste: -

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

Esto funcionará fuera del navegador ( this predeterminado para el espacio global). El uso de call on mainfunc también funcionaría:

function target(a) {
    alert(a)
}

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

mainfunc("target", "Hello");

mainfunc.call(o, "target", "Hello");

Answer 10

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

consola: 3