Cómo crear un módulo Node.js

El autor seleccionó a 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 un conjunto de funciones y objetos de JavaScript que las aplicaciones externas pueden usar. La descripción de un fragmento de código como módulo se refiere menos a lo que es el código que a lo que hace; cualquier archivo de Node.js o colección de archivos puede considerarse un módulo si sus funciones y datos se pueden utilizar en programas externos.

Debido a que los módulos proporcionan unidades de funciones que pueden reutilizarse en muchos programas más grandes, permiten crear aplicaciones acopladas libremente que se adaptan a la complejidad y que pueda compartir su código con otros desarrolladores. Ser capaz de escribir módulos que exporten funciones y datos útiles, le permitirá hacer aportes a la comunidad de Node.js más amplia. De hecho, todos los paquetes que utilice en npm se agrupan y se comparten como módulos. Esto hace que crear módulos sea una habilidad esencial para un desarrollador de Node.js.

A través de este tutorial, creará un módulo de Node.js que sugerirá el color que deben usar los desarrolladores web en sus diseños. Podrá desarrollar el módulo almacenando los colores en una matriz y proporcionando una función para recuperar uno de forma aleatoria. Después, veremos varias formas de importar un módulo en una aplicación de Node.js.

Requisitos previos

• Necesitará tener instalados Node.js y npm en su entorno de desarrollo. En este tutorial, se utiliza la versión 10.17.0. Para instalarlo en macOS o Ubuntu 18.04, siga los pasos de Cómo instalar Node.js y crear un entorno de desarrollo local en macOS o las indicaciones de la sección Instalación con un PPA, de Cómo instalar Node.js en Ubuntu 18.04. Si tiene Node.js instalado también tendrá npm instalado; en este tutorial se utiliza la versión 6.11.3.
• También debería estar familiarizado con el archivo package.json. Además, sería útil tener experiencia con los comandos de npm. Para obtener esta experiencia, consulte Cómo usar módulos de Node.js con npm y package.json, en particular el paso 1: Crear un archivo package.json.
• También resultará útil para sentirse a gusto con el REPL de Node.js (leer, evaluar, imprimir, repetir). Lo usará para probar su módulo. Si necesita más información sobre esto, consulte nuestra guía Cómo usar el REPL de Node.js.

Paso 1: Crear un módulo

Este paso lo guiará para crear su primer módulo de Node.js. Su módulo contendrá un grupo de colores en una matriz y proporcionará una función para obtener uno al azar. Usaremos la propiedad exports incorporada de Node.js para permitir que la función y la matriz estén disponibles para programas externos.

Primero, comenzaremos por decidir qué datos sobre colores se almacenarán en su módulo. Cada color será un objeto que contiene una propiedad name que los seres humanos pueden identificar fácilmente y una propiedad code, que es una string que contiene un código de color HTML. Los códigos de colores 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 colores HTML leyendo el artículo Códigos y nombres de colores HTML.

Luego, debe definir los colores que desea admitir en su módulo. Su módulo contendrá una matriz llamada allColors que contendrá seis colores. Su módulo también incluirá una función llamada getRandomColor() que seleccionará un color de su matriz de forma aleatoria y lo mostrará.

En su terminal, cree una nueva carpeta llamada colors y posiciónese en 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

Use el indicador -y para omitir las solicitudes habituales de personalización de su package.json. Si este fuera un módulo que desea publicar en npm, respondería a todas estas preguntas con datos pertinentes, como se explica en Cómo usar módulos de Node.js con npm y package.json.

En este caso, su resultado será el siguiente:

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, abra un editor de texto de línea de comandos como nano y cree un nuevo archivo para que sirva como punto de entrada para su módulo:

nano index.js

Su módulo hará algunas acciones. Primero, definirá una clase Color. Su clase Color se instalará con su nombre y código HTML. Añada las líneas siguientes para crear la clase:

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

Ahora que dispone de la estructura de datos para Color, añada algunas instancias a su módulo. 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'),
];

