Alai

El autor seleccionó el Open Internet/Free Speech Fund para recibir una donación como parte del programa Write for DOnations.

Introducción

En Node.js, un módulo es una colección de funciones y objetos JavaScript que pueden ser utilizados por aplicaciones externas. Describir un trozo de código como un módulo se refiere menos a lo que el código es y más a lo que hace-cualquier archivo o colección de archivos de Node.js puede ser considerado un módulo si sus funciones y datos se hacen utilizables para programas externos.

Debido a que los módulos proporcionan unidades de funcionalidad que pueden ser reutilizadas en muchos programas más grandes, le permiten crear aplicaciones débilmente acopladas que escalan con la complejidad, y le abren la puerta para compartir su código con otros desarrolladores. Ser capaz de escribir módulos que exporten funciones y datos útiles te permitirá contribuir a la comunidad más amplia de Node.js -de hecho, todos los paquetes que utilizas en npm fueron empaquetados y compartidos como módulos. Esto hace que la creación de módulos sea una habilidad esencial para un desarrollador de Node.js.

En este tutorial, crearás un módulo de Node.js que sugiere qué color deben usar los desarrolladores web en sus diseños. Desarrollarás el módulo almacenando los colores como un array, y proporcionando una función para recuperar uno al azar. Después, recorrerás varias formas de importar un módulo en una aplicación Node.js.

Requisitos previos

• Necesitarás Node.js y npm instalados en tu entorno de desarrollo. Este tutorial utiliza la versión 10.17.0. Para instalarlo en macOS o Ubuntu 18.04, sigue los pasos de Cómo instalar Node.js y crear un entorno de desarrollo local en macOS o la sección Instalar usando un PPA de Cómo instalar Node.js en Ubuntu 18.04. Al tener Node.js instalado también tendrás npm instalado; este tutorial utiliza la versión 6.11.3.
• También deberías estar familiarizado con el archivo package.json, y la experiencia con los comandos npm también sería útil. Para obtener esta experiencia, siga Cómo utilizar los módulos de Node.js con npm y package.json, en particular el Paso 1 – Creación de un archivo package.json.
• También ayudará estar cómodo con el REPL de Node.js (Read-Evaluate-Print-Loop). Usted usará esto para probar su módulo. Si necesitas más información sobre esto, lee nuestra guía sobre Cómo usar el REPL de Node.js.

Paso 1 – Crear un módulo

Este paso te guiará en la creación de tu primer módulo Node.js. Tu módulo contendrá una colección de colores en un array y proporcionará una función para obtener uno al azar. Utilizarás la propiedad exports incorporada en Node.js para que la función y el array estén disponibles para programas externos.

Primero, empezarás por decidir qué datos sobre los colores vas a almacenar en tu módulo. Cada color será un objeto que contiene una propiedad name que los humanos pueden identificar fácilmente, y una propiedad code que es una cadena que contiene un código de color HTML. Los códigos de color HTML son números hexadecimales de seis dígitos que permiten cambiar el color de los elementos de una página web. Puedes aprender más sobre los códigos de color HTML leyendo este artículo Códigos y nombres de color HTML.

A continuación, decidirás qué colores quieres admitir en tu módulo. Su módulo contendrá un array llamado allColors que contendrá seis colores. Su módulo también incluirá una función llamada getRandomColor() que seleccionará aleatoriamente un color de su matriz y lo devolverá.

En su terminal, haga una nueva carpeta llamada colors y muévase dentro de ella:

 
mkdir colors
 
cd colors
 

Inicie npm para que otros programas puedan importar este módulo más adelante en el tutorial:

npm init -y 

Utilizó la bandera -y para saltarse las indicaciones habituales para personalizar su package.json. Si se tratara de un módulo que quisieras publicar en npm, responderías a todas estas indicaciones con los datos pertinentes, como se explica en Cómo usar los módulos de Node.js con npm y package.json.

En este caso, tu salida será:

Output
{ "name": "colors", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Ahora, abre un editor de texto de línea de comandos como nano y crea un nuevo archivo que sirva como punto de entrada para tu módulo:

nano index.js

Tu módulo hará algunas cosas. Primero, definirá una clase Color. Su clase Color será instanciada con su nombre y código HTML. Añade las siguientes líneas para crear la clase:

class Color { constructor(name, code) { this.name = name; this.code = code; }}

Ahora que tienes tu estructura de datos para Color, añade algunas instancias en tu módulo. Escribe el siguiente array resaltado en tu archivo:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;

Por último, introduce una función que seleccione aleatoriamente un elemento del array allColors que acabas de crear:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors;}exports.allColors = allColors;

La palabra clave exports hace referencia a un objeto global disponible en todos los módulos de Node.js. Todas las funciones y objetos almacenados en el objeto exports de un módulo se exponen cuando otros módulos Node.js lo importan. La función getRandomColor() fue creada directamente en el objeto exports, por ejemplo. A continuación, ha añadido una propiedad allColors al objeto exports que hace referencia a la constante local allColors matriz creada anteriormente en el script.

