A Few Useful Functions in Node.js Util Module

Node.js encompasses a range of components that come together to form a JavaScript runtime environment. In our series on Node.js Architecture - Introduction to Node.js, we explored the various components that make up Node.js and their respective functions.

Within Node.js, there are numerous built-in modules - i.e., modules that are integrated from the outset. One such module is util, which, in my opinion, deserves more attention. The util module comprises a collection of small utility functions that can be helpful in certain situations. In this article, we will delve into some of these functions...

util.promisify and util.callbackify

The callback is one of the earliest ways to handle asynchronous code. However, callbacks have several limitations, such as creating nested code and causing the infamous "callback hell." Occasionally, reading a piece of code written in a callback style can be overwhelming. Adding new functionality can be challenging, as it requires introducing an additional layer of logic.

In Node.js, there is a utility function to convert asynchronous functions using the callback style to Promises. This function is useful when you want to transition to a Promise-based approach and then combine it with async/await to make your code more concise and easier to follow.

const util = require('node:util');
const fs = require('node:fs');

const stat = util.promisify(fs.stat);

async function callStat() {
  const stats = await stat('.');
  console.log(`This directory is owned by ${stats.uid}`);
}

callStat(); 

Conversely, we have util.callbackify to convert Promise-based functions back to callbacks.

const util = require('node:util');

async function fn() {
  return 'hello world';
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
}); 

util.deprecate

If you frequently use libraries, you may have noticed console messages indicating that a function is deprecated.

oldFunction() is deprecated. Use newFunction() instead.

This is a notification that the oldFunction is nearing the end of its support lifecycle and may be removed in the future. It is a common approach to remind developers that a function is approaching its "retirement" and to use an alternative function instead.

In Node.js, there is a simple way to display this notification if you need to warn others that a function is nearing its end-of-life.

const util = require('util');

function oldFunction() {
    console.log('This function is deprecated!');
}

const deprecatedFunction = util.deprecate(oldFunction, 'oldFunction() is deprecated. Use newFunction() instead.');

Simply "wrap" the oldFunction inside util.deprecate. Each time oldFunction is called, the warning message will appear in the console.

util.types

From ES6 onward, we have additional functions to check the type of data: boolean, array, object, etc.

The util module has a types property that extends the capability to check data types.

For instance:

console.log(util.types.isPromise(Promise.resolve())); // true
console.log(util.types.isRegExp(/abc/)); // true
console.log(util.types.isDate(new Date())); // true

A comprehensive list is available at util.types | Node.js documentation.

util.isDeepStrictEqual

isDeepStrictEqual is the most efficient method to compare two objects and determine if they are identical.

const util = require('util');

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: 1, b: { c: 2 } };

console.log(util.isDeepStrictEqual(obj1, obj2)); // true

In addition to these functions, the util module provides many other utility functions, such as util.styleText to format text output in the console, and util.parseEnv to parse the contents of environment variables in .env files.

For more information, refer to:

• Node.js v22.8.0 documentation | Util