PHP's call_user_func_array in TypeScript

How to use

Install via yarn add locutus and import: import { call_user_func_array } from 'locutus/php/funchand/call_user_func_array'.

Or with CommonJS: const { call_user_func_array } = require('locutus/php/funchand/call_user_func_array')

Use a bundler that supports tree-shaking so you only ship the functions you actually use. Vite, webpack, Rollup, and Parcel all handle this. For server-side use this is less of a concern.

Examples

These examples are extracted from test cases that automatically verify our functions against their native counterparts.

#	code	expected result
1	call_user_func_array('isNaN', ['a'])	true
2	call_user_func_array('isNaN', [1])	false

Notes

• Callback resolution intentionally avoids eval/new Function for security.

Dependencies

This function uses the following Locutus functions:

• _callbackResolver (php/_helpers)
• _phpRuntimeState (php/_helpers)
• _phpTypes (php/_helpers)

Here's what our current TypeScript equivalent to PHP's call_user_func_array looks like.

TSTypeScript JSJavaScript TSStandalone TS JSStandalone JS

Copy code

import { resolvePhpCallable } from '../_helpers/_callbackResolver.ts'
import { getPhpGlobalEntry, getPhpObjectEntry } from '../_helpers/_phpRuntimeState.ts'
import {
  isObjectLike,
  isPhpCallable,
  type PhpCallable,
  type PhpCallableArgs,
  type PhpCallableDescriptor,
  type PhpRuntimeValue,
} from '../_helpers/_phpTypes.ts'

type FunctionValue = PhpRuntimeValue
type FunctionScope = FunctionValue | object

