DocsReferenceGuidesBlog
Discord logo
Discord
GitHub logo
Bun

Node.js module

util/types

The 'node:util/types' submodule provides type-checking utility functions for Node.js internal and user objects. It includes checks like isRegExp, isDate, isBuffer, and many others.

Use these functions to identify built-in object types accurately in userland code.

  • object: unknown
    ): object is ArrayBufferLike;

    Returns true if the value is a built-in ArrayBuffer or SharedArrayBuffer instance.

    See also util.types.isArrayBuffer() and util.types.isSharedArrayBuffer().

    util.types.isAnyArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer());  // Returns true
  • object: unknown
    ): object is IArguments;

    Returns true if the value is an arguments object.

    function foo() {
  util.types.isArgumentsObject(arguments);  // Returns true
}
  • function isArrayBuffer(
    object: unknown
    ): object is ArrayBuffer;

    Returns true if the value is a built-in ArrayBuffer instance. This does not include SharedArrayBuffer instances. Usually, it is desirable to test for both; See util.types.isAnyArrayBuffer() for that.

    util.types.isArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer());  // Returns false
  • object: unknown
    ): object is ArrayBufferView<ArrayBufferLike>;

    Returns true if the value is an instance of one of the ArrayBuffer views, such as typed array objects or DataView. Equivalent to ArrayBuffer.isView().

    util.types.isArrayBufferView(new Int8Array());  // true
util.types.isArrayBufferView(Buffer.from('hello world')); // true
util.types.isArrayBufferView(new DataView(new ArrayBuffer(16)));  // true
util.types.isArrayBufferView(new ArrayBuffer());  // false
  • function isAsyncFunction(
    object: unknown
    ): boolean;

    Returns true if the value is an async function. This only reports back what the JavaScript engine is seeing; in particular, the return value may not match the original source code if a transpilation tool was used.

    util.types.isAsyncFunction(function foo() {});  // Returns false
util.types.isAsyncFunction(async function foo() {});  // Returns true
  • function isBigInt64Array(
    value: unknown
    ): value is BigInt64Array<ArrayBufferLike>;

    Returns true if the value is a BigInt64Array instance.

    util.types.isBigInt64Array(new BigInt64Array());   // Returns true
util.types.isBigInt64Array(new BigUint64Array());  // Returns false
  • function isBigIntObject(
    object: unknown
    ): object is BigInt;

    Returns true if the value is a BigInt object, e.g. created by Object(BigInt(123)).

    util.types.isBigIntObject(Object(BigInt(123)));   // Returns true
util.types.isBigIntObject(BigInt(123));   // Returns false
util.types.isBigIntObject(123);  // Returns false
  • value: unknown
    ): value is BigUint64Array<ArrayBufferLike>;

    Returns true if the value is a BigUint64Array instance.

    util.types.isBigUint64Array(new BigInt64Array());   // Returns false
util.types.isBigUint64Array(new BigUint64Array());  // Returns true
  • function isBooleanObject(
    object: unknown
    ): object is Boolean;

    Returns true if the value is a boolean object, e.g. created by new Boolean().

    util.types.isBooleanObject(false);  // Returns false
util.types.isBooleanObject(true);   // Returns false
util.types.isBooleanObject(new Boolean(false)); // Returns true
util.types.isBooleanObject(new Boolean(true));  // Returns true
util.types.isBooleanObject(Boolean(false)); // Returns false
util.types.isBooleanObject(Boolean(true));  // Returns false
  • object: unknown
    ): object is String | Number | Boolean | Symbol | BigInt;

    Returns true if the value is any boxed primitive object, e.g. created by new Boolean(), new String() or Object(Symbol()).

    For example:

    util.types.isBoxedPrimitive(false); // Returns false
util.types.isBoxedPrimitive(new Boolean(false)); // Returns true
util.types.isBoxedPrimitive(Symbol('foo')); // Returns false
util.types.isBoxedPrimitive(Object(Symbol('foo'))); // Returns true
util.types.isBoxedPrimitive(Object(BigInt(5))); // Returns true
  • function isCryptoKey(
    object: unknown
    ): object is CryptoKey;

    Returns true if value is a CryptoKey, false otherwise.

  • function isDataView(
    object: unknown
    ): object is DataView<ArrayBufferLike>;

    Returns true if the value is a built-in DataView instance.

    const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab));  // Returns true
util.types.isDataView(new Float64Array());  // Returns false

    See also ArrayBuffer.isView().

  • function isDate(
    object: unknown
    ): object is Date;

    Returns true if the value is a built-in Date instance.

    util.types.isDate(new Date());  // Returns true
  • function isExternal(
    object: unknown
    ): boolean;

    Returns true if the value is a native External value.

    A native External value is a special type of object that contains a raw C++ pointer (void*) for access from native code, and has no other properties. Such objects are created either by Node.js internals or native addons. In JavaScript, they are frozen objects with a null prototype.

    #include <js_native_api.h>
