如何检查JavaScript中是否存在函数？

function js_to_as( str ){
if (me && me.onChange)
me.onChange(str);
}

试试这样的东西：

if (typeof me.onChange !== "undefined") {
// safe to use the function
}

或者更好（根据UpTheCreek的评论）

if (typeof me.onChange === "function") {
// safe to use the function
}

没有任何条件

me.onChange=function(){};


function getID( swfID ){
if(navigator.appName.indexOf("Microsoft") != -1){
me = window[swfID];
}else{
me = document[swfID];
}
}


function js_to_as( str ){
me.onChange(str);
}

我怀疑me没有在负载上正确分配。

将get_ID调用移动到onClick事件中应该可以处理它。

显然，您可以进一步陷阱如前所述：

function js_to_as( str) {
var me = get_ID('jsExample');
if (me && me.onChange) {
me.onChange(str);
}
}

我将进一步确定属性确实是一个函数

function js_to_as( str ){
if (me && me.onChange && typeof me.onChange === 'function') {
me.onChange(str);
}
}

如果您使用ava将字符串转换为函数，并且您想检查是否存在此ava方法，您需要在val中使用typeof和您的函数字符串：

var functionString = "nonexsitantFunction"
eval("typeof " + functionString) // returns "undefined" or "function"

不要反转并在val上尝试typeof。如果你这样做，将抛出引用错误：

var functionString = "nonexsitantFunction"
typeof(eval(functionString)) // returns ReferenceError: [function] is not defined

如果obj恰好是undefined，if (obj && typeof obj === 'function') { ... }会不断抛出引用错误，所以最后我做了以下操作：

if (typeof obj !== 'undefined' && typeof obj === 'function') { ... }

然而，一位同事向我指出，检查它是否是!== 'undefined'然后=== 'function'是多余的，因此：

更简单：

if (typeof obj === 'function') { ... }

更干净，工作很棒。

尝试typeof--查找'undefined'表示它不存在，'function'表示函数。此代码的JSFiddle

function thisishere() {
return false;
}
alert("thisishere() is a " + typeof thisishere);
alert("thisisnthere() is " + typeof thisisnthere);

或者作为一个if：

if (typeof thisishere === 'function') {
// function exists
}

或者使用返回值，在单行上：

var exists = (typeof thisishere === 'function') ? "Value if true" : "Value if false";
var exists = (typeof thisishere === 'function') // Returns true or false

我总是这样检查：

if(!myFunction){return false;}

只需将其放在使用此函数的任何代码之前

不如：

if('functionName' in Obj){
//code
}

e. g.

var color1 = new String("green");
"length" in color1 // returns true
"indexOf" in color1 // returns true
"blablabla" in color1 // returns false

至于你的情况：

if('onChange' in me){
//code
}

见MDN文档。

//Simple function that will tell if the function is defined or not
function is_function(func) {
return typeof window[func] !== 'undefined' && $.isFunction(window[func]);
}


//usage


