La modularización en JavaScript es un concepto fundamental para cualquier desarrollador que desee mantener sus proyectos ordenados, escalables y mantenibles. Antes de la llegada de ES6 con sus módulos ES, CommonJS era la principal herramienta utilizada para este propósito en el entorno de Node.js. Aún hoy, comprender CommonJS es crucial, especialmente cuando tratamos con código base existente o contribuimos a proyectos de la comunidad que aún lo utilizan.
¿Qué es CommonJS?
CommonJS es un estándar para modularizar el código de JavaScript que fue adoptado principalmente en el entorno de Node.js. Esta especificación define un conjunto de convenciones para la creación de módulos intercambiables, lo que significa que puedes escribir piezas de código que pueden ser reutilizadas a lo largo de diferentes partes de una aplicación o incluso entre diferentes proyectos.
Orígenes y Evolución
Los orígenes de CommonJS se remontan a los primeros días de JavaScript en el servidor, cuando el lenguaje comenzó a extenderse fuera del navegador. En ese momento, la falta de un sistema de módulos estandarizado llevó a la comunidad a buscar una solución. CommonJS surgió como respuesta a esta necesidad, aunque con el tiempo ha sido complementado y en muchos casos reemplazado por los módulos ES en el navegador, y la sintaxis de importación y exportación de ES6 en el servidor.
Características Principales
- Simplicidad: Un módulo CommonJS es un archivo JavaScript simple que exporta un objeto, una función, una clase o cualquier valor a través del objeto
module.exports. - Sincronización: La carga de módulos se realiza de manera sincrónica. Esto significa que los módulos están disponibles inmediatamente después de que se cargan, lo cual es apto en el entorno de Node.js que opera en el lado del servidor.
- Encapsulamiento: Cada módulo tiene su propio alcance. Por lo tanto, las variables y funciones definidas en un módulo no están accesibles directamente desde otros módulos a menos que se exporten explícitamente.
- Resolución de módulos: Node.js utiliza un sistema de resolución de módulos para encontrar archivos basándose en una serie de reglas de resolución de rutas, lo que permite utilizar tanto módulos del núcleo de Node.js como módulos instalados desde npm o módulos locales.
Cómo Trabajar con CommonJS
Para comenzar a trabajar con CommonJS, es necesario entender el sistema de require y module.exports.
Exportación de Módulos
Cuando creas un módulo, lo que haces es preparar ciertos elementos para ser utilizados en otros archivos. Para hacer que una función, un objeto o cualquier otro valor sea accesible fuera del módulo, se utiliza module.exports. Por ejemplo:
// saludos.js
function saludar(nombre) {
return `¡Hola, ${nombre}!`;
}
module.exports = saludar;Importación de Módulos
Para utilizar el módulo que has exportado en otro archivo de JavaScript, empleas la función require proporcionando la ruta al módulo que deseas importar.
// app.js
const saludar = require('./saludos.js');
console.log(saludar('NelkoDev')); // ¡Hola, NelkoDev!Múltiples Exportaciones
Si quieres exportar múltiples funciones o valores puedes utilizar exports para añadir cada uno de ellos al objeto que module.exports expone:
// operaciones.js
function sumar(a, b) {
return a + b;
}
function restar(a, b) {
return a - b;
}
exports.sumar = sumar;
exports.restar = restar;Y luego los importarías así:
// app.js
const operaciones = require('./operaciones.js');
console.log(operaciones.sumar(5, 3)); // 8
console.log(operaciones.restar(5, 3)); // 2Módulos Nativos y de Terceros
Además de los módulos que puedes crear tú mismo, Node.js viene con varios módulos incorporados, conocidos como módulos del núcleo, que puedes requerir de la misma manera:
// Usando el módulo 'http' que es parte del core de Node.js
const http = require('http');Similar es el proceso para cargar módulos de terceros, previamente instalados en tu proyecto a través de npm:
// Usando un módulo instalado a través de npm, por ejemplo 'lodash'
const _ = require('lodash');Buenas Prácticas en Modularización
La modularización es más que solo partir tu código en diferentes archivos. Implica seguir una serie de buenas prácticas:
- Cohesión: Cada módulo debe tener una responsabilidad única y claramente definida.
- Reusabilidad: Diseña módulos de tal manera que puedan ser reutilizados en diferentes partes de tu aplicación o en nuevos proyectos.
- Independencia: Los módulos deben ser lo más independientes posible. Esto mejora la facilidad de mantenimiento y testeo.
- Nomenclatura clara: Elige nombres de archivos y variables que comuniquen claramente su función y contenido.
Hacia Adelante en la Modularización
Aunque CommonJS sigue siendo una herramienta vigente, especialmente en proyectos que se ejecutan en el lado del servidor con Node.js, es vital estar al tanto de los avances en el campo de la modularización. Los módulos ES son el estándar actual en el navegador y están ganando terreno en el lado del servidor gracias a las últimas versiones de Node.js que soportan importación y exportación ES6 nativas.
Conclusión
La capacidad de modularizar tu código es una habilidad esencial en el desarrollo moderno de aplicaciones JavaScript. CommonJS desempeñó un papel crucial en la historia de JavaScript al proporcionar una forma de estructurar y organizar el código antes de que se estandarizaran los módulos ES6.
Dominar estas técnicas te equipará para trabajar tanto en proyectos heredados como en nuevas codebases, y afianzará tu comprensión de los conceptos fundamentales que sostienen las aplicaciones JavaScript de hoy en día. Si deseas aprender más sobre otros temas de desarrollo o compartir tus experiencias con la modularización, te invito a visitar NelkoDev Blog o ponerte en contacto a través de este enlace.
Continuar explorando estos conceptos y prácticas te ayudará a crear software robusto y bien organizado, listo para enfrentar las demandas de un mundo de desarrollo en constante evolución.
Spanish 
English