#include <stdlib.h>
napi_value result;
static napi_value MyNapi(napi_env env, napi_callback_info info) {
  int* raw = (int*) malloc(1024);
  napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
  if (status != napi_ok) {
    napi_throw_error(env, NULL, "napi_create_external failed");
    return NULL;
  }
  return result;
}
...
DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
...

    import native from 'napi_addon.node';
import { types } from 'node:util';

const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false

    For further information on napi_create_external, refer to napi_create_external().

  • function isFloat32Array(
    object: unknown
    ): object is Float32Array<ArrayBufferLike>;

    Returns true if the value is a built-in Float32Array instance.

    util.types.isFloat32Array(new ArrayBuffer());  // Returns false
util.types.isFloat32Array(new Float32Array());  // Returns true
util.types.isFloat32Array(new Float64Array());  // Returns false
  • function isFloat64Array(
    object: unknown
    ): object is Float64Array<ArrayBufferLike>;

    Returns true if the value is a built-in Float64Array instance.

    util.types.isFloat64Array(new ArrayBuffer());  // Returns false
util.types.isFloat64Array(new Uint8Array());  // Returns false
util.types.isFloat64Array(new Float64Array());  // Returns true
  • object: unknown
    ): object is GeneratorFunction;

    Returns true if the value is a generator function. This only reports back what the JavaScript engine is seeing; in particular, the return value may not match the original source code if a transpilation tool was used.

    util.types.isGeneratorFunction(function foo() {});  // Returns false
util.types.isGeneratorFunction(function* foo() {});  // Returns true
  • object: unknown
    ): object is Generator<unknown, any, any>;

    Returns true if the value is a generator object as returned from a built-in generator function. This only reports back what the JavaScript engine is seeing; in particular, the return value may not match the original source code if a transpilation tool was used.

    function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator);  // Returns true
  • function isInt16Array(
    object: unknown
    ): object is Int16Array<ArrayBufferLike>;

    Returns true if the value is a built-in Int16Array instance.

    util.types.isInt16Array(new ArrayBuffer());  // Returns false
util.types.isInt16Array(new Int16Array());  // Returns true
util.types.isInt16Array(new Float64Array());  // Returns false
  • function isInt32Array(
    object: unknown
    ): object is Int32Array<ArrayBufferLike>;

    Returns true if the value is a built-in Int32Array instance.

    util.types.isInt32Array(new ArrayBuffer());  // Returns false
util.types.isInt32Array(new Int32Array());  // Returns true
util.types.isInt32Array(new Float64Array());  // Returns false
  • function isInt8Array(
    object: unknown
    ): object is Int8Array<ArrayBufferLike>;

    Returns true if the value is a built-in Int8Array instance.

    util.types.isInt8Array(new ArrayBuffer());  // Returns false
util.types.isInt8Array(new Int8Array());  // Returns true
util.types.isInt8Array(new Float64Array());  // Returns false
  • function isKeyObject(
    object: unknown
    ): object is KeyObject;

    Returns true if value is a KeyObject, false otherwise.

  • function isMap<T>(
    object: {} | T
    ): object is T extends ReadonlyMap<any, any> ? unknown extends T<T> ? never : ReadonlyMap<any, any> : Map<unknown, unknown>;

    Returns true if the value is a built-in Map instance.

    util.types.isMap(new Map());  // Returns true
  • function isMapIterator(
    object: unknown
    ): boolean;

    Returns true if the value is an iterator returned for a built-in Map instance.

    const map = new Map();
util.types.isMapIterator(map.keys());  // Returns true
util.types.isMapIterator(map.values());  // Returns true
util.types.isMapIterator(map.entries());  // Returns true
util.types.isMapIterator(map[Symbol.iterator]());  // Returns true
  • value: unknown
    ): boolean;

    Returns true if the value is an instance of a Module Namespace Object.

    import * as ns from './a.js';

util.types.isModuleNamespaceObject(ns);  // Returns true
  • function isNativeError(
    object: unknown
    ): object is Error;

    Returns true if the value was returned by the constructor of a built-in Error type.

    console.log(util.types.isNativeError(new Error()));  // true
console.log(util.types.isNativeError(new TypeError()));  // true
console.log(util.types.isNativeError(new RangeError()));  // true

    Subclasses of the native error types are also native errors:

    class MyError extends Error {}
console.log(util.types.isNativeError(new MyError()));  // true

    A value being instanceof a native error class is not equivalent to isNativeError() returning true for that value. isNativeError() returns true for errors which come from a different realm while instanceof Error returns false for these errors:

    import { createContext, runInContext } from 'node:vm';
import { types } from 'node:util';