if (is_function("myFunction") {
alert("myFunction defined");
} else {
alert("myFunction not defined");
}

我喜欢使用这种方法：

function isFunction(functionToCheck) {
var getType = {};
return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
}

用法：

if ( isFunction(me.onChange) ) {
me.onChange(str); // call the function with params
}

没有看到这个建议： me.on&&me.on更改（str）；

基本上，如果me.onChange是未定义的（如果它尚未启动，它将是未定义的），那么它将不会执行后一部分。如果me.onChange是一个函数，它将执行me.onChange（str）。

你甚至可以更进一步，做：

me && me.onChange && me.onChange(str);

以防我也是异步的。

Underscore.js库在isFunction方法中将其定义为this（注释建议可能会迎合一些浏览器错误）

typeof obj == 'function' || false

我遇到了函数名称根据添加到函数名称的变量（在本例中为var'x'）而变化的情况。这工作：

if ( typeof window['afunction_'+x] === 'function' ) { window['afunction_'+x](); }

这个简单的jQuery代码应该可以做到：

if (jQuery.isFunction(functionName)) {
functionName();
}

如果你正在检查一个jQuery插件的函数，你需要使用$.fn.myfunction

if (typeof $.fn.mask === 'function') {
$('.zip').mask('00000');
}

我已经尝试了接受的答案；然而：

console.log(typeof me.onChange);

返回“未定义”。 我注意到规范声明了一个名为“onChange”而不是“onChange”的事件（注意camelCase）。

将最初接受的答案更改为以下内容对我有用：

if (typeof me.onchange === "function") {
// safe to use the function
}

    function sum(nb1,nb2){


return nb1+nb2;
}


try{


if(sum() != undefined){/*test if the function is defined before call it*/


sum(3,5);               /*once the function is exist you can call it */


}


}catch(e){


console.log("function not defined");/*the function is not defined or does not exists*/
}

然后还有这个…

( document.exitPointerLock || Function )();

这是一个工作和简单的解决方案，用于检查另一个函数的函数的存在性和动态触发该功能；

触发功能

function runDynamicFunction(functionname){


if (typeof window[functionname] == "function") { //check availability


window[functionname]("this is from the function it"); // run function and pass a parameter to it
}
}

您现在可以动态生成函数，可能使用像这样的php

function runThis_func(my_Parameter){


alert(my_Parameter +" triggerd");
}

现在您可以使用动态生成的事件调用函数

<?php


$name_frm_somware ="runThis_func";


echo "<input type='button' value='Button' onclick='runDynamicFunction(\"".$name_frm_somware."\");'>";


?>

您需要的超文本标记语言代码是

<input type="button" value="Button" onclick="runDynamicFunction('runThis_func');">

试试这个：

Window.function_exists=function(function_name,scope){
//Setting default scope of none is provided
If(typeof scope === 'undefined') scope=window;
//Checking if function name is defined
If (typeof function_name === 'undefined') throw new
Error('You have to provide an valid function name!');
//The type container
var fn= (typeof scope[function_name]);
//Function type
If(fn === 'function') return true;
//Function object type
if(fn.indexOf('function')!== false) return true;
return false;
}

请注意，这是我用手机写的 可能包含一些大写问题和/或其他需要的更正，例如函数name

如果您希望使用PHP之类的函数来检查是否设置了var：

Window.isset=function (variable_con){
If(typeof variable_con !== 'undefined') return true;
return false;
}

为了说明前面的答案，这里有一个快速的JSFiddle片段：

function test () {
console.log()


}


console.log(typeof test) // >> "function"


// implicit test, in javascript if an entity exist it returns implcitly true unless the element value is false as :
// var test = false
if(test){ console.log(true)}
else{console.log(false)}


// test by the typeof method
if( typeof test === "function"){ console.log(true)}
else{console.log(false)}




// confirm that the test is effective :
// - entity with false value
var test2 = false
if(test2){ console.log(true)}
else{console.log(false)}


// confirm that the test is effective :
// - typeof entity
if( typeof test ==="foo"){ console.log(true)}
else{console.log(false)}


/* Expected :
function
true
true
false
false
*/

最简单的方法：

function func_exists(fname)
{
return (typeof window[fname] === 'function');
}

function function_exists(function_name)
{
return eval('typeof ' + function_name) === 'function';
}
alert(function_exists('test'));
alert(function_exists('function_exists'));

或

function function_exists(func_name) {
//  discuss at: http://phpjs.org/functions/function_exists/
// original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
// improved by: Steve Clay
// improved by: Legaev Andrey
// improved by: Brett Zamir (http://brett-zamir.me)
//   example 1: function_exists('isFinite');
//   returns 1: true


if (typeof func_name === 'string') {
func_name = this.window[func_name];
}
return typeof func_name === 'function';
}

在要检查的函数名之前加上双感叹号，即！！。如果存在，它将返回true。

function abc(){
}
!!window.abc; // return true
!!window.abcd; // return false

我也一直在寻找一个优雅的方法来解决这个问题。经过深思熟虑，我发现这是最好的方法。

const func=me.onChange||（str=>{}）； func（str）；

一句话：抓住例外。

我真的很惊讶没有人在这篇文章中回答或评论异常捕获。

详细信息：这里有一个例子，我尝试匹配一个前缀为mask_后缀为表单字段“name”的函数。当JavaScript找不到该函数时，它应该抛出一个引用错误，您可以在catch部分随意处理。

function inputMask(input) {
try {
let maskedInput = eval("mask_"+input.name);


if(typeof maskedInput === "undefined")
return input.value;
else
return eval("mask_"+input.name)(input);


} catch(e) {
if (e instanceof ReferenceError) {
return input.value;
}
}
}

// just pass your tested function name instead of myFunctionName
if ( $.isFunction($.fn.myFunctionName) ) {
console.log( 'write your code here.' );
}

这将验证该函数是否存在，如果存在，它将被执行

me.onChange && me.onChange(str);

因此错误TypeError: me.onChange is not a function是防止的。

现代JavaScript来救援！

me.onChange?.(str)

可选链接语法（?.）解决了这个问题

• 在javascript自ES2020
• 在打字稿自版本3.7

在上面的示例中，如果me.onChange属性存在并且是一个函数，则调用它。

如果不存在me.onChange属性，则什么都不会发生：表达式只返回undefined。

注意-如果me.onChange属性存在但没有是一个函数，那么TypeError将被抛出，就像您在JavaScript中将任何非函数调用为函数一样。可选链接不会做任何魔法来消除这种情况。

我建议使用：

function hasMethod(subject, methodName) {
return subject != null && typeof subject[methodName] == "function";
}

第一个检查subject != null过滤掉没有任何属性的空值（null和undefined）。没有这个检查subject[methodName]可能会抛出错误：

TypeError：（未定义|null）没有属性

仅检查truthy值是不够的，因为0和""都是假的，但确实有属性。

在验证subject不是null后，您可以安全地访问该属性并检查它是否与typeof subject[methodName] == "function"匹配。

将此应用于您的代码，您现在可以执行：

if (hasMethod(me, "onChange")) {
me.onChange(str);
}

function isFunction( o ) { return null !== o && "function" === typeof o && !!o.apply; }

我更喜欢使用lodash库，如下所示（看起来更干净）：

if (_.has(me, "onChange")) {
// your desired code here
}


// or generic one like


if (_.has(this, "some property or function name")) {
// your desired code here
}