Node.js Util Module Reference

Introduction

The Util Module in Node.js is a powerful collection of utility functions that can help developers efficiently perform common tasks. Whether you are a beginner or an experienced developer, understanding the features provided by the util module can greatly enhance your development process. This article will explore the different methods available in the util module, along with practical examples to demonstrate their usage.

Util Module Methods

util.inherits()

The util.inherits() function is used to set up inheritance between two constructor functions. This allows one constructor to “inherit” the prototype methods of another.

const util = require('util');

function Animal(name) {
    this.name = name;
}

Animal.prototype.speak = function() {
    console.log(this.name + ' makes a noise.');
};

function Dog(name) {
    Animal.call(this, name);
}

// Inherit from Animal
util.inherits(Dog, Animal);

Dog.prototype.speak = function() {
    console.log(this.name + ' barks.');
};

const dog = new Dog('Rex');
dog.speak(); // Output: Rex barks.

util.inspect()

The util.inspect() method is used to convert an object into a string representation, allowing for better readability of objects in the console.

const util = require('util');

const obj = {
    name: 'John',
    age: 30,
    isActive: true,
    hobbies: ['reading', 'gaming']
};

console.log(util.inspect(obj, { showHidden: true, depth: null, colors: true }));
// Output will show obj in a readable format with colors

util.format()

The util.format() function allows developers to create formatted strings similar to printf in C/C++.

const util = require('util');

const name = 'Alice';
const age = 25;

const message = util.format('%s is %d years old.', name, age);
console.log(message); // Output: Alice is 25 years old.

util.deprecate()

The util.deprecate() function can be used to mark methods as deprecated, providing a warning when the method is called.

const util = require('util');

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

const newFunction = util.deprecate(deprecatedFunction, 'Please use newFunction instead.');

newFunction(); // Output: (Warning) This function is deprecated.

util.promisify()

The util.promisify() function converts a callback-style function into a Promise-based function.

const util = require('util');

const fs = require('fs');
const readFile = util.promisify(fs.readFile);

readFile('example.txt', 'utf8')
    .then(data => console.log(data))
    .catch(err => console.error(err));

util.callbackify()

The util.callbackify() function transforms a Promise-based function back into a callback-style function.

const util = require('util');

async function asyncFunction() {
    return 'Hello from async!';
}

const callbackFunction = util.callbackify(asyncFunction);

callbackFunction((err, result) => {
    if (err) throw err;
    console.log(result); // Output: Hello from async!
});

util.types

The util.types namespace provides type-checking methods to determine the type of an object.

Types in Util Module

Method	Description
isPromise()	Checks if a given value is a Promise.
isGeneratorFunction()	Checks if a given function is a Generator function.
isGeneratorObject()	Checks if a given object is a Generator object.
isAsyncFunction()	Checks if a given function is an Async function.
isTypedArray()	Checks if a given object is a Typed Array.
isWeakRef()	Checks if a given object is a WeakRef.
isWebAssemblyCompiledModule()	Checks if a given object is a WebAssembly compiled module.

Example: isPromise()

const util = require('util');

async function exampleFunction() {}

console.log(util.types.isPromise(exampleFunction())); // Output: true
console.log(util.types.isPromise(42)); // Output: false

Example: isAsyncFunction()

const util = require('util');

async function asyncFunc() {}

console.log(util.types.isAsyncFunction(asyncFunc)); // Output: true
console.log(util.types.isAsyncFunction(function() {})); // Output: false

Conclusion

In summary, the Util Module provides a wide range of highly useful functions that simplify many common tasks in Node.js applications. By familiarizing yourself with methods like util.promisify(), util.inspect(), and others, you can enhance both your productivity and the quality of your code. As you continue your journey with Node.js, be sure to explore these utilities further and integrate them into your projects.

FAQ

What is the util module used for?

The util module provides utility functions for various tasks, including inheritance, string formatting, type checking, and Promises handling.

How can I use Promises with the util module?

You can use util.promisify() to convert callback-based functions into Promises, making it easier to work with asynchronous code.

Is the util module built into Node.js?

Yes, the util module is a built-in module, so you don’t need to install it separately. Simply require it in your application with const util = require(‘util’);.

Can I use the util.inherits() method for class inheritance?

While util.inherits() is used for prototype inheritance, with ES6 classes, you should use the extends keyword for inheritance.

What types of objects can I check with util.types?

You can check for various types, including Promises, Generator functions, Typed Arrays, and more, using the methods provided in util.types.

askthedev.com Latest Articles