Javascript 基于输入参数调用嵌套函数

我有一个这样的函数

function myfun(input1, input2, input3){
    //
    // Other codes which deals with input2 and input3 (irrelevant)
    //
    function a(){
        console.log('func a');
    }
    function b(){
        console.log('func b');
    }
    function c(){
        console.log('func c');
    }
    function d(){
        console.log('func d');
    }
    // input1 is an array
    for(var i=0; i<input1.length; i++){
        var name = input1[i];
        name(); // Doesn't work as 'name' refers to a string;
        this[name](); // Doesn't work;
        // How can i execute the nested function whose name is stored in input array ?
    }
}
myfun(['b','d'], 'foo', 'bar');

函数myfun（input1、input2、input3）{
//
//处理输入2和输入3的其他代码（无关）
//
函数a（）{
console.log（'func a'）；
}
函数b（）{
console.log（'func b'）；
}
函数c（）{
console.log（'func'）；
}
函数d（）{
console.log（'func d'）；
}
//input1是一个数组
对于（var i=0；i编辑

正如@Felix所建议的，有一种更好的方法（在效率方面）可以做到这一点-

var myfun = (function () {
    var util = {
        a: function (){
            console.log('method a');
        },
        b: function (){
            console.log('method b');
        },
        c: function (){
            console.log('method c');
        },
        d: function (){
            console.log('method d');
        }
    };

    return function (input1, input2, input3) {
        for(var i=0; i<input1.length; i++){
            var name = input1[i];
            util[name]();
        }
    };
}());

myfun(['b','d'], 'foo', 'bar');

编辑

正如@Felix所建议的，有一种更好的方法（在效率方面）可以做到这一点-

var myfun = (function () {
    var util = {
        a: function (){
            console.log('method a');
        },
        b: function (){
            console.log('method b');
        },
        c: function (){
            console.log('method c');
        },
        d: function (){
            console.log('method d');
        }
    };

    return function (input1, input2, input3) {
        for(var i=0; i<input1.length; i++){
            var name = input1[i];
            util[name]();
        }
    };
}());

myfun(['b','d'], 'foo', 'bar');

编辑

正如@Felix所建议的，有一种更好的方法（在效率方面）可以做到这一点-

var myfun = (function () {
    var util = {
        a: function (){
            console.log('method a');
        },
        b: function (){
            console.log('method b');
        },
        c: function (){
            console.log('method c');
        },
        d: function (){
            console.log('method d');
        }
    };

    return function (input1, input2, input3) {
        for(var i=0; i<input1.length; i++){
            var name = input1[i];
            util[name]();
        }
    };
}());

myfun(['b','d'], 'foo', 'bar');

编辑

正如@Felix所建议的，有一种更好的方法（在效率方面）可以做到这一点-

var myfun = (function () {
    var util = {
        a: function (){
            console.log('method a');
        },
        b: function (){
            console.log('method b');
        },
        c: function (){
            console.log('method c');
        },
        d: function (){
            console.log('method d');
        }
    };

    return function (input1, input2, input3) {
        for(var i=0; i<input1.length; i++){
            var name = input1[i];
            util[name]();
        }
    };
}());

myfun(['b','d'], 'foo', 'bar');

编辑：

必须使函数成为对象的成员

var funcFactory = {
    a:function(){
        console.log('func a');
    },
    b:function(){
        console.log('func b');
    },
    c:function(){
        console.log('func c');
    },
    d:function(){
        console.log('func d');
    },
    call:function(input1, input2, input3){     
        for(var i=0; i<input1.length; i++){
           var name = input1[i];
            this[name](); // Doesn't work;
        }
    }
}
funcFactory.call(['b','d'],foo,bar);

var funcFactory={
a:函数（）{
console.log（'func a'）；
},
b:函数（）{
console.log（'func b'）；
},
c:函数（）{
console.log（'func'）；
},
d:函数（）{
console.log（'func d'）；
},
调用：函数（input1，input2，input3）{
对于（var i=0；i编辑：

必须使函数成为对象的成员

var funcFactory = {
    a:function(){
        console.log('func a');
    },
    b:function(){
        console.log('func b');
    },
    c:function(){
        console.log('func c');
    },
    d:function(){
        console.log('func d');
    },
    call:function(input1, input2, input3){     
        for(var i=0; i<input1.length; i++){
           var name = input1[i];
            this[name](); // Doesn't work;
        }
    }
}
funcFactory.call(['b','d'],foo,bar);

var funcFactory={
a:函数（）{
console.log（'func a'）；
},
b:函数（）{
console.log（'func b'）；
},
c:函数（）{
console.log（'func'）；
},
d:函数（）{
console.log（'func d'）；
},
调用：函数（input1，input2，input3）{
对于（var i=0；i编辑：

必须使函数成为对象的成员

var funcFactory = {
    a:function(){
        console.log('func a');
    },
    b:function(){
        console.log('func b');
    },
    c:function(){
        console.log('func c');
    },
    d:function(){
        console.log('func d');
    },
    call:function(input1, input2, input3){     
        for(var i=0; i<input1.length; i++){
           var name = input1[i];
            this[name](); // Doesn't work;
        }
    }
}
funcFactory.call(['b','d'],foo,bar);

var funcFactory={
a:函数（）{
console.log（'func a'）；
},
b:函数（）{
console.log（'func b'）；
},
c:函数（）{
console.log（'func'）；
},
d:函数（）{
console.log（'func d'）；
},
调用：函数（input1，input2，input3）{
对于（var i=0；i编辑：

必须使函数成为对象的成员

var funcFactory = {
    a:function(){
        console.log('func a');
    },
    b:function(){
        console.log('func b');
    },
    c:function(){
        console.log('func c');
    },
    d:function(){
        console.log('func d');
    },
    call:function(input1, input2, input3){     
        for(var i=0; i<input1.length; i++){
           var name = input1[i];
            this[name](); // Doesn't work;
        }
    }
}
funcFactory.call(['b','d'],foo,bar);

var funcFactory={
a:函数（）{
console.log（'func a'）；
},
b:函数（）{
console.log（'func b'）；
},
c:函数（）{
console.log（'func'）；
},
d:函数（）{
console.log（'func d'）；
},
调用：函数（input1，input2，input3）{
对于（var i=0；i替换name（）；使用eval（name+“（）”）；
替换name（）；使用eval（name+“（）”）；
替换name（）；使用eval（name+“（）”）；
替换name（）；使用eval（name+“（）”）给定OP的代码，这将使函数成为全局函数，因为
这个
将引用
窗口
。您没有使函数成为外部函数的“成员”。是的，我尝试了这个，但正如@FelixKling所说，它创建了这个引用窗口。啊，对。您需要它们位于对象{a:function（）{}…}中给定OP的代码，这将使函数成为全局函数，因为
this
将引用
window
。您没有使函数成为外部函数的“成员”。是的，我尝试了这个，但正如@FelixKling所说，它创建了这个引用窗口。啊，对。您需要它们位于对象{a:function（）{}…}中给定OP的代码，这将使函数成为全局函数，因为
this
将引用
window
。您没有使函数成为外部函数的“成员”。是的，我尝试了这个，但正如@FelixKling所说，它创建了这个引用窗口。啊，对。您需要它们位于对象{a:function（）{}…}中给定OP的代码，这将使函数成为全局函数，因为
this
将引用
window
。您没有使函数成为外部函数的“成员”。是的，我尝试了这个，但正如@FelixKling所说，它创建了这个引用窗口。啊，对。您需要它们位于对象{a:function（）{}…}中根据这些内部函数的性质，您可以使用IIFE只创建一次对象，并且仍然可以从外部访问这些函数。例如，
var myfun=（function（）{var util={}；return function（input1，…{…}；}（））是的，你说得很对，我错过了。谢谢你的输入，我已经编辑了我的答案！根据这些内部函数的性质，你可以使用IIFE只创建一次对象，仍然可以从外部访问这些函数。例如，
var myfun=（function（）{var util={}；return function（input1，{…}；}（））；
@FelixKling:是的，你完全正确，我错过了。谢谢你的输入，我已经编辑了我的答案！根据这些内部函数的性质，你可以使用IIFE只创建一次对象，并且仍然可以从外部访问这些函数。例如
var myfun=（function（）{var util={}；返回函数（input1，…{…}；}（））是的，你说得很对，我错过了。谢谢你的输入，我已经编辑了我的答案！根据这些内部函数的性质，你可以使用IIFE只创建一次对象，仍然可以从外部访问这些函数。例如，
var myfun=（function（）{var util={}；return function（input1，{…}；}（））；
@FelixKling:是的，你完全正确，我错过了。谢谢你的输入，我已经编辑了我的答案！既然你的代码中有
这个[name]（）；
，看看，更好地了解它是如何工作的。既然你有
这个[name]（）；
在您的代码中，查看，以更好地了解其工作原理。既然您的代码中有
此[名称]（）；
，请查看，以更好地了解其工作原理。既然您的代码中有
此[名称]（）；
，请查看，以更好地了解其工作原理