export function call_user_func_array<TResult = FunctionValue, TArgs extends PhpCallableArgs = PhpCallableArgs>(
  cb: PhpCallableDescriptor<TArgs, TResult>,
  parameters: [...TArgs],
): TResult {
  //  discuss at: https://locutus.io/php/call_user_func_array/
  // original by: Thiago Mata (https://thiagomata.blog.com)
  //  revised by: Jon Hohle
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Diplom@t (https://difane.com/)
  // improved by: Brett Zamir (https://brett-zamir.me)
  //      note 1: Callback resolution intentionally avoids eval/new Function for security.
  //   example 1: call_user_func_array('isNaN', ['a'])
  //   returns 1: true
  //   example 2: call_user_func_array('isNaN', [1])
  //   returns 2: false

  let func: PhpCallable<TArgs, TResult> | undefined
  let scope: FunctionScope = null

  try {
    const resolved = resolvePhpCallable<TArgs, TResult>(cb, { invalidMessage: 'invalid' })
    func = resolved.fn
    scope = resolved.scope
  } catch {
    // Fall back to legacy-compatible callback resolution paths below.
  }

  if (!func && typeof cb === 'string') {
    const globalCandidate = getPhpGlobalEntry(cb)
    if (isPhpCallable<TArgs, TResult>(globalCandidate)) {
      func = globalCandidate
    }
  } else if (!func && Array.isArray(cb)) {
    if (typeof cb[0] === 'string') {
      const globalScope = getPhpGlobalEntry(cb[0])
      if (isObjectLike(globalScope) || typeof globalScope === 'function') {
        const method = getPhpObjectEntry(globalScope, String(cb[1]))
        if (isPhpCallable<TArgs, TResult>(method)) {
          func = method
        }
        scope = globalScope
      }
    } else if (isObjectLike(cb[0]) || typeof cb[0] === 'function') {
      const method = getPhpObjectEntry(cb[0], String(cb[1]))
      if (isPhpCallable<TArgs, TResult>(method)) {
        func = method
      }
      scope = cb[0]
    }
  } else if (!func && isPhpCallable<TArgs, TResult>(cb)) {
    func = cb
  }

  if (!func) {
    throw new Error(String(cb) + ' is not a valid function')
  }

  return func.apply(scope, parameters)
}

import { resolvePhpCallable } from '../_helpers/_callbackResolver.ts'
import { getPhpGlobalEntry, getPhpObjectEntry } from '../_helpers/_phpRuntimeState.ts'
import { isObjectLike, isPhpCallable } from '../_helpers/_phpTypes.ts'

export function call_user_func_array(cb, parameters) {
  //  discuss at: https://locutus.io/php/call_user_func_array/
  // original by: Thiago Mata (https://thiagomata.blog.com)
  //  revised by: Jon Hohle
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Diplom@t (https://difane.com/)
  // improved by: Brett Zamir (https://brett-zamir.me)
  //      note 1: Callback resolution intentionally avoids eval/new Function for security.
  //   example 1: call_user_func_array('isNaN', ['a'])
  //   returns 1: true
  //   example 2: call_user_func_array('isNaN', [1])
  //   returns 2: false

  let func
  let scope = null

  try {
    const resolved = resolvePhpCallable(cb, { invalidMessage: 'invalid' })
    func = resolved.fn
    scope = resolved.scope
  } catch {
    // Fall back to legacy-compatible callback resolution paths below.
  }

  if (!func && typeof cb === 'string') {
    const globalCandidate = getPhpGlobalEntry(cb)
    if (isPhpCallable(globalCandidate)) {
      func = globalCandidate
    }
  } else if (!func && Array.isArray(cb)) {
    if (typeof cb[0] === 'string') {
      const globalScope = getPhpGlobalEntry(cb[0])
      if (isObjectLike(globalScope) || typeof globalScope === 'function') {
        const method = getPhpObjectEntry(globalScope, String(cb[1]))
        if (isPhpCallable(method)) {
          func = method
        }
        scope = globalScope
      }
    } else if (isObjectLike(cb[0]) || typeof cb[0] === 'function') {
      const method = getPhpObjectEntry(cb[0], String(cb[1]))
      if (isPhpCallable(method)) {
        func = method
      }
      scope = cb[0]
    }
  } else if (!func && isPhpCallable(cb)) {
    func = cb
  }

  if (!func) {
    throw new Error(String(cb) + ' is not a valid function')
  }

  return func.apply(scope, parameters)
}

// php/_helpers/_phpTypes (Locutus helper dependency)
type PhpNullish = null | undefined

type PhpInput = {} | PhpNullish

type PhpScalar = string | number | boolean

type PhpPrimitive = PhpScalar | bigint

type PhpList<T = PhpInput> = T[]

type PhpAssoc<T = PhpInput> = { [key: string]: T }

type PhpArrayLike<T = PhpInput> = PhpList<T> | PhpAssoc<T>

type PhpFunctionValue = (...args: PhpInput[]) => PhpInput

interface PhpRuntimeAssoc {
  [key: string]: PhpRuntimeValue
}

interface PhpRuntimeList extends Array<PhpRuntimeValue> {}

type PhpRuntimeValue = PhpPrimitive | PhpNullish | PhpRuntimeList | PhpRuntimeAssoc | PhpFunctionValue

type PhpCallableArgs = PhpInput[]

type PhpCallable<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput> = (
  ...args: TArgs
) => TResult

type PhpCallableScope = PhpInput

type PhpCallableTuple<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput> = readonly [
  PhpCallableScope,
  string | PhpCallable<TArgs, TResult>,
]

type PhpCallableDescriptor<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput> =
  | string
  | PhpCallable<TArgs, TResult>
  | PhpCallableTuple<TArgs, TResult>

function isObjectLike(value: PhpInput): value is PhpArrayLike<PhpInput> {
  return typeof value === 'object' && value !== null
}

function isPhpCallable<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput>(
  value: PhpInput,
): value is PhpCallable<TArgs, TResult> {
  return typeof value === 'function'
}

// php/_helpers/_phpRuntimeState (Locutus helper dependency)
interface LocutusRuntimeContainer {
  php?: PhpAssoc<PhpInput>
}

interface PhpGlobalProcessLike {
  env?: PhpAssoc<string | undefined>
}

interface PhpGlobalBufferLike {
  from?: (...args: PhpInput[]) => PhpInput
}

interface PhpGlobalKnownEntryMap {
  process: PhpGlobalProcessLike
  Buffer: PhpGlobalBufferLike
}

type GlobalWithLocutus = {
  $locutus?: LocutusRuntimeContainer
  [key: string]: PhpInput
}

const globalContext: GlobalWithLocutus =
  typeof window === 'object' && window !== null ? window : typeof global === 'object' && global !== null ? global : {}

function getPhpGlobalEntry<TKey extends keyof PhpGlobalKnownEntryMap>(
  key: TKey,
): PhpGlobalKnownEntryMap[TKey] | undefined

function getPhpGlobalEntry(key: string): PhpInput | undefined

function getPhpGlobalEntry(key: string): PhpInput | undefined {
  const value = globalContext[key]
  return typeof value === 'undefined' ? undefined : value
}

function getPhpObjectEntry(value: PhpInput, key: string): PhpInput | undefined {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return undefined
  }

  let current: object | null = value
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.get === 'function') {
        const getterValue = descriptor.get.call(value)
        return typeof getterValue === 'undefined' ? undefined : getterValue
      }
      const directValue = descriptor.value
      return typeof directValue === 'undefined' ? undefined : directValue
    }
    current = Object.getPrototypeOf(current)
  }

  return undefined
}

