Skip to main content

util

Note

For compatibility dates of 2026-08-04 or later, Workers enables both nodejs_compat and nodejs_compat_v2 by default. These flags are not used for these compatibility dates. Existing projects do not need to remove them when updating their compatibility date. For earlier dates, add nodejs_compat to your Wrangler configuration file to opt in. For instructions to turn off Node.js compatibility, refer to the Node.js compatibility flag.

promisify/callbackify

The promisify and callbackify APIs in Node.js provide a means of bridging between a Promise-based programming model and a callback-based model.

The promisify method allows taking a Node.js-style callback function and converting it into a Promise-returning async function:

import { promisify } from "node:util";

function foo(args, callback) {
	try {
		callback(null, 1);
	} catch (err) {
		// Errors are emitted to the callback via the first argument.
		callback(err);
	}
}

const promisifiedFoo = promisify(foo);
await promisifiedFoo(args);

Similarly to promisify, callbackify converts a Promise-returning async function into a Node.js-style callback function:

import { callbackify } from 'node:util';

async function foo(args) {
  throw new Error('boom');
}

const callbackifiedFoo = callbackify(foo);

callbackifiedFoo(args, (err, value) => {
  if (err) throw err;
});

callbackify and promisify make it easy to handle all of the challenges that come with bridging between callbacks and promises.

Refer to the Node.js documentation for callbackify and Node.js documentation for promisify for more information.

util.types

The util.types API provides a reliable and efficient way of checking that values are instances of various built-in types.

import { types } from "node:util";

types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
types.isArrayBufferView(new Int8Array()); // true
types.isArrayBufferView(Buffer.from("hello world")); // true
types.isArrayBufferView(new DataView(new ArrayBuffer(16))); // true
types.isArrayBufferView(new ArrayBuffer()); // false
function foo() {
	types.isArgumentsObject(arguments); // Returns true
}
types.isAsyncFunction(function foo() {}); // Returns false
types.isAsyncFunction(async function foo() {}); // Returns true
// .. and so on

Caution

The Workers implementation currently does not provide implementations of the util.types.isExternal(), util.types.isProxy(), util.types.isKeyObject(), or util.type.isWebAssemblyCompiledModule() APIs.

For more about util.types, refer to the Node.js documentation for util.types.

util.MIMEType

util.MIMEType provides convenience methods that allow you to more easily work with and manipulate MIME types. For example:

import { MIMEType } from "node:util";

const myMIME = new MIMEType("text/javascript;key=value");

console.log(myMIME.type);
// Prints: text

console.log(myMIME.essence);
// Prints: text/javascript

console.log(myMIME.subtype);
// Prints: javascript

console.log(String(myMIME));
// Prints: application/javascript;key=value

For more about util.MIMEType, refer to the Node.js documentation for util.MIMEType.

Edit on GitHub