Módulo util

Qué es el módulo util

El módulo util es una biblioteca nativa de Node.js que proporciona funciones de utilidad para el desarrollo de aplicaciones. Este módulo incluye herramientas que facilitan tareas comunes como la inspección de objetos, formateo de texto, manejo de promesas y otras operaciones auxiliares que mejoran la productividad durante el desarrollo.

A diferencia de otros módulos que se centran en funcionalidades específicas como el sistema de archivos o HTTP, el módulo util actúa como una caja de herramientas con funciones diversas que complementan el trabajo diario con JavaScript en Node.js.

Importación y uso básico

Para utilizar el módulo util, simplemente lo importamos usando require():

const util = require('util');

Una vez importado, tenemos acceso a todas sus funciones de utilidad. El módulo util es especialmente útil para depuración, formateo de datos y conversión entre diferentes tipos de funciones.

Inspección de objetos con util.inspect()

Una de las funciones más utilizadas es util.inspect(), que permite examinar objetos de forma detallada, mostrando su estructura interna de manera legible:

const util = require('util');

const objeto = {
  nombre: 'Juan',
  edad: 30,
  hobbies: ['lectura', 'programación'],
  direccion: {
    ciudad: 'Madrid',
    codigo: 28001
  }
};

console.log(util.inspect(objeto, { depth: null, colors: true }));

La función inspect() acepta opciones para personalizar la salida:

• depth: controla la profundidad de inspección de objetos anidados
• colors: añade colores para mejorar la legibilidad
• showHidden: muestra propiedades no enumerables

Formateo de texto con util.format()

El método util.format() funciona de manera similar a printf en otros lenguajes, permitiendo formatear cadenas con marcadores de posición:

const util = require('util');

const nombre = 'Ana';
const edad = 25;
const salario = 45000.50;

const mensaje = util.format('Empleado: %s, Edad: %d, Salario: %.2f€', nombre, edad, salario);
console.log(mensaje); // Empleado: Ana, Edad: 25, Salario: 45000.50€

Los marcadores de posición más comunes son:

• %s: cadena de texto
• %d: número entero
• %f: número decimal
• %j: objeto JSON
• %%: símbolo de porcentaje literal

Conversión de funciones callback a promesas

Una funcionalidad muy valiosa es util.promisify(), que convierte funciones que usan callbacks al estilo tradicional de Node.js en funciones que retornan promesas:

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

// Convertir fs.readFile a una función que retorna promesas
const readFileAsync = util.promisify(fs.readFile);

// Uso con async/await
async function leerArchivo() {
  try {
    const contenido = await readFileAsync('archivo.txt', 'utf8');
    console.log('Contenido del archivo:', contenido);
  } catch (error) {
    console.error('Error al leer archivo:', error.message);
  }
}

leerArchivo();

Esta conversión es especialmente útil cuando queremos modernizar código que utiliza callbacks y adoptar el patrón async/await para un código más limpio y legible.

Verificación de tipos con util.types

El submódulo util.types proporciona funciones para verificar tipos específicos de JavaScript de forma más precisa que los operadores tradicionales:

const util = require('util');

const fecha = new Date();
const array = [1, 2, 3];
const mapa = new Map();

console.log(util.types.isDate(fecha));        // true
console.log(util.types.isArray(array));       // true
console.log(util.types.isMap(mapa));          // true
console.log(util.types.isPromise(Promise.resolve())); // true

Estas funciones son más confiables que usar instanceof o typeof, especialmente cuando trabajamos con objetos que pueden provenir de diferentes contextos o marcos de ejecución.

Herencia y util.inherits()

Aunque menos común en el JavaScript moderno, util.inherits() permite establecer herencia prototípica entre constructores:

const util = require('util');

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

Animal.prototype.hablar = function() {
  console.log(`${this.nombre} hace un sonido`);
};

function Perro(nombre, raza) {
  Animal.call(this, nombre);
  this.raza = raza;
}

// Establecer herencia
util.inherits(Perro, Animal);

Perro.prototype.ladrar = function() {
  console.log(`${this.nombre} ladra`);
};

const miPerro = new Perro('Rex', 'Labrador');
miPerro.hablar(); // Rex hace un sonido
miPerro.ladrar(); // Rex ladra

En aplicaciones modernas, es preferible usar clases de ES6 con extends, pero util.inherits() sigue siendo útil para mantener compatibilidad con código existente o cuando trabajamos con constructores tradicionales.