当我将JavaScript函数的名称作为字符串时，如何执行该函数

Question

我将JavaScript中的函数名作为字符串。如何将其转换为函数指针，以便稍后调用它？

根据具体情况，我可能还需要向方法中传递各种参数。

某些功能可以采用以下形式namespace.namespace.function（args[…]）.

Answer 1

不要使用评估除非你绝对的，肯定的别无选择。

如前所述，使用这样的方法是最好的方法：

窗口[“functionName”]（参数）；

然而，这不适用于命名空间函数：

窗口[“My.Namespace.functionName”]（参数）；//失败

这就是你要做的：

window[“My”][“Namespace”][“functionName”]（参数）；//成功

为了让这更容易并提供一些灵活性，这里有一个方便功能：

函数executeFunctionByName（functionName，context/*，args*/）{var args=Array.prototype.slice.call（参数，2）；var namespaces=functionName.split（“.”）；var func=命名空间.pop（）；for（var i=0；i<namespaces.length；i++）{context=context[namespaces[i]]；}return context[func].apply（context，args）；}

你可以这样称呼它：

executeFunctionByName（“My.Namespace.functionName”，窗口，参数）；

注意，您可以在任何上下文中传递，因此这与上面的操作相同：

executeFunctionByName（“Namespace.functionName”，My，参数）；

Answer 2

我只是想发布一个稍微修改过的版本Jason Bunting的功能非常有用.

首先，我通过向提供第二个参数简化了第一条语句切片（）。原始版本在除IE之外的所有浏览器中都运行良好。

第二，我已经更换了这具有上下文在返回语句中；否则，这总是指向窗口执行目标函数时。

函数executeFunctionByName（functionName，context/*，args*/）{var args=Array.prototype.slice.call（参数，2）；var namespaces=functionName.split（“.”）；var func=命名空间.pop（）；for（var i=0；i<namespaces.length；i++）{context=context[namespaces[i]]；}return context[func].apply（context，args）；}

Answer 3

另一个问题的答案向您展示了如何做到这一点：相当于Python的locals（）的Javascript？

基本上，你可以说

窗口[“foo”]（arg1，arg2）；

或者正如许多其他人所建议的那样，您可以只使用eval：

eval（fname）（arg1，arg2）；

尽管除非你完全确定自己在评估什么，否则这是非常不安全的。

Answer 4

我认为这样做的一种优雅方式是在散列对象中定义函数。然后可以使用字符串从散列中引用这些函数。例如。

var自定义对象={customFunction:函数（param）{…}};

然后您可以拨打：

自定义对象['customFunction']（参数）；

其中customFunction将是与对象中定义的函数匹配的字符串。

更新

似乎这个答案对许多其他的编码人员很有帮助，所以这里有一个更新的版本。

使用ES6，您可以另外使用计算的属性名称这会让你避免使用魔术弦。

const FunctionNames=对象.freeze（{FirstFunction:“FirstFunction”，第二功能：“第二功能”});...var自定义对象={[FunctionNames.FirstFunction]：函数（param）{…}，[FunctionNames.SecondFunction]：函数（param）｛…｝};...customObject[FunctionNames.FirstFunction]（参数）；

Answer 5

你能不能不这样做：

var codeToExecute=“My.Namespace.functionName（）”；var tmpFunc=新函数（codeToExecute）；tmpFunc（）；

您还可以使用此方法执行任何其他JavaScript。

Answer 6

使用ES6，您可以按名称访问类方法：

X类{方法1（）{console.log（“1”）；}方法2（）{本[方法1]（）；console.log（“2”）；}}设x=新x（）；x【方法2】（）；

输出将是：

12

Answer 7

两件事：

• 避免eval，它非常危险和缓慢