Por último, ingrese una función que seleccione de forma aleatoria un elemento de la matriz allColors que acaba de crear:

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 palabra clave exports hace referencia a un objeto global disponible en todos los módulos Node.js. Las funciones y los objetos almacenados en el objeto exports de un módulo, en su totalidad, quedan expuestos cuando otros módulos Node.js los importan. Por ejemplo, la función getRandomColor() se creó directamente en el objeto exports. Luego, añada una propiedad allColors al objeto exports que hace referencia a la matriz de constante local allColors creada anteriormente en la secuencia de comandos.

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

Guarde el archivo y ciérrelo.

Hasta ahora, creó un módulo que contiene una matriz de colores y una función que muestra uno de forma aleatoria. También exportó la matriz y la función para que los programas externos puedan usarlas. En el siguiente paso, usará su módulo en otras aplicaciones para demostrar los efectos de export.

Paso 2: Probar su módulo con REPL

Antes de crear una aplicación completa, tómese un momento para confirmar que su módulo funciona. En este paso, usará el REPL para cargar el módulo colors. Mientras se encuentra en el REPL, invoque la función getRandomColor() para ver si se comporta como se espera.

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

node

Cuando se inicie el REPL, verá el símbolo >. Esto significa que podrá ingresar el código JavaScript que se evaluará de inmediato. Si desea leer más sobre esto, siga nuestra guía sobre el uso de REPL.

Primero, ingrese lo siguiente:

colors = require('./index');

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

Output
{
  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 muestra el valor de colors, que son las funciones y los objetos importados del archivo index.js. Cuando utilice la palabra clave require, Node.js mostrará todos los contenidos dentro del objeto exports de un módulo.

Recuerde que añadió getRandomColor() y allColors a exports en el módulo colors. Por ese motivo, verá a ambos en el REPL cuando se importen.

En el símbolo del sistema, pruebe la función getRandomColor():

colors.getRandomColor();

Se le solicitará un color aleatorio:

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

Debido a que el índice es aleatorio, su resultado puede variar. Ahora que confirmó que el módulo colors está funcionando, cierre el REPL de Node.js

.exit

Con esto, regresará a la línea de comandos de su terminal.

Acaba de confirmar que su módulo funciona de la manera esperada usando el REPL. Luego, aplique estos mismos conceptos y cargue su módulo en una aplicación, como lo haría en un proyecto real.

Paso 3: Guardar su módulo local como dependencia

Al probar su módulo en el 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. Si bien esto funciona, normalmente la experiencia de programación es mejor si importa los módulos por sus nombres, de modo que la importación no se vea afectada cuando el contexto cambie. En este paso, instalará el módulo colors con la función install del módulo local de npm.

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

cd ..
mkdir really-large-application

Ahora, posiciónese en su nuevo proyecto:

cd really-large-application

Como en el caso del módulo colors, inicie su 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, instale su módulo colors y utilice el indicador --save para que se registre en su archivo package.json:

npm install --save ../colors

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

nano package.json

Verá que se agregaron 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"
  }
}

Cierre el archivo.

El módulo colors se copió a su directorio node_modules. Verifique que esté en él con el siguiente comando:

ls node_modules

Esto generará el siguiente resultado:

Output
colors

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

nano index.js

Su programa importará primero el módulo colors. Luego, elegirá un color de forma aleatoria usando la función getRandomColor() proporcionada por el módulo. Por último, imprimirá un mensaje en la consola que indicará al usuario el color que debe usar.

Introduzca 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 este archivo y ciérrelo.

Su aplicación ahora indicará al usuario una opción de color aleatorio para un componente del sitio web.

Ejecute esta secuencia de comandos con lo siguiente:

node index.js

El resultado será similar a este:

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

Con esto, habrá instalado con éxito el módulo colors y podrá administrarlo como cualquier otro paquete de npm utilizado en su proyecto. Sin embargo, si añadiera más colores y funciones a su módulo colors local, debería ejecutar npm update en sus aplicaciones para poder usar las nuevas opciones. En el siguiente paso, usará el módulo local colors de otra forma y obtendrá actualizaciones automáticas cuando el código del módulo cambie.

