en programación, los módulos son unidades autónomas de funcionalidad que se pueden compartir y reutilizar entre proyectos. Hacen nuestra vida como desarrolladores más fácil, ya que podemos usarlos para aumentar nuestras aplicaciones con funcionalidades que no hemos tenido que escribir nosotros mismos. También nos permiten organizar y desacoplar nuestro código, lo que conduce a aplicaciones que son más fáciles de entender, depurar y mantener.
en este artículo, examinaré cómo trabajar con módulos en Node.JS, centrándose en cómo exportarlos y consumirlos.,
diferentes formatos de módulo
como JavaScript originalmente no tenía un concepto de Módulos, una variedad de formatos competidores han surgido con el tiempo. Aquí hay una lista de los principales a tener en cuenta:
- El formato de definición de módulo asíncrono (AMD) Se utiliza en los navegadores y utiliza una función
definepara definir módulos. - El formato CommonJS (CJS) se utiliza en Node.js y utiliza
requireymodule.exportspara definir dependencias y módulos. El ecosistema npm se basa en este formato. - El formato del módulo ES (ESM)., A partir de ES6 (ES2015), JavaScript admite un formato de módulo nativo. Utiliza una palabra clave
exportpara exportar la API pública de un módulo y una palabra claveimportpara importarla. - El Sistema.el formato de registro fue diseñado para soportar módulos ES6 dentro de ES5.
- El formato de definición de módulo Universal (UMD) se puede utilizar tanto en el navegador como en el nodo.js. Es útil cuando un módulo necesita ser importado por varios cargadores de módulos diferentes.
tenga en cuenta que este artículo trata únicamente del formato CommonJS, el estándar en Node.js., Si quieres leer en cualquiera de los otros formatos, te recomiendo este artículo, del autor de SitePoint Jurgen Van de Moere.
requiere un módulo
nodo.js viene con un conjunto de módulos integrados que podemos utilizar en nuestro código sin tener que instalarlos. Para hacer esto, necesitamos requerir el módulo usando la palabra clave require y asignar el resultado a una variable. Esto se puede usar para invocar cualquier método que el módulo exponga.,
por ejemplo, para enumerar el contenido de un directorio, puede usar el módulo del sistema de archivos y su método readdir:
tenga en cuenta que en CommonJS, los módulos se cargan de forma sincrónica y se procesan en el orden en que ocurren.
crear y exportar un módulo
ahora veamos cómo crear nuestro propio módulo y exportarlo para usarlo en otro lugar de nuestro programa., Comienza por la creación de un user.js archivo y agregar la siguiente:
const getName = () => { return 'Jim';};exports.getName = getName;Ahora crear un index.js archivo en la misma carpeta y añadir esto:
const user = require('./user');console.log(`User: ${user.getName()}`);Ejecute el programa con node index.js y usted debería ver el resultado siguiente en la terminal:
User: JimEntonces, ¿qué ha pasado aquí?, Bueno, si miras el archivo user.js, notarás que estamos definiendo una función getName, luego usaremos la palabra clave exports para que esté disponible para importar en otro lugar. Luego, en el archivo index.js, estamos importando esta función y ejecutándola. También tenga en cuenta que en la instrucción require, el nombre del módulo tiene el prefijo ./, ya que es un archivo local. También tenga en cuenta que no es necesario agregar la extensión de archivo.,
Exportar Múltiples Métodos y Valores
podemos exportar varios métodos y valores de la misma manera:
Y en el index.js:
const user = require('./user');console.log( `${user.getName()} lives in ${user.getLocation()} and was born on ${user.dob}.`);El código anterior produce esto:
Jim lives in Munich and was born on 12.01.1982.Observe cómo el nombre que damos a la exportado dateOfBirth variable puede ser cualquier cosa que nos apetece (dob en este caso). No tiene que ser el mismo que el nombre de la variable original.,
variaciones en la sintaxis
También debo mencionar que es posible exportar métodos y valores sobre la marcha, no solo al final del archivo.
Por ejemplo:
exports.getName = () => { return 'Jim';};exports.getLocation = () => { return 'Munich';};exports.dob = '12.01.1982';Y gracias a la desestructuración de la asignación, podemos cherry-pick lo que desea importar:
const { getName, dob } = require('./user');console.log( `${getName()} was born on ${dob}.`);Como era de esperar, esta registros:
Jim was born on 12.01.1982.Exportar un Valor Predeterminado
En el ejemplo anterior, estamos exportando funciones y valores de forma individual., Esto es útil para funciones auxiliares que podrían necesitarse en toda una aplicación, pero cuando tiene un módulo que exporta solo una cosa, es más común usar module.exports:
y en index.js:
const User = require('./user');const jim = new User('Jim', 37, '[email protected]');console.log(jim.getUserStats());el código anterior registra esto:
Name: JimAge: 37Email: [email protected]Cuál es la diferencia entre el módulo.¿exportaciones y exportaciones?,
en sus viajes por la Web, puede encontrar la siguiente sintaxis:
module.exports = { getName: () => { return 'Jim'; }, getLocation: () => { return 'Munich'; }, dob: '12.01.1982',};Aquí estamos asignando las funciones y valores que queremos exportar a una propiedad exports En module — y por supuesto, esto funciona bien:/p>
const { getName, dob } = require('./user');console.log( `${getName()} was born on ${dob}.`);esto registra lo siguiente:
Jim was born on 12.01.1982.entonces, ¿cuál es la diferencia entre module.exports y exports? ¿Es uno solo un alias útil para el otro?,
Bueno, un poco, pero no del todo …
Para ilustrar lo que quiero decir, vamos a cambiar el código en el index.js para registrar el valor de module:
console.log(module);Esto produce:
Como puede ver, el module tiene un exports propiedad. Vamos a añadir algo a esto:
// index.jsexports.foo = 'foo';console.log(module);Esta salida es:
Module { id: '.', exports: { foo: 'foo' }, ...Asignación de propiedades exports también añade a module.exports., Esto se debe a que (inicialmente, al menos) exports es una referencia a module.exports.
Entonces, ¿cuál debo usar?
As module.exports and exports both point to the same object, it doesn’t normally matter which you use. Por ejemplo:
exports.foo = 'foo';module.exports.bar = 'bar';Este código daría como resultado que el objeto exportado del módulo fuera{ foo: 'foo', bar: 'bar' }.
sin Embargo, hay una advertencia. Lo que le asigne module.exports es lo que se exporta desde su módulo.,
por lo tanto, tome lo siguiente:
exports.foo = 'foo';module.exports = () => { console.log('bar'); };esto solo resultaría en una función anónima exportada. La variable foo sería ignorada.
si quieres leer más sobre la diferencia, te recomiendo este artículo.
conclusión
Los módulos se han convertido en una parte integral del ecosistema JavaScript, lo que nos permite componer programas grandes a partir de partes más pequeñas. Espero que este artículo le haya dado una buena introducción a trabajar con ellos en Node.js, además de ayudar a desmitificar su sintaxis.