• 其次，函数存在于何处并不重要，“全局性”与此无关。x.y.foo（）可以通过启用x.y[“oo”]（）或x['y']['foo']（）甚至是窗口['x]['y']['foo']（）你可以这样无限期地连锁。

Answer 8

所有答案都假设可以通过全局范围（窗口）访问函数。然而，OP并没有做出这种假设。

如果函数位于本地作用域（也称为closure）中，并且没有被其他本地对象引用，那么运气不好：您必须使用评估（）AFAIK，参见在javascript中动态调用本地函数

Answer 9

根据您所在的位置，您还可以使用：

此[“函数名”]（）；自我[“函数名”]（）；窗口[“函数名”]（）；顶部[“函数名”]（）；globalThis[“函数名”]（）；

或者，在nodejs中

全局[“函数名”]（）

Answer 10

以下是我对杰森·本廷/亚历克斯·纳扎罗夫的出色回答的贡献，其中包括Crashalot要求的错误检查。

鉴于此（人为）序言：

a=函数（args）{console.log（'传递的全局函数：'）；for（var i=0；i<参数长度；i++）{console.log（“->”+参数[i]）；}};ns={}；ns.a=函数（参数）{console.log（'传递的命名空间函数：'）；for（var i=0；i<参数长度；i++）{console.log（“->”+参数[i]）；}};名称='nsa'；n_s_a=[‘斯诺登’]；noSuchAgency=函数（）{}；

然后执行以下功能：

函数executeFunctionByName（functionName，context/*，args*/）{变量args，命名空间，函数；if（typeof functionName===“undefined”）{throw“未指定函数名”；}if（eval类型（functionName）！=='函数“）{throw functionName+”不是函数“；}if（上下文类型！==“未定义”）{if（typeofcontext==='object'和context-instanceofArray====false）{if（typeof context[functionName]！==“function”）{抛出上下文+'.'+functionName+“不是函数”；}args=Array.prototype.slice.call（参数，2）；}其他{args=Array.prototype.slice.call（参数，1）；context=窗口；}}其他{context=窗口；}namespaces=functionName.split（“.”）；func=命名空间.pop（）；for（var i=0；i<namespaces.length；i++）{context=context[namespaces[i]]；}return context[func].apply（context，args）；}

将允许您通过存储在字符串中的名称（名称空间或全局）调用javascript函数，无论是否有参数（包括Array对象），都可以对遇到的任何错误提供反馈（希望能够捕捉到它们）。

示例输出显示了其工作原理：

//调用不带参数的全局函数executeFunctionByName（“a”）；/*输出：传递的全局函数：*///调用传递数字的全局函数（使用隐式窗口上下文）按名称执行功能（'a'，123）；/*输出：传递的全局函数：-> 123*///调用不带参数的命名空间函数executeFunctionByName（'ns.a'）；/*输出：传递的命名空间函数：*///调用命名空间函数传递字符串文本executeFunctionByName（'ns.a'，'无此类代理！'）；/*输出：传递的命名空间函数：->没有这样的机构！*///调用命名空间函数，显式上下文作为单独的参数，传递字符串文本和数组executeFunctionByName（'a'，ns，'没有这样的代理！'，[007，'是人']）；/*输出：传递的命名空间函数：->没有这样的机构！->7，是那个男人吗*///调用传递字符串变量的全局函数（使用隐式窗口上下文）executeFunctionByName（“a”，名称）；/*输出：传递的全局函数：->国家安全局*///通过字符串文字调用不存在的函数按名称执行功能（'n_s_a'）；/*输出：未捕获的n_s_a不是函数*///通过字符串变量调用不存在的函数按名称执行功能（n_s_a）；/*输出：Uncaught Snowden不是函数*///使用错误的命名空间引用调用现有函数executeFunctionByName（'a'，{}）；/*输出：Uncaught[object object].a不是函数*///不调用函数executeFunctionByName（）；/*输出：未指定未捕获的函数名*///通过空字符串调用executeFunctionByName（“”）；/*输出：Uncaught不是函数*///使用命名空间引用调用现有全局函数按名称执行功能（'noSuchAgency'，ns）；/*输出：Uncaught[object object]。noSuchAgency不是函数*/

Answer 11

只需通过以下方法将字符串转换为指针窗口[<方法名>].例子：

var function_name=“string”；函数名=窗口[函数名]；

现在你可以像指针一样使用它了。

Answer 12

这是我的Es6方法，它使您能够以字符串或函数名的形式调用函数，还使您能够将不同数量的参数传递给不同类型的函数：

函数fnCall（fn，…args）{让func=（类型fn==“字符串”）？窗口[fn]：fn；if（typeof func==“function”）func（…args）；else throw new Error（`${fn}不是函数！`）；}函数示例1（arg1）{console.log（arg1，arg1）}函数示例2（arg1，arg2）{console.log（arg1+“和”+arg2）}函数example3（）{console.log（“没有参数！”）}fnCall（“example1”，“test_1”）；fnCall（“example2”、“test_2”和“test3”）；fnCall（示例3）；fnCall（“示例4”）；//应在控制台中引发错误

Answer 13

如果要使用窗口[“functionName”]你可以这样做；

var myObject=新对象（）；myObject[“functionName”]（参数）；

例子：

var now=新日期（）；现在[“getFullYear”]（）

Answer 14

小心！！！

应尽量避免在JavaScript中通过字符串调用函数，原因有二：

原因1：一些代码模糊处理程序会破坏代码，因为它们会更改函数名，使字符串无效。

原因2：维护使用这种方法的代码要困难得多，因为很难定位字符串调用的方法的用法。

Answer 15

我认为您不需要复杂的中间函数或eval，也不需要依赖窗口等全局变量：

函数fun1（arg）{控制台.log（arg）；}函数fun2（arg）{控制台.log（arg）；}常量操作={功能1，娱乐2};操作[“fun1”]（“Hello World”）；operations.fun2（“Hello World”）；//如果愿意，可以使用中间变量设temp=“fun1”；操作[temp]（“Hello World”）；

它还将与导入的函数一起工作：

//模式.js导出函数fun1（arg）{控制台.log（arg）；}导出函数fun2（arg）{控制台.log（arg）；}

//索引.js从“./mod”导入{fun1，fun2}；常量操作={功能1，娱乐2};操作[“fun1”]（“Hello World”）；操作[“fun2”]（“Hello World”）；

由于它使用的是属性访问，所以它将在最小化或模糊处理后幸存下来，这与您在这里找到的一些答案相反。

Answer 16

很惊讶看到没有提到setTimeout。

要运行不带参数的函数，请执行以下操作：

var functionWithoutArguments=函数（）{console.log（“Executing function WithoutArguments”）；}setTimeout（“functionWithoutArguments（）”，0）；

要运行带参数的函数，请执行以下操作：

var functionWithArguments=函数（arg1，arg2）{console.log（“Executing function With Arguments”，arg1，arg2）；}setTimeout（“functionWithArguments（10，20）”）；

要运行深度命名空间函数，请执行以下操作：

var非常={_深深地：{_定义：{_函数：函数（num1，num2）{console.log（“Execution_very_deeply _defined_function:”，num1，num2）；}}}}setTimeout（“_very.deeply.defined._function（40,50）”，0）；

Answer 17

const myFnCollection={myFnStringName:函数（参数）{}};让fn=“myFnStringName”；// 1. 推荐if（窗口类型[fn]===“函数”）{窗口[fn]（参数）；}// 2. 推荐if（myFnCollection[fn]的类型===“函数”）{myFn集合[fn]（args）；}// 3. 评估是邪恶的；）if（eval类型（fn）===“函数”）{评估（fn）（参数）；}

Answer 18

因此，正如其他人所说，绝对最好的选择是：

窗口['myfunction']（参数）

就像杰森·邦廷说，如果函数的名称包含对象，则它将不起作用：

窗口['myobject.myfunction']（参数）；//行不通窗口['myobject']['myfunction']（参数）；//会起作用的

下面是我的函数版本，它将按名称执行所有函数（包括或不包括对象）：

我的={代码：{是：{nice：函数（a，b）{alert（a+“，”+b）；}}}};guy=函数（）{alert（'awesome'）；}函数executeFunctionByName（str，args）{var arr=str.split（'.'）；var fn=窗口[arr[0]]；对于（var i=1；i<arr.length；i++）{fn=fn[arr[i]]；}fn.应用（窗口，参数）；}executeFunctionByName（'my.code.is.nice'，['arg1'，'arg2']）；executeFunctionByName（“家伙”）；

Answer 19

让t0=（）=>{alert（'red0'）}var t1=（）=>{警报（'red1'）}var t2=（）=>｛警报（'rd2'）｝vart3=（）=>{alert（'red3'）}vart4=（）=>{alert（'red4'）}var t5=（）=>｛警报（'red5'）｝vart6=（）=>{alert（'red6'）}函数getSelection（类型）{var评估选择={“标题0”：t0，“标题1”：t1，“标题2”：t2，“标题3”：t3，“title4”：t4，“title5”：t5，“title6”：t6，“default”：函数（）{return'Default'；}};return（evalSelection[type]||evalSelection['default']）（）；}获取选择（'title1'）；

一个更面向对象的解决方案。。。

Answer 20

关于Jason和Alex的帖子的更多细节。我发现在上下文中添加默认值很有帮助。只要把context=context==未定义？窗口：上下文；在函数的开头。你可以改变窗口无论您首选的上下文是什么，那么每次在默认上下文中调用它时都不需要传入相同的变量。

Answer 21

为了补充Jason Bunting的答案，如果您正在使用nodejs或其他东西（这在dom js中也适用），可以使用这而不是窗口（记住：eval是邪恶的:

此['fun'+'ctionName']（）；

Answer 22

我的代码中有一个非常类似的东西。我有一个服务器生成的字符串，其中包含一个函数名，需要将其作为第三方库的回调传递。所以我有一个代码，它获取字符串并返回一个指向函数的“指针”，如果找不到，则返回null。

我的解决方案与“Jason Bunting的功能非常有用"*，虽然它不会自动执行，并且上下文始终显示在窗口上。但这很容易修改。

希望这对某人有所帮助。

/***将包含函数或对象方法名的字符串转换为函数指针。*@param string函数*@return函数*/函数getFuncFromString（func）{//如果已经是函数，则返回if（typeof func===‘function’）返回func；//如果是字符串，尝试查找对象的函数或方法（“obj.func”格式）if（函数类型===“字符串”）{if（！func.length）返回null；var目标=窗口；var func=函数分割（'.'）；while（函数长度）{var ns=函数移位（）；if（typeof target[ns]===“undefined”）返回null；目标=目标[ns]；}if（typeof target===“函数”）返回目标；}//如果无法解析，则返回null返回null；}

Answer 23

这里有一个健壮且可重用的解决方案，我最终为我的一个项目实现了它。

FunctionExecutor构造函数函数

用法：

let executor=new FunctionExecutor（）；executor.addFunction（两个）executor.addFunction（三个）执行人。执行（“一个”）；执行人。执行（“三”）；

显然，在项目中，添加所有需要按名称调用的函数都是通过循环完成的。

函数Executor：

函数FunctionExecutor（）{this.functions={}；this.addFunction=函数（fn）{让fnName=fn.name；this.functions[fnName]=fn；}this.execute=函数执行（fnName，…args）{if（this.functions中的fnName和this.fuctions[fnName]===“function”的类型）{return this.functions[fnName]（…args）；}其他{console.log（“找不到”+fnName+“函数”）；}}this.logFunctions=函数（）{console.log（this.functions）；}}

示例用法：

函数二（）{console.log（“两个”）；}函数三（）{console.log（“三”）；}let executor=new FunctionExecutor（）；executor.addFunction（两个）executor.addFunction（三个）执行人。执行（“一”）；执行人。执行（“三”）；

Answer 24

还有一些非常有用的方法。

http://devlicio.us/blogs/sergio_pereira/archive/2009/02/09/javascript-5-ways-to-call-a-function.aspx

var arrayMaker={someProperty:'此处有一些值'，make:function（arg1，arg2）｛返回[this，arg1，arg2]；},执行：函数名};

Answer 25

我忍不住要提到另一个技巧如果有未知数量的参数也作为字符串的一部分传递，则会有所帮助包含函数名称。例如：

var anningstring='调用my_func（123，true，“废话”）'；

如果您的Javascript正在HTML页面上运行，那么您只需要一个不可见的链接；您可以将字符串传递到onclick（单击）属性，并调用点击方法。

<a href=“#”id=“link_secret”><！--不可见--></a>

$（'#link_secret'）.attr（'onclick'，anningstring）；$（“#link_secret”）.click（）；

或创建<a>元素。

Answer 26

最简单的方法是像访问has元素一样访问它

窗口。客户端验证.forms.location_form

与相同

窗口。ClientSideValidations.forms['location_form']

Answer 27

人们一直这么说评估是危险和邪恶的，因为它可以运行任何任意代码。但是，如果将eval与白名单方法，假设您知道可能需要提前运行的所有可能的函数名，那么eval不再是安全问题，因为输入是不再武断。白名单是一种良好而频繁的安全模式。下面是一个示例：

函数runDynamicFn（fnName，…args）{//也可以通过严格控制的配置进行馈电const allowedFnNames=['fn1'，'ns1.ns2.fn3'，'ns4.fn4']；return allowedFnNames.includes（fnName）？eval（fnName）（…args）：未定义；}//测试功能：函数fn1（a）{console.log（'fn1用'调用，a）}runDynamicFn（'alert（“抓住你了！”）'）runDynamicFn（'fn1'，'foo'）

Answer 28

我喜欢简明的解决方案，所以可以采用这种更为ES6的方式：

const executeByName=（名称，originContext，…args）=>{const namespaces=name.split（'.'）；const func=名称空间.pop（）；const funcContext=namespaces.reduce（（context，namespace）=>context[namespace]，originContext）；return funcContext[func]（…args）；};

Answer 29

外观基本：

var namefunction=“jspure”；//字符串函数jspure（msg1=''，msg2=''）{控制台.log（消息1+（消息2！=“”？“/”+消息2:“”）；}//多个参数//试验结果window[namefunction]（'hello'，'hello again'）；//一些。。。eval[namefunction]='hello'；//使用字符串或其他东西，但其eval仅为一个参数，不存在多个

存在其他类型的函数是班看看例子尼尔斯·彼得森

Answer 30

谢谢你的回答。我在用Jason Bunting的功能在我的项目中。

我扩展了它，将其与可选超时一起使用，因为设置超时的常规方法不起作用。请参阅阿布希基斯诺问题

函数executeFunctionByName（函数名，上下文，超时/*，参数*/）{var args=Array.prototype.slice.call（参数，3）；var namespaces=functionName.split（“.”）；var func=命名空间.pop（）；for（var i=0；i<namespaces.length；i++）{context=context[namespaces[i]]；}var timeoutID=设置超时(function（）{context[func].apply（context，args）}，超时);return timeoutID；}var非常={_深度：{_定义：{_函数：函数（num1，num2）{console.log（“Execution_very_deeply _defined_function:”，num1，num2）；}}}}console.log（'现在等待'）executeFunctionByName（“_very.deeply.defined._function”，窗口，2000，40，50）；