Paso 4: Vincular un módulo local

Si su módulo local se encuentra en pleno desarrollo, actualizar los paquetes de forma continua puede ser tedioso. Una alternativa sería vincular los módulos. Vincular un módulo garantiza que cualquier actualización al módulo se refleje de inmediato en las aplicaciones que lo utilizan.

En este paso, vinculará el módulo colors a su aplicación. También modificará el módulo colors y confirmará que sus cambios más recientes funcionen en la aplicación sin tener que volver a instalarla o actualizarla.

Primero, desinstale su módulo local:

npm un colors

npm vincula los módulos usando enlaces simbólicos (o symlinks), que son referencias que apuntan a archivos o directorios de 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 symlink entre su directorio node_modules global y el directorio de su módulo. El directorio node_modules global es la ubicación en la que se instalan todos los paquetes npm en el nivel del sistema (cualquier paquete que instale con el indicador -g).
2. Crear un enlace local. npm crea un symlink entre el proyecto local que utiliza el módulo y el enlace global del módulo.

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

cd ../colors
sudo npm link

Una vez que haga esto, su shell mostrará lo siguiente:

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

Acaba de crear en su carpeta node_modules un symlink a su directorio colors.

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

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

Obtendrá un resultado similar al siguiente:

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

Como muestra el resultado, acaba de crear un symlink desde su directorio node_modules local de really-large-application​​ al symlink colors en su node_modules global, que apunta al directorio real con el módulo colors.

El proceso de enlace está completo. Ejecute su archivo para garantizar que aún funcione:

node index.js

El resultado será similar a este:

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

La funcionalidad de su programa está intacta. Luego, compruebe que las actualizaciones se apliquen de inmediato. En su editor de texto, vuelva a abrir el archivo index.js en el módulo colors:

cd ../colors
nano index.js

Ahora, agregue una función que seleccione el mejor tono de azul que existe. No toma argumentos y siempre muestra el tercer elemento de la matriz allColors. Añada 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 cierre el archivo, y luego vuelva a abrir el archivo index.js en la carpeta really-large-application:

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

Invoque la función getBlue() recientemente creada e imprima una frase con las propiedades de color. Añada 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`);

Guarde el archivo y ciérrelo.

El código ahora utiliza la función getBlue() recientemente creada. Ejecute el archivo como lo hizo anteriormente:

node index.js

Obtendrá un resultado como este:

Output
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 módulo colors sin tener que ejecutar npm update. Esto hará que sea más fácil aplicar cambios a esta aplicación durante 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 desea que se configuren estos módulos. Si solo por un programa usará su módulo, puede permanecer dentro del mismo proyecto y una ruta relativa puede hacer referencia a él. Si su módulo se compartirá más tarde por separado o existe en una ubicación muy diferente del proyecto en el que trabaja ahora, la instalación o vinculación podría ser más viable. Los módulos en desarrollo activo también se benefician con las actualizaciones automáticas de vinculación. Si el módulo no se encuentra en desarrollo activo, usar npm install puede ser la opción más sencilla.

Conclusión

A lo largo de este tutorial, aprendió que un módulo de Node.js es un archivo de JavaScript con funciones y objetos que otros programas pueden usar. Luego, creó un módulo y adjuntó sus funciones y objetos al objeto exports global para que estén disponibles para programas externos. Por último, importó ese módulo en un programa y demostró que los módulos se agrupan en aplicaciones más grandes.

Ahora que sabe crear módulos, piense en el tipo de programa que desea escribir y divídalo en varios componentes, manteniendo cada conjunto únicos de actividades y datos en sus módulos. Cuanta más práctica tenga para la escritura de módulos, mayor será su capacidad para escribir programas de Node.js de calidad en su experiencia de aprendizaje. Para trabajar con un ejemplo de una aplicación de Node.js que use módulos, consulte nuestro tutorial Cómo configurar una aplicación de Node.js para producción en Ubuntu 18.04.