Cómo crear un módulo Node.js

Introducción

En Node.js, un módulo es una colección de funciones y objetos de JavaScript que pueden ser utilizados por aplicaciones externas. Cualquier archivo Node.js o colección de archivos puede considerarse un módulo si sus funciones y datos se pueden utilizar mediante programas externos.

Poder escribir módulos que exporten funciones y datos útiles te permitirá contribuir a la comunidad Node.js, de hecho, todos los paquetes que usas en npm han sido agrupados 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á un módulo Node.js que sugiere qué color deben usar los desarrolladores web en sus proyectos. Desarrollará el módulo almacenando los colores como una matriz y proporcionando una función para recuperar uno al azar. A continuación, veremos varias formas de importar un módulo a una aplicación Node.js.

Prerrequisitos

Necesitará Node.js y NPM instalados en su entorno de desarrollo, siga uno de los siguientes tutoriales según su sistema operativo:

Paso 1: crea un formulario

Este paso lo guiará a través de la creación de su primer módulo Node.js. El módulo contendrá una colección de colores en una matriz y proporcionará una función para obtener uno al azar. Utilizará la exports integrada en Node.js para que la función y la matriz estén disponibles para programas externos.

Primero, comenzará por decidir qué datos de color se almacenarán en el formulario. Cada color será un objeto que contiene una name que puede identificar fácilmente y una 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 le permiten cambiar el color de los elementos de una página web. Puede obtener más información sobre los códigos de color HTML leyendo este artículo. Códigos de color y nombres HTML.

Luego, decidirá qué colores desea admitir en su forma. Su módulo contendrá una matriz llamada allColors que contendrá seis colores. El módulo también incluirá una función llamada getRandomColor() que seleccionará aleatoriamente un color de la matriz y lo devolverá.

En su terminal, cree una nueva carpeta llamada colors y muévase a ella:

mkdir colors

cd colors

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

npm init -y

Usó el -y para omitir las instrucciones habituales para personalizar su package.json. Si es un formulario que quieres publicar en npm, debes contestar todas estas instrucciones con los datos relevantes.

En este caso, la salida será:

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

Ahora, abra un editor de texto de línea de comando como nano y cree un nuevo archivo para usarlo como punto de entrada para su módulo:

nano index.js

Primero, defina una clase de Color Se Color con su nombre y código HTML. Agregue las siguientes líneas para crear la clase:

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

Ahora que tiene su estructura de datos para Color, agregue algunas instancias en su formulario. Escriba la siguiente matriz resaltada en su archivo:

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

 const allColors = [
 new Color('brightred', '#E74C3C'),
 new Color('soothingpurple', '#9B59B6'),
 new Color('skyblue', '#5DADE2'),
 new Color('leafygreen', '#48C9B0'),
 new Color('sunkissedyellow', '#F4D03F'),
 new Color('groovygray', '#D7DBDD'),
 ];

Finalmente, inserte una función que seleccione aleatoriamente un elemento de la allColors

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

 const allColors = [
 new Color('brightred', '#E74C3C'),
 new Color('soothingpurple', '#9B59B6'),
 new Color('skyblue', '#5DADE2'),
 new Color('leafygreen', '#48C9B0'),
 new Color('sunkissedyellow', '#F4D03F'),
 new Color('groovygray', '#D7DBDD'),
 ];

 exports.getRandomColor = () => {
 return allColors[Math.floor(Math.random() * allColors.length)];
 }

 exports.allColors = allColors;

La exports refiere a un objeto global disponible en cada módulo de Node.js. Todas las funciones y objetos almacenados en exports se exponen cuando otros módulos de Node.js lo importan. La función getRandomColor() se creó directamente en el objeto de exports Luego agregamos una propiedad allColors exports que hace referencia a la allColors creada anteriormente en el script.

