使用动态参数调用动态函数

我在找一个关于这个的把戏。我知道如何在 JavaScript 中调用一个动态的、任意的函数，传递特定的参数，像这样:

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


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


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

我知道如何使用 mainfunc中的 arguments集合传递可选的、无限制的参数，但是，我不知道如何将任意数量的参数发送到 mainfunc并动态地发送到 calledfunc; 我如何能够完成这样的事情，但是使用任意数量的可选参数(不使用那个丑陋的 if-else) ？

function mainfunc(func){
if(arguments.length == 3)
window[func](arguments[1], arguments[2]);
else if(arguments.length == 4)
window[func](arguments[1], arguments[2], arguments[3]);
else if(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');
239249 次浏览
小开
最佳答案

使用函数的 application 方法:-

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

Edit : 我突然想到，如果稍微调整一下:-，这会更有用

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

这将在浏览器之外工作(this默认为全局空间)。在 mainfunc 上使用 call 也可以:-

function target(a) {
alert(a)
}


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


mainfunc("target", "Hello");


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

你就不能传递 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');
小开

你可以用 .apply()

您需要指定一个 this... 我想您可以在 mainfunc中使用 this。

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


window[func].apply(this, args);
}
小开

您的代码只适用于全局函数。window对象的成员。若要与任意函数一起使用它，请将函数本身而不是它的名称作为字符串传递:

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"
小开

以下是你需要的:

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

第一个参数用作函数名，其余所有参数用作被调用函数的参数..。

我们可以使用 shift方法返回并从参数数组中删除第一个值。注意，我们从 Array 原型中调用了它，因为严格来说，参数不是一个真正的数组，所以不像普通数组那样继承 shift方法。

您也可以像这样调用 shift 方法:

[].shift.call(arguments);
小开

如果你想传递一些其他的参数，你必须一起创建所有参数的数组，例如:

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);
}
}
小开

最简单的方法可能是:

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


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

假设目标函数已经附加到一个“窗口”对象。

小开

如果有人仍然在寻找具有动态参数的动态函数调用-

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


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

现在我用这个:

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();
}
}
}
});
};
小开 
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))

控制台: 3


提交答案