Standard Object Type Checking

/**
 * Returns true if val is array, it won't check items of array
 * @param val - Value to check
 * @returns Type guard indicating if value is array
 */
function isArray<T = any>(val?: unknown): val is Array<T>;

import { isArray } from "is-type-of";

isArray([1, 2, 3]);     // => true
isArray("hello");       // => false
isArray({length: 3});   // => false

// With type parameter
function processNumbers(value: unknown) {
  if (isArray<number>(value)) {
    // value is now typed as number[]
    value.forEach(n => console.log(n * 2));
  }
}

/**
 * Returns true if val is function
 * @param val - Value to check
 * @returns Type guard indicating if value is function
 */
function isFunction<T extends Function>(val?: unknown): val is T;

import { isFunction } from "is-type-of";

isFunction(() => {});           // => true
isFunction(function() {});      // => true
isFunction(Math.max);           // => true
isFunction("function");         // => false

/**
 * Returns true if val is generator function
 * @param val - Value to check
 * @returns Type guard indicating if value is generator function
 */
function isGeneratorFunction(val?: unknown): val is GeneratorFunction;

import { isGeneratorFunction } from "is-type-of";

function* generator() { yield 1; }

isGeneratorFunction(generator);     // => true
isGeneratorFunction(() => {});      // => false

/**
 * Returns true if val is async function
 * @param val - Value to check
 * @returns Type guard indicating if value is async function
 */
function isAsyncFunction(val?: unknown): val is Function;

import { isAsyncFunction } from "is-type-of";

async function asyncFn() { return 42; }

isAsyncFunction(asyncFn);       // => true
isAsyncFunction(() => {});      // => false

/**
 * Returns true if val is async generator function
 * @param val - Value to check
 * @returns Type guard indicating if value is async generator function
 */
function isAsyncGeneratorFunction(val?: unknown): val is AsyncGeneratorFunction;

import { isAsyncGeneratorFunction } from "is-type-of";

async function* asyncGenerator() { yield 1; }

isAsyncGeneratorFunction(asyncGenerator);  // => true
isAsyncGeneratorFunction(() => {});        // => false

/**
 * Returns true if val is object
 * @param val - Value to check
 * @returns Type guard indicating if value is object
 */
function isObject(val?: unknown): val is object;

import { isObject } from "is-type-of";

isObject({});           // => true
isObject([]);           // => true
isObject(null);         // => false
isObject("string");     // => false

/**
 * Returns true if val is class
 * Note: "class" is supported in ECMAScript 6, and if the code is using some compiler or transpiler, the checking might fail
 * @param val - Value to check
 * @returns Type guard indicating if value is class
 */
function isClass<T extends Class>(val?: unknown): val is T;

import { isClass } from "is-type-of";

class MyClass {}

isClass(MyClass);       // => true
isClass(() => {});      // => false

/**
 * Returns true if val is regular expression
 * @param val - Value to check
 * @returns Type guard indicating if value is RegExp
 */
function isRegExp(val?: unknown): val is RegExp;

import { isRegExp } from "is-type-of";

isRegExp(/pattern/);        // => true
isRegExp(new RegExp("pattern"));  // => true
isRegExp("pattern");        // => false

/**
 * Returns true if val is instance of Date
 * @param val - Value to check
 * @returns Type guard indicating if value is Date
 */
function isDate(val?: unknown): val is Date;

import { isDate } from "is-type-of";

isDate(new Date());         // => true
isDate("2023-01-01");       // => false
isDate(Date.now());         // => false

/**
 * Returns true if val is instance of Error
 * @param val - Value to check
 * @returns Type guard indicating if value is Error
 */
function isError(val?: unknown): val is Error;

import { isError } from "is-type-of";

isError(new Error("message"));      // => true
isError(new TypeError("message"));  // => true
isError("error message");           // => false

/**
 * Returns true if val is generator
 * @param val - Value to check
 * @returns Type guard indicating if value is Generator
 */
function isGenerator(val?: unknown): val is Generator;

import { isGenerator } from "is-type-of";

function* generatorFn() { yield 1; }
const gen = generatorFn();

isGenerator(gen);           // => true
isGenerator(generatorFn);   // => false

/**
 * Returns true if val is promise
 * @param val - Value to check
 * @returns Type guard indicating if value is Promise
 */
function isPromise<T = any>(val?: unknown): val is Promise<T>;

import { isPromise } from "is-type-of";

isPromise(Promise.resolve(42));     // => true
isPromise(new Promise(() => {}));   // => true
isPromise({then: () => {}});        // => false (use isPromiseLike for this)

/**
 * Returns true if val is like promise, if the object has then property, the checking will pass
 * @param val - Value to check
 * @returns Type guard indicating if value is PromiseLike
 */
function isPromiseLike<T = any>(val?: unknown): val is PromiseLike<T>;

import { isPromiseLike } from "is-type-of";

const thenable = {
  then: (onResolve: Function) => onResolve(42)
};

isPromiseLike(Promise.resolve(42));   // => true
isPromiseLike(thenable);              // => true
isPromiseLike({});                    // => false

type Class = new (...args: any[]) => any;