Cuando otros módulos importen este módulo, tanto allColors como getRandomColor() estarán expuestos y disponibles para su uso.

Guardar y salir del archivo.

Hasta ahora, ha creado un módulo que contiene una matriz de colores y una función que devuelve uno al azar. También has exportado el array y la función, para que los programas externos puedan utilizarlos. En el siguiente paso, utilizarás tu módulo en otras aplicaciones para demostrar los efectos de export.

Paso 2 – Probando su módulo con el REPL

Antes de construir una aplicación completa, tómese un momento para confirmar que su módulo está funcionando. En este paso, usarás el REPL para cargar el módulo colors. Mientras que en el REPL, usted llamará a la función getRandomColor() para ver si se comporta como usted espera.

Inicia el REPL de Node.js en la misma carpeta que el archivo index.js:

node

Cuando el REPL se haya iniciado, verás el prompt >. Esto significa que puede introducir código JavaScript que será evaluado inmediatamente. Si quieres leer más sobre esto, sigue nuestra guía sobre el uso de la REPL.

Primero, introduce lo siguiente:

colors = require('./index');

En este comando, require() carga el módulo colors en su punto de entrada. Al pulsar ENTER se obtiene:

Output
{ getRandomColor: , allColors: }

El REPL nos muestra el valor de colors, que son todas las funciones y objetos importados del fichero index.js. Cuando usas la palabra clave require, Node.js devuelve todo el contenido dentro del objeto exports de un módulo.

Recuerda que has añadido getRandomColor() y allColors a exports en el módulo colors. Por esa razón, usted ve ambos en el REPL cuando son importados.

En el prompt, pruebe la función getRandomColor():

colors.getRandomColor();

Se le pedirá un color aleatorio:

Output
Color { name: 'groovygray', code: '#D7DBDD' }

Como el índice es aleatorio, su salida puede variar. Ahora que has confirmado que el módulo colors funciona, sal del REPL de Node.js:

.exit

Esto te devolverá a la línea de comandos de tu terminal.

Acabas de confirmar que tu módulo funciona como se esperaba utilizando el REPL. A continuación, aplicará estos mismos conceptos y cargará su módulo en una aplicación, como lo haría en un proyecto real.

Paso 3 – Guardar su módulo local como una dependencia

Mientras probaba su módulo en la REPL, lo importó con una ruta relativa. Esto significa que utilizó la ubicación del archivo index.js en relación con el directorio de trabajo para obtener su contenido. Aunque esto funciona, normalmente es una mejor experiencia de programación importar módulos por sus nombres para que la importación no se rompa cuando se cambie el contexto. En este paso, instalarás el módulo colors con la función de módulo local de npm install.

Crea un nuevo módulo de Node.js fuera de la carpeta colors. Primero, ve al directorio anterior y crea una nueva carpeta:

 
cd ..
 
mkdir really-large-application
 

Ahora muévete a tu nuevo proyecto:

cd really-large-application

Al igual que con el módulo colors, inicializa tu carpeta con npm:

npm init -y 

Se generará el siguiente package.json:

Output
{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Ahora, instala tu módulo colors y utiliza la bandera --save para que quede registrado en tu archivo package.json:

npm install --save ../colors

Acabas de instalar tu módulo colors en el nuevo proyecto. Abra el archivo package.json para ver la nueva dependencia local:

nano package.json

Verá que se han añadido las siguientes líneas resaltadas:

{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC", "dependencies": { "colors": "file:../colors" }}

Salga del archivo.

El módulo colors se ha copiado en su directorio node_modules. Verifique que está allí con el siguiente comando:

ls node_modules

Esto dará la siguiente salida:

Output
colors

Use su módulo local instalado en este nuevo programa. Vuelva a abrir su editor de texto y cree otro archivo JavaScript:

nano index.js

Su programa importará primero el módulo colors. A continuación, elegirá un color al azar utilizando la función getRandomColor() proporcionada por el módulo. Finalmente, imprimirá un mensaje en la consola que le dirá al usuario qué color usar.

Ingrese el siguiente código en index.js:

const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

Guarde y salga de este archivo.

Su aplicación ahora le dirá al usuario una opción de color aleatoria para un componente del sitio web.

Ejecute este script con:

node index.js

Su salida será similar a:

Output
You should use leafygreen on your website. It's HTML code is #48C9B0

Ahora ha instalado con éxito el módulo colors y puede gestionarlo como cualquier otro paquete npm utilizado en su proyecto. Sin embargo, si añadieras más colores y funciones a tu módulo local colors, tendrías que ejecutar npm update en tus aplicaciones para poder utilizar las nuevas opciones. En el siguiente paso, utilizará el módulo local colors de otra manera y obtendrá actualizaciones automáticas cuando el código del módulo cambie.

Paso 4 – Enlazar un módulo local

Si su módulo local está en fuerte desarrollo, actualizar continuamente los paquetes puede ser tedioso. Una alternativa sería vincular los módulos. Enlazar un módulo asegura que cualquier actualización del módulo se refleje inmediatamente en las aplicaciones que lo utilizan.

En este paso, enlazará el módulo colors a su aplicación. También modificará el módulo colors y confirmará que sus cambios más recientes funcionan en la aplicación sin tener que reinstalar o actualizar.

Primero, desinstale su módulo local:

npm un colors

npm enlaza módulos utilizando enlaces simbólicos (o symlinks), que son referencias que apuntan a archivos o directorios en su computadora. La vinculación de un módulo se realiza en dos pasos:

1. Crear un enlace global al módulo. npm crea un enlace simbólico entre su directorio global node_modules y el directorio de su módulo. El directorio global node_modules es la ubicación en la que se instalan todos los paquetes npm de su sistema (cualquier paquete que instale con la bandera -g).
2. Crear un enlace local. npm crea un enlace simbólico entre su proyecto local que está utilizando el módulo y el enlace global del módulo.

Primero, cree el enlace global volviendo a la carpeta colors y utilizando el comando link:

 
cd ../colors
 
sudo npm link
 

Una vez completado, su shell mostrará:

Output
/usr/local/lib/node_modules/colors -> /home/sammy/colors

Acaba de crear un enlace simbólico en su carpeta node_modules a su directorio colors.

Vuelve a la carpeta really-large-application y enlaza el paquete:

 
cd ../really-large-application
 
sudo npm link colors
 

Recibirás una salida similar a la siguiente:

Output
/home/sammy/really-large-application/node_modules/colors -> /usr/local/lib/node_modules/colors -> /home/sammy/colors

Nota: Si quieres escribir un poco menos, puedes usar ln en lugar de link. Por ejemplo, npm ln colors habría funcionado exactamente igual.

Como muestra la salida, acabas de crear un enlace simbólico desde el directorio local node_modules de tu really-large-application al enlace simbólico colors en tu node_modules global, que apunta al directorio real con el módulo colors.

El proceso de vinculación está completo. Ejecute su archivo para asegurarse de que sigue funcionando:

node index.js

Su salida será similar a:

Output
You should use sunkissedyellow on your website. It's HTML code is #F4D03F

La funcionalidad de su programa está intacta. A continuación, compruebe que las actualizaciones se aplican inmediatamente. En su editor de texto, vuelva a abrir el archivo index.js en el módulo colors:

 
cd ../colors
 
nano index.js
 

Ahora añada una función que seleccione el mejor tono de azul que exista. No toma argumentos, y siempre devuelve el tercer elemento de la matriz allColors. Añade estas líneas al final del archivo:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors; }exports.allColors = allColors;exports.getBlue = () => { return allColors;}

Guarda y sal del archivo, y vuelve a abrir el archivo index.js en la carpeta really-large-application:

 
cd ../really-large-application
 
nano index.js
 

Haz una llamada a la función getBlue() recién creada, e imprime una sentencia con las propiedades del color. Añade estas sentencias al final del archivo:

const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);const favoriteColor = colors.getBlue();console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Guarda y sal del archivo.

El código ahora utiliza la función getBlue() recién creada. Ejecute el archivo como antes:

node index.js

Obtendrá una salida como:

Output
You should use brightred on your website. It's HTML code is #E74C3CMy favorite color is skyblue/#5DADE2, btw

Su script ha podido utilizar la última función de su módulo colors, sin tener que ejecutar npm update. Esto facilitará la realización de cambios en esta aplicación en el desarrollo.

A medida que escriba aplicaciones más grandes y complejas, piense en cómo se puede agrupar el código relacionado en módulos, y cómo quiere que se configuren estos módulos. Si su módulo sólo va a ser utilizado por un programa, puede permanecer dentro del mismo proyecto y ser referenciado por una ruta relativa. Si su módulo va a ser compartido más tarde por separado o existe en una ubicación muy diferente del proyecto en el que está trabajando ahora, instalar o enlazar podría ser más viable. Los módulos en desarrollo activo también se benefician de las actualizaciones automáticas de la vinculación. Si el módulo no está en desarrollo activo, usar npm install puede ser la opción más fácil.

Conclusión

En este tutorial, aprendiste que un módulo Node.js es un archivo JavaScript con funciones y objetos que pueden ser usados por otros programas. Luego creaste un módulo y adjuntaste tus funciones y objetos al objeto global exports para que estén disponibles para programas externos. Finalmente, importaste ese módulo en un programa, demostrando cómo los módulos se unen en aplicaciones más grandes.

Ahora que sabes cómo crear módulos, piensa en el tipo de programa que quieres escribir y divídelo en varios componentes, manteniendo cada conjunto único de actividades y datos en sus propios módulos. Cuanta más práctica obtengas escribiendo módulos, mejor será tu capacidad para escribir programas Node.js de calidad en tu viaje de aprendizaje. Para trabajar a través de un ejemplo de una aplicación Node.js que utiliza módulos, vea nuestro tutorial Cómo configurar una aplicación Node.js para producción en Ubuntu 18.04.