Cuando otros módulos importen este módulo, allColors y 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 aleatorio. También ha exportado la matriz y la función, por lo que los programas externos pueden usarlas. En el siguiente paso, utilizará su módulo en otras aplicaciones para demostrar los efectos de la export.

Paso 2: prueba el formulario con REPL

Antes de crear una aplicación completa, tómese un momento para confirmar que su formulario está funcionando. En este paso, se utilizará REPL para cargar el módulo de colors Mientras estamos en REPL, llamaremos a la función getRandomColor() para ver si se comporta como se esperaba.

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

node

Cuando se haya iniciado REPL, se mostrará > Esto significa que puede ingresar código JavaScript que será evaluado inmediatamente.

Primero, ingrese lo siguiente:

colors = require('./index');

En este comando, require() carga el colors en su punto de entrada. Cuando presione ENTER, obtendrá el siguiente resultado:

{
 getRandomColor: [Function],
 allColors: [
 Color { name: 'brightred', code: '#E74C3C' },
 Color { name: 'soothingpurple', code: '#9B59B6' },
 Color { name: 'skyblue', code: '#5DADE2' },
 Color { name: 'leafygreen', code: '#48C9B0' },
 Color { name: 'sunkissedyellow', code: '#F4D03F' },
 Color { name: 'groovygray', code: '#D7DBDD' }
 ]
 }

El REPL nos muestra el valor de los colors, que son todas las funciones y objetos importados del archivo index.js Cuando se usa la require, Node.js devuelve todo el contenido dentro del exports de un módulo.

Recuerde que agregó getRandomColor() y allColors a las exports en el módulo de colors Por esta razón, ambos aparecen en el REPL cuando se importan.

Pruebe la función getRandomColor():

colors.getRandomColor();

Se le mostrará un color aleatorio:

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

Dado que el índice es aleatorio, la salida puede variar. Ahora que ha confirmado que el colors está funcionando, salga del REPL de Node.js:

.exit

Esto lo llevará de regreso a la línea de comandos de su terminal.

Acaba de confirmar que su formulario funciona como se esperaba usando 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: guarde el módulo local como una dependencia

Al probar el módulo en REPL, se importó con una ruta relativa. Esto significa que usó la ubicación del index.js relativa al directorio de trabajo para obtener su contenido. Por lo general, es conveniente importar módulos con sus nombres para que la importación no se interrumpa cuando se cambia el contexto. En este paso, instalará el colors con la función npm install local module.

Configure un nuevo módulo Node.js fuera de la carpeta de colors Primero, vaya al directorio anterior y cree una nueva carpeta:

cd..

mkdir really-large-application

Ahora cambie a su nuevo proyecto:

cd really-large-application

Al igual que con el colors, inicialice su carpeta con npm:

npm init -y

package.json se generará a continuación:

{
 "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 instale su colors y use la --save para que quede registrado en su archivo package.json

npm install --save../colors

Acaba de instalar su colors en el nuevo proyecto. Abra el package.json para ver la nueva dependencia local:

nano package.json

Verá que se han agregado 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 colors se ha copiado en su directorio node_modules Verifique que esté allí con el siguiente comando:

ls node_modules

Esto dará el siguiente resultado:

colors

Utilice el 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 de colors Luego elegirá un color aleatorio usando la función getRandomColor() proporcionada por el módulo. Finalmente, imprimirá un mensaje en la consola que le indicará al usuario qué color usar.

Inserte 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}`);

Guardar y salir del 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 se verá así:

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

Ahora ha instalado con éxito el colors y puede manejarlo como cualquier otro paquete npm utilizado en su proyecto. Sin embargo, si ha agregado más colores y funciones a su colors, debe ejecutar npm update en sus aplicaciones para poder usar las nuevas opciones. En el siguiente paso, utilizará el colors locales de otra manera y obtendrá actualizaciones automáticas cuando cambie el código del módulo.

Paso 4: conecte un módulo local

Si su módulo local se encuentra en un desarrollo intenso, la actualización continua de paquetes puede resultar tediosa. Una alternativa sería conectar los módulos. Vincular un módulo garantiza que cualquier actualización del módulo se refleje inmediatamente en las aplicaciones que lo utilizan.

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

Primero, desinstale el módulo local:

npm un colors

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

Creando un enlace global al módulo. npm crea un enlace simbólico entre su node_modules y su directorio de módulo. node_modules directorio global node_modules es la ubicación donde se instalan todos los paquetes npm de todo el sistema (cualquier paquete instalado con el -g ).
Crea un enlace local. npm crea un enlace simbólico entre el proyecto local que usa el módulo y el enlace global del módulo.

Primero, cree el enlace global volviendo a la colors y usando el comando de link

cd../colors

sudo npm link

Una vez completado, su caparazón producirá:

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

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

Regrese a la really-large-application y vincule el paquete:

cd../really-large-application

sudo npm link colors

Recibirá un resultado similar al siguiente:

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

Notalnlinknpm ln colors

Como muestra el resultado, acaba de crear un enlace simbólico desde la aplicación really-large-application en el directorio node_modules al enlace simbólico de colors node_modules globales, apuntando al directorio real con el módulo de colors

El proceso de vinculación está completo. Ejecute su archivo para asegurarse de que aún funcione:

node index.js

Su salida se verá así:

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

La funcionalidad del programa está intacta. A continuación, verifique que las actualizaciones se apliquen de inmediato. En su editor de texto, vuelva a abrir el index.js en el módulo de colors

cd../colors

nano index.js

Ahora agregue una función que seleccione el mejor tono de azul existente. No toma argumentos y siempre devuelve el tercer elemento de la matriz allColors Agregue estas líneas al final del archivo:

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

 const allColors = [
 new Color('brightred', '#E74C3C'),
 new Color('soothingpurple', '#9B59B6'),
 new Color('skyblue', '#5DADE2'),
 new Color('leafygreen', '#48C9B0'),
 new Color('sunkissedyellow', '#F4D03F'),
 new Color('groovygray', '#D7DBDD'),
 ];

 exports.getRandomColor = () => {
 return allColors[Math.floor(Math.random() * allColors.length)];
 }

 exports.allColors = allColors;

 exports.getBlue = () => {
 return allColors[2];
 }

Guarde y salga del archivo, luego vuelva a abrir el index.js en la carpeta de la really-large-application

cd../really-large-application

nano index.js

Realice una llamada a la getBlue() e imprima una oración con propiedades de color. Agregue estas instrucciones 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`);

Guardar y salir del archivo.

El código ahora usa la nueva función de compilación getBlue(). Ejecute el archivo como antes:

node index.js

Obtendrá una salida como:

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

Su secuencia de comandos pudo usar la última función en su colors, sin tener que ejecutar npm update. Esto facilitará la realización de cambios en esta aplicación en desarrollo.

A medida que escribe aplicaciones más grandes y complejas, piense en cómo agrupar el código relacionado en módulos y cómo desea que se configuren estos módulos. Si su módulo será utilizado por un solo programa, puede permanecer dentro del mismo proyecto y ser referenciado por una ruta relativa. Si el módulo se compartirá más adelante por separado o existe en una ubicación muy diferente del proyecto en el que está trabajando ahora, la instalación o la vinculación pueden ser más viables. Los módulos de desarrollo activos también se benefician de las actualizaciones automáticas de enlaces. Si el módulo no está en desarrollo activo, usar npm install puede ser la opción más simple.

Conclusión

En este tutorial, aprendió que un módulo Node.js es un archivo JavaScript con funciones y objetos que pueden ser utilizados por otros programas. Luego creamos un módulo y vinculamos las funciones y los objetos al exports para que estén disponibles para programas externos. Finalmente, importó ese módulo a un programa, demostrando cómo los módulos se fusionan en aplicaciones más grandes.