// php/_helpers/_callbackResolver (Locutus helper dependency)
type CallbackValue = PhpInput

interface CallbackResolverOptions {
  invalidMessage: string
  missingScopeMessage?: (scopeName: string) => string
}

interface ResolvedCallback<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = CallbackValue> {
  fn: PhpCallable<TArgs, TResult>
  scope: CallbackValue
}

function resolvePhpCallable<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = CallbackValue>(
  callback: PhpCallableDescriptor<TArgs, TResult>,
  options: CallbackResolverOptions,
): ResolvedCallback<TArgs, TResult> {
  if (isPhpCallable<TArgs, TResult>(callback)) {
    return { fn: callback, scope: null }
  }

  if (typeof callback === 'string') {
    const candidate = getPhpGlobalEntry(callback)
    if (isPhpCallable<TArgs, TResult>(candidate)) {
      return { fn: candidate, scope: null }
    }
    throw new Error(options.invalidMessage)
  }

  if (Array.isArray(callback) && callback.length >= 2) {
    const scopeDescriptor = callback[0]
    const callableDescriptor = callback[1]

    let scope: CallbackValue
    if (typeof scopeDescriptor === 'string') {
      scope = getPhpGlobalEntry(scopeDescriptor)
      if (typeof scope === 'undefined' && options.missingScopeMessage) {
        throw new Error(options.missingScopeMessage(scopeDescriptor))
      }
    } else {
      scope = scopeDescriptor
    }

    if (isPhpCallable<TArgs, TResult>(callableDescriptor)) {
      return { fn: callableDescriptor, scope }
    }

    if (typeof callableDescriptor === 'string' && (isObjectLike(scope) || typeof scope === 'function')) {
      const candidate = getPhpObjectEntry(scope, callableDescriptor)
      if (isPhpCallable<TArgs, TResult>(candidate)) {
        return { fn: candidate, scope }
      }
    }
  }

  throw new Error(options.invalidMessage)
}

// php/funchand/call_user_func_array (target function module)
type FunctionValue = PhpRuntimeValue

type FunctionScope = FunctionValue | object

function call_user_func_array<TResult = FunctionValue, TArgs extends PhpCallableArgs = PhpCallableArgs>(
  cb: PhpCallableDescriptor<TArgs, TResult>,
  parameters: [...TArgs],
): TResult {
  //  discuss at: https://locutus.io/php/call_user_func_array/
  // original by: Thiago Mata (https://thiagomata.blog.com)
  //  revised by: Jon Hohle
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Diplom@t (https://difane.com/)
  // improved by: Brett Zamir (https://brett-zamir.me)
  //      note 1: Callback resolution intentionally avoids eval/new Function for security.
  //   example 1: call_user_func_array('isNaN', ['a'])
  //   returns 1: true
  //   example 2: call_user_func_array('isNaN', [1])
  //   returns 2: false

  let func: PhpCallable<TArgs, TResult> | undefined
  let scope: FunctionScope = null

  try {
    const resolved = resolvePhpCallable<TArgs, TResult>(cb, { invalidMessage: 'invalid' })
    func = resolved.fn
    scope = resolved.scope
  } catch {
    // Fall back to legacy-compatible callback resolution paths below.
  }

  if (!func && typeof cb === 'string') {
    const globalCandidate = getPhpGlobalEntry(cb)
    if (isPhpCallable<TArgs, TResult>(globalCandidate)) {
      func = globalCandidate
    }
  } else if (!func && Array.isArray(cb)) {
    if (typeof cb[0] === 'string') {
      const globalScope = getPhpGlobalEntry(cb[0])
      if (isObjectLike(globalScope) || typeof globalScope === 'function') {
        const method = getPhpObjectEntry(globalScope, String(cb[1]))
        if (isPhpCallable<TArgs, TResult>(method)) {
          func = method
        }
        scope = globalScope
      }
    } else if (isObjectLike(cb[0]) || typeof cb[0] === 'function') {
      const method = getPhpObjectEntry(cb[0], String(cb[1]))
      if (isPhpCallable<TArgs, TResult>(method)) {
        func = method
      }
      scope = cb[0]
    }
  } else if (!func && isPhpCallable<TArgs, TResult>(cb)) {
    func = cb
  }

  if (!func) {
    throw new Error(String(cb) + ' is not a valid function')
  }

  return func.apply(scope, parameters)
}

// php/_helpers/_phpTypes (Locutus helper dependency)
function isObjectLike(value) {
  return typeof value === 'object' && value !== null
}

function isPhpCallable(value) {
  return typeof value === 'function'
}

// php/_helpers/_phpRuntimeState (Locutus helper dependency)
const globalContext =
  typeof window === 'object' && window !== null ? window : typeof global === 'object' && global !== null ? global : {}

function getPhpGlobalEntry(key) {
  const value = globalContext[key]
  return typeof value === 'undefined' ? undefined : value
}

function getPhpObjectEntry(value, key) {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return undefined
  }

  let current = value
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.get === 'function') {
        const getterValue = descriptor.get.call(value)
        return typeof getterValue === 'undefined' ? undefined : getterValue
      }
      const directValue = descriptor.value
      return typeof directValue === 'undefined' ? undefined : directValue
    }
    current = Object.getPrototypeOf(current)
  }

  return undefined
}

