jQuery jQuery.isFunction() Method

What You’ll Learn

The jQuery.isFunction() utility returns true when a value is a callable JavaScript function. This tutorial covers syntax, five worked examples for callback validation, comparisons with typeof and $.type(), and safe patterns before invoking user-supplied handlers.

Introduction

jQuery plugins and event helpers often accept optional callbacks — a function to run when work completes, or a string selector when the argument is not callable. Before you invoke callback(), you must confirm the value really is a function.

jQuery provides jQuery.isFunction() (also written $.isFunction()) as a reliable boolean test. It returns true for function declarations, expressions, arrows, async functions, and methods — and false for strings, objects, arrays, and other types.

Understanding the jQuery.isFunction() Method

jQuery.isFunction(obj) is equivalent to jQuery.type(obj) === "function". jQuery inspects the internal class tag of the value and maps it to the familiar type name "function".

Use it anywhere a parameter might be a callback: plugin hooks, AJAX complete handlers, custom event emitters, and utility wrappers that mirror jQuery’s own overloaded arguments.

📝 Syntax

General form of jQuery.isFunction:

jQuery.isFunction( obj )
// or
$.isFunction( obj )

Parameters

• obj — any JavaScript value to test.

Return value

• true if obj is a function.
• false for all other types.

Minimal workflow

function runIfCallable(maybeFn) {
  if ($.isFunction(maybeFn)) {
    maybeFn();
  }
}

Examples Gallery

Each example uses $.isFunction(). Open DevTools or use the Try-it links to run them interactively.

console.log($.isFunction(function () {})); // true
console.log($.isFunction("text"));           // false

true
false

function notify(done, message) {
  if ($.isFunction(done)) {
    done(message);
  }
}

notify(function (msg) { console.log(msg); }, "Saved");
notify(null, "Ignored"); // no error

Saved
(no output for null callback)

var arrow = function (x) { return x * 2; };
var asyncFn = async function () { return 1; };

console.log($.isFunction(arrow));   // true
console.log($.isFunction(asyncFn)); // true

true
true

var fn = function () { return 42; };

console.log($.isFunction(fn));           // true
console.log(typeof fn === "function");   // true
console.log($.type(fn) === "function");  // true
console.log($.isFunction({ run: fn }));  // false — object, not function

true
true
true
false

function myPlugin(arg) {
  if ($.isFunction(arg)) {
    return arg();              // ready-style callback
  }
  return $(arg);               // assume selector string
}

console.log(typeof myPlugin(function () { return "cb"; }));
console.log(myPlugin("#app") instanceof jQuery);

string ("cb")
true (jQuery object when #app exists)

🚀 Common Use Cases

• Optional callbacks — invoke completion handlers only when provided.
• Plugin methods — accept function hooks in options objects.
• Event emitters — verify listener before .call() or .apply().
• Argument overloading — distinguish callback vs selector vs config object.
• AJAX helpers — validate success / error parameters.
• Legacy jQuery code — consistent function detection across old IE builds.

📝 Notes

• Available since jQuery 1.2.
• Equivalent to jQuery.type(obj) === "function".
• Does not treat objects with a call method as functions unless they are function objects.
• The jQuery factory $ itself is a function — $.isFunction(jQuery) is true.
• Safe on null and undefined — returns false, does not throw.
• Related: $.type(), $.isArray(), $.isPlainObject().

💡 Best Practices