isFunction

Determines whether a value is a function with enhanced type safety. Provides reliable function detection with generic type support for type-safe function validation and processing. Detects all function types including regular functions, arrow functions, async functions, generators, and class constructors.

Signature

const isFunction: <T extends Fn<any[], any>>(value: unknown) => value is T

Parameters

Name	Type	Description
value	-	Value to test for function type

Returns

Type-safe boolean indicating whether the value is a function

Examples

Function type detection

import { isFunction } from '@winglet/common-utils';

const regularFunc = function() { return 'hello'; };
const arrowFunc = () => 'world';
const asyncFunc = async () => 'async';
const generatorFunc = function* () { yield 1; };
const classConstructor = class MyClass {};
const namedFunction = function namedFn() {};

console.log(isFunction(regularFunc)); // true
console.log(isFunction(arrowFunc)); // true
console.log(isFunction(asyncFunc)); // true
console.log(isFunction(generatorFunc)); // true
console.log(isFunction(classConstructor)); // true
console.log(isFunction(namedFunction)); // true

// Non-functions return false
console.log(isFunction('string')); // false
console.log(isFunction({})); // false
console.log(isFunction([])); // false
console.log(isFunction(1)); // false
console.log(isFunction(null)); // false
console.log(isFunction(undefined)); // false

Callback validation

function processWithCallback<T>(data: T[], callback?: unknown) {
  if (isFunction(callback)) {
    // TypeScript knows callback is a function
    return data.map(item => callback(item));
  }
  return data;
}

// Usage
const numbers = [1, 2, 3];
const result = processWithCallback(numbers, (x: number) => x * 2);
console.log(result); // [2, 4, 6]

Event handler validation

interface EventOptions {
  onSuccess?: unknown;
  onError?: unknown;
}

function setupEventHandlers(options: EventOptions) {
  if (isFunction(options.onSuccess)) {
    document.addEventListener('success', options.onSuccess);
  }

  if (isFunction(options.onError)) {
    document.addEventListener('error', options.onError);
  }
}

Higher-order function utilities

function createMiddleware(middleware: unknown) {
  if (!isFunction(middleware)) {
    throw new Error('Middleware must be a function');
  }

  return (req: any, res: any, next: Function) => {
    // TypeScript knows middleware is callable
    return middleware(req, res, next);
  };
}

Dynamic function invocation

function safeInvoke(fn: unknown, ...args: any[]) {
  if (isFunction(fn)) {
    try {
      return fn(...args);
    } catch (error) {
      console.error('Function execution failed:', error);
      return null;
    }
  }
  console.warn('Attempted to invoke non-function:', typeof fn);
  return null;
}

Playground

import { isFunction } from '@winglet/common-utils';

const regularFunc = function() { return 'hello'; };
const arrowFunc = () => 'world';
const asyncFunc = async () => 'async';
const generatorFunc = function* () { yield 1; };
const classConstructor = class MyClass {};
const namedFunction = function namedFn() {};

console.log(isFunction(regularFunc)); // true
console.log(isFunction(arrowFunc)); // true
console.log(isFunction(asyncFunc)); // true
console.log(isFunction(generatorFunc)); // true
console.log(isFunction(classConstructor)); // true
console.log(isFunction(namedFunction)); // true

// Non-functions return false
console.log(isFunction('string')); // false
console.log(isFunction({})); // false
console.log(isFunction([])); // false
console.log(isFunction(1)); // false
console.log(isFunction(null)); // false
console.log(isFunction(undefined)); // false

Notes

Function Types Detected:

• Regular functions (function() {})
• Arrow functions (() => {})
• Async functions (async function() {})
• Generator functions (function*() {})
• Class constructors (class MyClass {})
• Built-in functions (console.log, Array.isArray, etc.)

Use Cases:

• Callback and event handler validation
• Higher-order function utilities
• Dynamic function invocation
• Plugin and middleware systems
• Type guards for function parameters

Performance: Direct typeof check provides optimal performance.