const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false

    Conversely, isNativeError() returns false for all objects which were not returned by the constructor of a native error. That includes values which are instanceof native errors:

    const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
  • function isNumberObject(
    object: unknown
    ): object is Number;

    Returns true if the value is a number object, e.g. created by new Number().

    util.types.isNumberObject(0);  // Returns false
util.types.isNumberObject(new Number(0));   // Returns true
  • function isPromise(
    object: unknown
    ): object is Promise<unknown>;

    Returns true if the value is a built-in Promise.

    util.types.isPromise(Promise.resolve(42));  // Returns true
  • function isProxy(
    object: unknown
    ): boolean;

    Returns true if the value is a Proxy instance.

    const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target);  // Returns false
util.types.isProxy(proxy);  // Returns true
  • function isRegExp(
    object: unknown
    ): object is RegExp;

    Returns true if the value is a regular expression object.

    util.types.isRegExp(/abc/);  // Returns true
util.types.isRegExp(new RegExp('abc'));  // Returns true
  • function isSet<T>(
    object: {} | T
    ): object is T extends ReadonlySet<any> ? unknown extends T<T> ? never : ReadonlySet<any> : Set<unknown>;

    Returns true if the value is a built-in Set instance.

    util.types.isSet(new Set());  // Returns true
  • function isSetIterator(
    object: unknown
    ): boolean;

    Returns true if the value is an iterator returned for a built-in Set instance.

    const set = new Set();
util.types.isSetIterator(set.keys());  // Returns true
util.types.isSetIterator(set.values());  // Returns true
util.types.isSetIterator(set.entries());  // Returns true
util.types.isSetIterator(set[Symbol.iterator]());  // Returns true
  • object: unknown
    ): object is SharedArrayBuffer;

    Returns true if the value is a built-in SharedArrayBuffer instance. This does not include ArrayBuffer instances. Usually, it is desirable to test for both; See util.types.isAnyArrayBuffer() for that.

    util.types.isSharedArrayBuffer(new ArrayBuffer());  // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer());  // Returns true
  • function isStringObject(
    object: unknown
    ): object is String;

    Returns true if the value is a string object, e.g. created by new String().

    util.types.isStringObject('foo');  // Returns false
util.types.isStringObject(new String('foo'));   // Returns true
  • function isSymbolObject(
    object: unknown
    ): object is Symbol;

    Returns true if the value is a symbol object, created by calling Object() on a Symbol primitive.

    const symbol = Symbol('foo');
util.types.isSymbolObject(symbol);  // Returns false
util.types.isSymbolObject(Object(symbol));   // Returns true
  • function isTypedArray(
    object: unknown
    ): object is TypedArray<ArrayBufferLike>;

    Returns true if the value is a built-in TypedArray instance.

    util.types.isTypedArray(new ArrayBuffer());  // Returns false
util.types.isTypedArray(new Uint8Array());  // Returns true
util.types.isTypedArray(new Float64Array());  // Returns true

    See also ArrayBuffer.isView().

  • function isUint16Array(
    object: unknown
    ): object is Uint16Array<ArrayBufferLike>;

    Returns true if the value is a built-in Uint16Array instance.

    util.types.isUint16Array(new ArrayBuffer());  // Returns false
util.types.isUint16Array(new Uint16Array());  // Returns true
util.types.isUint16Array(new Float64Array());  // Returns false
  • function isUint32Array(
    object: unknown
    ): object is Uint32Array<ArrayBufferLike>;

    Returns true if the value is a built-in Uint32Array instance.

    util.types.isUint32Array(new ArrayBuffer());  // Returns false
util.types.isUint32Array(new Uint32Array());  // Returns true
util.types.isUint32Array(new Float64Array());  // Returns false
  • function isUint8Array(
    object: unknown
    ): object is Uint8Array<ArrayBufferLike>;

    Returns true if the value is a built-in Uint8Array instance.

    util.types.isUint8Array(new ArrayBuffer());  // Returns false
util.types.isUint8Array(new Uint8Array());  // Returns true
util.types.isUint8Array(new Float64Array());  // Returns false
  • object: unknown
    ): object is Uint8ClampedArray<ArrayBufferLike>;

    Returns true if the value is a built-in Uint8ClampedArray instance.

    util.types.isUint8ClampedArray(new ArrayBuffer());  // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray());  // Returns true
util.types.isUint8ClampedArray(new Float64Array());  // Returns false
  • function isWeakMap(
    object: unknown
    ): object is WeakMap<object, unknown>;

    Returns true if the value is a built-in WeakMap instance.

    util.types.isWeakMap(new WeakMap());  // Returns true
  • function isWeakSet(
    object: unknown
    ): object is WeakSet<object>;

    Returns true if the value is a built-in WeakSet instance.

    util.types.isWeakSet(new WeakSet());  // Returns true