Node Modules

Los módulos constituyen el sistema fundamental de organización de código en Node.js, permitiendo dividir aplicaciones complejas en componentes reutilizables y mantenibles. A diferencia del JavaScript del navegador, Node.js implementa un sistema de módulos robusto que facilita la modularización del código y la gestión de dependencias.

Sistema de módulos en Node.js

Node.js utiliza principalmente dos sistemas de módulos: CommonJS (el sistema tradicional) y ES Modules (el estándar moderno de JavaScript). Ambos sistemas permiten exportar e importar funcionalidades entre archivos, pero con sintaxis y comportamientos diferentes.

CommonJS: el sistema tradicional

CommonJS ha sido el sistema de módulos por defecto en Node.js desde sus inicios. Utiliza las funciones require() para importar módulos y module.exports o exports para exportar funcionalidades.

// matematicas.js
function sumar(a, b) {
    return a + b;
}

function multiplicar(a, b) {
    return a * b;
}

// Exportar múltiples funciones
module.exports = {
    sumar,
    multiplicar
};

// app.js
const { sumar, multiplicar } = require('./matematicas');

console.log(sumar(5, 3)); // 8
console.log(multiplicar(4, 2)); // 8

La desestructuración permite importar solo las funciones necesarias, mejorando la legibilidad del código y optimizando el uso de memoria.

ES Modules: el estándar moderno

Los ES Modules representan el estándar oficial de JavaScript para el manejo de módulos. Node.js los soporta completamente desde la versión 14, y son la opción recomendada para nuevos proyectos.

// matematicas.mjs
export function sumar(a, b) {
    return a + b;
}

export function multiplicar(a, b) {
    return a * b;
}

// Exportación por defecto
export default function dividir(a, b) {
    return a / b;
}

// app.mjs
import { sumar, multiplicar } from './matematicas.mjs';
import dividir from './matematicas.mjs';

console.log(sumar(10, 5)); // 15
console.log(dividir(10, 2)); // 5

Para utilizar ES Modules en Node.js, puedes usar archivos con extensión .mjs o configurar tu proyecto añadiendo "type": "module" en el archivo package.json.

Tipos de módulos

Node.js organiza los módulos en tres categorías principales que determinan cómo se resuelven y cargan las dependencias.

Módulos nativos

Los módulos nativos forman parte del núcleo de Node.js y proporcionan funcionalidades esenciales del sistema operativo y el entorno de ejecución.

import fs from 'fs';
import path from 'path';
import os from 'os';

// Información del sistema
console.log('Plataforma:', os.platform());
console.log('Arquitectura:', os.arch());

// Manipulación de rutas
const rutaCompleta = path.join(__dirname, 'datos', 'archivo.txt');
console.log('Ruta:', rutaCompleta);

Estos módulos están optimizados a nivel nativo y no requieren instalación adicional, proporcionando acceso directo a las capacidades del sistema.

Módulos locales

Los módulos locales son archivos JavaScript que creates en tu proyecto para organizar y reutilizar código. Node.js resuelve estos módulos utilizando rutas relativas o absolutas.

// utils/validadores.js
export function validarEmail(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
}

export function validarTelefono(telefono) {
    const regex = /^\+?[\d\s-()]+$/;
    return regex.test(telefono);
}

// app.js
import { validarEmail, validarTelefono } from './utils/validadores.js';

const email = 'usuario@ejemplo.com';
const telefono = '+34 123 456 789';

console.log('Email válido:', validarEmail(email));
console.log('Teléfono válido:', validarTelefono(telefono));

La organización en carpetas y la nomenclatura descriptiva facilitan el mantenimiento y la colaboración en equipos de desarrollo.

Módulos de terceros

Los módulos de terceros se instalan desde el registro npm y extienden las capacidades de Node.js con funcionalidades desarrolladas por la comunidad.

// Instalación: npm install lodash
import _ from 'lodash';

const usuarios = [
    { nombre: 'Ana', edad: 25 },
    { nombre: 'Carlos', edad: 30 },
    { nombre: 'Beatriz', edad: 28 }
];