// php/_helpers/_callbackResolver (Locutus helper dependency)
function resolvePhpCallable(callback, options) {
  if (isPhpCallable(callback)) {
    return { fn: callback, scope: null }
  }

  if (typeof callback === 'string') {
    const candidate = getPhpGlobalEntry(callback)
    if (isPhpCallable(candidate)) {
      return { fn: candidate, scope: null }
    }
    throw new Error(options.invalidMessage)
  }

  if (Array.isArray(callback) && callback.length >= 2) {
    const scopeDescriptor = callback[0]
    const callableDescriptor = callback[1]

    let scope
    if (typeof scopeDescriptor === 'string') {
      scope = getPhpGlobalEntry(scopeDescriptor)
      if (typeof scope === 'undefined' && options.missingScopeMessage) {
        throw new Error(options.missingScopeMessage(scopeDescriptor))
      }
    } else {
      scope = scopeDescriptor
    }

    if (isPhpCallable(callableDescriptor)) {
      return { fn: callableDescriptor, scope }
    }

    if (typeof callableDescriptor === 'string' && (isObjectLike(scope) || typeof scope === 'function')) {
      const candidate = getPhpObjectEntry(scope, callableDescriptor)
      if (isPhpCallable(candidate)) {
        return { fn: candidate, scope }
      }
    }
  }

  throw new Error(options.invalidMessage)
}

// php/funchand/call_user_func_array (target function module)
function call_user_func_array(cb, parameters) {
  //  discuss at: https://locutus.io/php/call_user_func_array/
  // original by: Thiago Mata (https://thiagomata.blog.com)
  //  revised by: Jon Hohle
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Diplom@t (https://difane.com/)
  // improved by: Brett Zamir (https://brett-zamir.me)
  //      note 1: Callback resolution intentionally avoids eval/new Function for security.
  //   example 1: call_user_func_array('isNaN', ['a'])
  //   returns 1: true
  //   example 2: call_user_func_array('isNaN', [1])
  //   returns 2: false

  let func
  let scope = null

  try {
    const resolved = resolvePhpCallable(cb, { invalidMessage: 'invalid' })
    func = resolved.fn
    scope = resolved.scope
  } catch {
    // Fall back to legacy-compatible callback resolution paths below.
  }

  if (!func && typeof cb === 'string') {
    const globalCandidate = getPhpGlobalEntry(cb)
    if (isPhpCallable(globalCandidate)) {
      func = globalCandidate
    }
  } else if (!func && Array.isArray(cb)) {
    if (typeof cb[0] === 'string') {
      const globalScope = getPhpGlobalEntry(cb[0])
      if (isObjectLike(globalScope) || typeof globalScope === 'function') {
        const method = getPhpObjectEntry(globalScope, String(cb[1]))
        if (isPhpCallable(method)) {
          func = method
        }
        scope = globalScope
      }
    } else if (isObjectLike(cb[0]) || typeof cb[0] === 'function') {
      const method = getPhpObjectEntry(cb[0], String(cb[1]))
      if (isPhpCallable(method)) {
        func = method
      }
      scope = cb[0]
    }
  } else if (!func && isPhpCallable(cb)) {
    func = cb
  }

  if (!func) {
    throw new Error(String(cb) + ' is not a valid function')
  }

  return func.apply(scope, parameters)
}

Improve this function

Locutus is a community effort following The McDonald's Theory: we ship first iterations, hoping others will improve them. If you see something that could be better, we'd love your contribution.

View on GitHub · Edit on GitHub · View Raw

---

« More PHP funchand functions

Star