Checks if any value is the type from a given type of the generic type Types.

const isType = <T extends Type, Payload extends object = object>(
  value: any,
  type: Types<T>,
  callback: ResultCallback<any, Payload> = resultCallback,
  payload?: Payload
): value is T =>
    ? {
        bigint: isBigInt,
        boolean: isBooleanType,
        function: isFunction,
        number: isNumberType,
        object: isObject,
        null: isNull,
        string: isStringType,
        symbol: isSymbol,
        undefined: isUndefined,
      }[type as Primitives](value, callback, payload)
    : isNotNull(type)
    ? isInstance(value, type, callback, payload)
    : false;

Generic type variables


A generic type variable T constrained by the generic type Type indicates the type of value parameter via the return type value is T and captured type of the generic type Constructor of the supplied type.


The Payload generic type variable constrained by object indicates the type of optional parameter payload of the supplied callback function and payload optional parameter of the isType() function from which it captures its value.


value: any

The value of any type to check against the type of given type.

type: Types<T>

A value of the generic type Types indicates against which type the provided value is checked.

callback: ResultCallback<any, Payload>

A callback function of ResultCallback type with parameters, the value that has been checked, the result of this check, and payload of generic type variable Payload with optional properties from the provided payload, to handle them before the result return. By default, it uses resultCallback() function.

payload?: Payload

An optional object of the generic type variable Payload is assigned to the payload of the given callback function.

Return type

value is T

The return type is a boolean as the result of its statement indicating the value is a generic type variable T by default equal to the Type but captured type class of the supplied type changes it to the class name.


The return value is a boolean indicating whether the provided value is a type from a given type of the Types.

Example usage

// Example usage.
import { isType } from '@angular-package/type';

class Person {}
const person = new Person();

// Primitives.
isType<bigint>(1n, 'bigint'); // Returns `true` as `value is bigint`
isType<boolean>(false, 'boolean'), // Returns `true` as `value is boolean`
isType<number>(27, 'number'); // Returns `true` as `value is number`
isType<null>(null, 'null'); // Returns `true` as `value is null`
isType<string>('age', 'string'); // Returns `true` as `value is string`
isType<symbol>(Symbol(27), 'symbol'); // Returns `true` as `value is symbol`
isType<undefined>(undefined, 'undefined'); // Returns `true` as `value is undefined`
// Function.
isType<Function>(() => {}, 'function'); // Returns `true` as `value is function`
// Object.
isType<object>({}, 'object'); // Returns `true` as `value is object`
// Class.
isType(person, Person); // Returns `true` as `value is Person`
// Class with callback and payload.
isType(person, Person, (result, value, payload) => {
  value // Person {}
  payload {
    value: {},
    id: 15,
    database: 'Persons'
  return result;
}, { id: 15, database: 'Persons' }); // Returns `true` as `value is Person`

Last updated