// Utilizar funcionalidades de lodash
const usuariosOrdenados = _.sortBy(usuarios, 'edad');
const nombres = _.map(usuarios, 'nombre');

console.log('Ordenados por edad:', usuariosOrdenados);
console.log('Solo nombres:', nombres);

Resolución de módulos

Node.js implementa un algoritmo de resolución sofisticado que determina qué archivo cargar cuando se solicita un módulo. Este proceso sigue un orden específico de búsqueda.

Resolución de rutas relativas

Cuando utilizas rutas que comienzan con ./ o ../, Node.js busca el archivo relativo a la ubicación del archivo que realiza la importación.

// Estructura de carpetas:
// proyecto/
//   ├── src/
//   │   ├── controllers/
//   │   │   └── usuario.js
//   │   └── models/
//   │       └── usuario.js
//   └── app.js

// En src/controllers/usuario.js
import UsuarioModel from '../models/usuario.js';

Resolución de módulos npm

Para módulos instalados via npm, Node.js busca en la carpeta node_modules comenzando desde el directorio actual y ascendiendo en la jerarquía de carpetas.

// Node.js busca en este orden:
// ./node_modules/lodash
// ../node_modules/lodash  
// ../../node_modules/lodash
// Y así sucesivamente hasta la raíz del sistema
import _ from 'lodash';

Exportaciones avanzadas

Las exportaciones en Node.js ofrecen flexibilidad para exponer diferentes tipos de funcionalidades según las necesidades del módulo.

Exportación selectiva

Permite exportar solo las funciones o variables específicas que otros módulos necesitan utilizar.

// servicios/database.js
const conexion = 'mongodb://localhost:27017';

function conectar() {
    console.log(`Conectando a ${conexion}`);
    // Lógica de conexión
}

function desconectar() {
    console.log('Desconectando de la base de datos');
    // Lógica de desconexión
}

// Solo exportamos las funciones públicas
export { conectar, desconectar };
// La variable conexion permanece privada

Exportación por defecto combinada

Combina exportaciones nombradas con una exportación por defecto para máxima flexibilidad.

// auth/jwt.js
export function generarToken(payload) {
    // Lógica para generar JWT
    return 'jwt-token-generado';
}

export function verificarToken(token) {
    // Lógica para verificar JWT
    return { valid: true, payload: {} };
}

// Exportación por defecto
export default class AuthManager {
    constructor(secreto) {
        this.secreto = secreto;
    }
    
    autenticar(credenciales) {
        // Lógica de autenticación
        return generarToken(credenciales);
    }
}

// Uso del módulo
import AuthManager, { generarToken, verificarToken } from './auth/jwt.js';

const auth = new AuthManager('mi-secreto');
const token = generarToken({ userId: 123 });
const esValido = verificarToken(token);

Carga dinámica de módulos

La importación dinámica permite cargar módulos condicionalmente o bajo demanda, optimizando el rendimiento de la aplicación.

// Carga condicional basada en el entorno
const entorno = process.env.NODE_ENV || 'development';

if (entorno === 'production') {
    const { default: logger } = await import('./logger-produccion.js');
    logger.info('Aplicación iniciada en producción');
} else {
    const { default: logger } = await import('./logger-desarrollo.js');
    logger.debug('Aplicación iniciada en desarrollo');
}

La carga bajo demanda resulta especialmente útil para módulos grandes que solo se utilizan en circunstancias específicas.

// Cargar módulo solo cuando sea necesario
async function procesarImagenes(imagenes) {
    // Solo importar la librería de procesamiento cuando se necesite
    const { default: sharp } = await import('sharp');
    
    return Promise.all(
        imagenes.map(imagen => sharp(imagen).resize(300, 300).toBuffer())
    );
}

Los módulos en Node.js proporcionan la base arquitectural para construir aplicaciones escalables y mantenibles, permitiendo la reutilización de código y la separación clara de responsabilidades entre diferentes componentes del sistema.