js怎么判断函数是否存在

判断javascript函数是否存在的最稳妥方法是使用typeof操作符；2. 若函数存在且为函数类型，typeof返回'function'，可安全调用，否则需提示不存在或类型错误；3. 检查对象方法时应先确认对象存在，再用typeof判断方法是否为函数，避免typeerror；4. 直接调用未定义或非函数的变量会抛出referenceerror或typeerror，导致程序中断；5. 在全局、对象、局部作用域中均可通过typeof判断函数存在性，核心逻辑一致；6. 其他方法如in操作符、hasownproperty、try-catch虽可行，但不如typeof简洁安全，不推荐作为首选。因此，typeof somevariable === 'function' 是最可靠且广泛采用的判断方式。

在JavaScript里，要判断一个函数是否存在，最直接、最稳妥的方法就是使用

typeof

typeof

'function'

undefined

null

typeof

'undefined'

解决方案

判断函数是否存在，核心就是利用

typeof

比如，你想知道一个叫

myFunction

if (typeof myFunction === 'function') {
  // 函数存在，可以安全调用
  myFunction();
} else {
  // 函数不存在或不是函数
  console.log('myFunction 不存在或不是一个函数。');
}

这同样适用于对象上的方法。假设你有一个对象

myObject

doSomething

const myObject = {
  // doSomething: function() { console.log('Doing something...'); }
};

if (myObject && typeof myObject.doSomething === 'function') {
  // myObject 存在且 doSomething 是一个函数
  myObject.doSomething();
} else {
  console.log('myObject.doSomething 不存在或不是一个函数。');
}

这里我特意加了个

myObject &&

myObject

null

undefined

TypeError

为什么直接调用可能会出错？

很多时候，新手或者急于求成的开发者可能会直接尝试调用一个函数，比如：

// 假设 myUndefinedFunction 并没有被定义
myUndefinedFunction(); // 这会直接报错！

当你直接调用一个未定义的函数时，JavaScript引擎会毫不留情地抛出一个

ReferenceError

myUndefinedFunction is not defined

更糟糕的情况是，如果一个变量存在，但它不是函数，你却尝试像函数一样调用它，比如：

const myVariable = "我不是函数";
myVariable(); // 这会抛出 TypeError！

这种情况下，你会得到一个

TypeError

myVariable is not a function

typeof

AITDK

免费AI SEO工具，SEO的AI生成器

下载

在不同作用域下如何判断函数存在？

判断函数存在与否，其实和它在哪个作用域里关系不大，核心的

typeof

全局作用域： 在浏览器环境中，全局函数通常是

window

typeof window.myGlobalFunction === 'function'

typeof myGlobalFunction === 'function'

window

// 定义一个全局函数
function globalFunc() {
  console.log('I am global.');
}

if (typeof globalFunc === 'function') {
  globalFunc();
}

// 或者更明确地指向 window (浏览器环境)
if (typeof window.globalFunc === 'function') {
  window.globalFunc();
}

在Node.js环境中，全局作用域略有不同，但直接使用

typeof globalFunc === 'function'

对象方法： 这是最常见的场景之一。一个函数作为对象的属性，我们称之为方法。判断它是否存在，就像前面提到的，需要先确保对象本身存在，再判断方法：

const user = {
  name: 'Alice',
  sayHello: function() {
    console.log(`Hello, ${this.name}!`);
  }
};

// 假设 user 对象可能不存在
const anotherUser = null;

if (user && typeof user.sayHello === 'function') {
  user.sayHello(); // 正常调用
}

if (anotherUser && typeof anotherUser.sayHello === 'function') {
  // 这段代码不会执行，因为 anotherUser 是 null
  anotherUser.sayHello();
} else {
  console.log('anotherUser 不存在，或者其 sayHello 方法不存在。');
}

局部作用域/闭包： 在一个函数内部定义的函数（或者通过闭包捕获的函数），判断方式和全局或对象方法并无二致。

typeof

function outerFunction() {
  function innerFunction() {
    console.log('I am inner.');
  }

  if (typeof innerFunction === 'function') {
    innerFunction(); // 在局部作用域内调用
  }
}

outerFunction();
// console.log(typeof innerFunction); // 这里会是 'undefined'，因为 innerFunction 在外部不可见

总的来说，无论函数藏在哪个角落，

typeof

除了

typeof

，还有其他判断方法吗？

当然有，但说实话，大部分情况下它们不如

typeof

1. 利用

   in

   操作符（针对对象属性）：

   in

   操作符可以检查一个属性是否存在于对象或其原型链上。如果函数是一个对象的方法，你可以用它来判断。

   const myModule = {
     init: function() { console.log('Module initialized.'); }
   };
   
   if ('init' in myModule) {
     // 属性存在，但还需要进一步判断它是不是函数
     if (typeof myModule.init === 'function') {
       myModule.init();
     }
   }

   仅仅用

   in

   是不够的，因为它只判断属性是否存在，不判断类型。一个属性可以是任何值，不一定是函数。所以，通常它会和

   typeof

   结合使用，或者说，

   typeof

   本身就足够了。在我看来，

   'init' in myModule && typeof myModule.init === 'function'

   这种写法，不如直接

   typeof myModule.init === 'function'

   简洁明了。后者如果

   myModule

   不存在会报错，所以前面加个

   myModule &&

   更稳妥。

2. hasOwnProperty

   方法（针对对象自有属性）： 这个方法可以判断一个属性是否是对象的“自有”属性，而不是从原型链继承来的。

   const proto = { inheritedFunc: function() {} };
   const obj = Object.create(proto);
   obj.ownFunc = function() {};
   
   if (obj.hasOwnProperty('ownFunc') && typeof obj.ownFunc === 'function') {
     obj.ownFunc();
   }
   
   if (obj.hasOwnProperty('inheritedFunc') && typeof obj.inheritedFunc === 'function') {
     // 不会执行，因为 inheritedFunc 是继承的
   } else {
     console.log('inheritedFunc 不是 obj 的自有属性。');
   }

   这在某些特定场景下有用，比如你需要区分是对象自身的方法还是继承的方法。但对于单纯判断“是否存在且可调用”而言，

   typeof

   依然是首选。

3. try-catch

   块： 理论上，你可以尝试调用一个函数，如果它不存在，就会抛出

   ReferenceError

   或

   TypeError

   ，然后你可以在

   catch

   块中捕获这个错误。

   try {
     maybeNonExistentFunction(); // 尝试调用
   } catch (e) {
     if (e instanceof ReferenceError || (e instanceof TypeError && e.message.includes('is not a function'))) {
       console.log('函数不存在或不可调用。', e.message);
     } else {
       // 其他类型的错误，需要重新抛出或处理
       throw e;
     }
   }

   说实话，这种方式我个人非常不推荐用来判断函数是否存在。

   try-catch

   块的开销相对较大，而且它主要是用来处理预料之外的异常情况，而不是用来做常规的流程控制判断。用它来判断函数存在，就像是为了确认门是不是锁着，非得撞一下门才能知道，而不是轻轻拧一下门把手。这显然不是最高效、最优雅的解决方案。

所以，兜兜转转一圈，你会发现，在绝大多数情况下，

typeof someVariable === 'function'