Node.js
Exportando y consumiendo módulos
Buscar..
Observaciones
Mientras que todo en Node.js generalmente se hace de forma asíncrona, require() no es una de esas cosas. Como los módulos en la práctica solo necesitan cargarse una vez, es una operación de bloqueo y deben usarse correctamente.
Los módulos se almacenan en caché después de la primera vez que se cargan. Si está editando un módulo en desarrollo, deberá eliminar su entrada en la memoria caché del módulo para poder utilizar nuevos cambios. Dicho esto, incluso si un módulo se borra de la memoria caché del módulo, el módulo en sí no se recolecta como basura, por lo que se debe tener cuidado para su uso en entornos de producción.
Cargando y utilizando un módulo
Un módulo puede ser "importado", o de lo contrario "requerido" por la función require() . Por ejemplo, para cargar el módulo http que se envía con Node.js, se puede usar lo siguiente:
const http = require('http');
Aparte de los módulos que se envían con el tiempo de ejecución, también puede requerir módulos que haya instalado desde npm, como Express. Si ya había instalado Express en su sistema a través de npm install express , simplemente podría escribir:
const express = require('express');
También puede incluir módulos que haya escrito usted mismo como parte de su aplicación. En este caso, para incluir un archivo llamado lib.js en el mismo directorio que el archivo actual:
const mylib = require('./lib');
Tenga en cuenta que puede omitir la extensión, y se asumirá .js . Una vez que carga un módulo, la variable se llena con un objeto que contiene los métodos y las propiedades publicadas desde el archivo requerido. Un ejemplo completo:
const http = require('http');
// The `http` module has the property `STATUS_CODES`
console.log(http.STATUS_CODES[404]); // outputs 'Not Found'
// Also contains `createServer()`
http.createServer(function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<html><body>Module Test</body></html>');
res.end();
}).listen(80);
Creando un módulo hello-world.js
Node proporciona la interfaz module.exports para exponer funciones y variables a otros archivos. La forma más sencilla de hacerlo es exportar solo un objeto (función o variable), como se muestra en el primer ejemplo.
hola-mundo.js
module.exports = function(subject) {
console.log('Hello ' + subject);
};
Si no queremos que la exportación completa sea un solo objeto, podemos exportar funciones y variables como propiedades del objeto de exports . Los tres ejemplos siguientes demuestran esto de maneras ligeramente diferentes:
- hello-venus.js: la definición de la función se realiza por separado y luego se agrega como una propiedad de
module.exports - hello-jupiter.js: las definiciones de funciones se ponen directamente como el valor de las propiedades de
module.exports - hello-mars.js: la definición de la función se declara directamente como una propiedad de las
exportsque es una versión corta demodule.exports
hola-venus.js
function hello(subject) {
console.log('Venus says Hello ' + subject);
}
module.exports = {
hello: hello
};
hola-jupiter.js
module.exports = {
hello: function(subject) {
console.log('Jupiter says hello ' + subject);
},
bye: function(subject) {
console.log('Jupiter says goodbye ' + subject);
}
};
hola-mars.js
exports.hello = function(subject) {
console.log('Mars says Hello ' + subject);
};
Módulo de carga con nombre de directorio
Tenemos un directorio llamado hello que incluye los siguientes archivos:
index.js
// hello/index.js
module.exports = function(){
console.log('Hej');
};
main.js
// hello/main.js
// We can include the other files we've defined by using the `require()` method
var hw = require('./hello-world.js'),
hm = require('./hello-mars.js'),
hv = require('./hello-venus.js'),
hj = require('./hello-jupiter.js'),
hu = require('./index.js');
// Because we assigned our function to the entire `module.exports` object, we
// can use it directly
hw('World!'); // outputs "Hello World!"
// In this case, we assigned our function to the `hello` property of exports, so we must
// use that here too
hm.hello('Solar System!'); // outputs "Mars says Hello Solar System!"
// The result of assigning module.exports at once is the same as in hello-world.js
hv.hello('Milky Way!'); // outputs "Venus says Hello Milky Way!"
hj.hello('Universe!'); // outputs "Jupiter says hello Universe!"
hj.bye('Universe!'); // outputs "Jupiter says goodbye Universe!"
hu(); //output 'hej'
Invalidando el caché del módulo
En el desarrollo, es posible que el uso de require() en el mismo módulo varias veces siempre devuelva el mismo módulo, incluso si ha realizado cambios en ese archivo. Esto se debe a que los módulos se almacenan en caché la primera vez que se cargan, y cualquier carga subsiguiente del módulo se cargará desde el caché.
Para solucionar este problema, tendrá que delete la entrada en el caché. Por ejemplo, si has cargado un módulo:
var a = require('./a');
A continuación, podría eliminar la entrada de caché:
var rpath = require.resolve('./a.js');
delete require.cache[rpath];
Y luego volver a requerir el módulo:
var a = require('./a');
Tenga en cuenta que esto no se recomienda en producción porque la delete solo eliminará la referencia al módulo cargado, no los datos cargados en sí. El módulo no se recolecta en la basura, por lo que el uso incorrecto de esta función podría provocar una pérdida de memoria.
Construyendo tus propios módulos.
También puede hacer referencia a un objeto para exportar públicamente y agregar continuamente métodos a ese objeto:
const auth = module.exports = {}
const config = require('../config')
const request = require('request')
auth.email = function (data, callback) {
// Authenticate with an email address
}
auth.facebook = function (data, callback) {
// Authenticate with a Facebook account
}
auth.twitter = function (data, callback) {
// Authenticate with a Twitter account
}
auth.slack = function (data, callback) {
// Authenticate with a Slack account
}
auth.stack_overflow = function (data, callback) {
// Authenticate with a Stack Overflow account
}
Para usar cualquiera de estos, solo necesita el módulo como lo haría normalmente:
const auth = require('./auth')
module.exports = function (req, res, next) {
auth.facebook(req.body, function (err, user) {
if (err) return next(err)
req.user = user
next()
})
}
Cada módulo inyectado solo una vez.
NodeJS ejecuta el módulo solo la primera vez que lo requiera. Cualquier otra función requerida volverá a utilizar el mismo Objeto, por lo que no ejecutará el código en el módulo otra vez. Además, Node almacena en caché los módulos la primera vez que se cargan utilizando require. Esto reduce el número de lecturas de archivos y ayuda a acelerar la aplicación.
myModule.js
console.log(123) ;
exports.var1 = 4 ;
index.js
var a=require('./myModule') ; // Output 123
var b=require('./myModule') ; // No output
console.log(a.var1) ; // Output 4
console.log(b.var1) ; // Output 4
a.var2 = 5 ;
console.log(b.var2) ; // Output 5
Módulo cargando desde node_modules
Los módulos pueden require d sin usar rutas relativas colocándolos en un directorio especial llamado node_modules .
Por ejemplo, para require un módulo llamado foo desde un archivo index.js , puede usar la siguiente estructura de directorios:
index.js
\- node_modules
\- foo
|- foo.js
\- package.json
Los módulos se deben colocar dentro de un directorio, junto con un archivo package.json . El campo main del archivo package.json debe apuntar al punto de entrada de su módulo: este es el archivo que se importa cuando los usuarios lo require('your-module') . main valores predeterminados main index.js si no se proporcionan. Como alternativa, puede hacer referencia a los archivos relativos a su módulo, simplemente añadiendo el recorrido relativo al require llamada: require('your-module/path/to/file') .
Los módulos también pueden require desde los directorios de node_modules hasta la jerarquía del sistema de archivos. Si tenemos la siguiente estructura de directorios:
my-project
\- node_modules
|- foo // the foo module
\- ...
\- baz // the baz module
\- node_modules
\- bar // the bar module
podremos require el módulo foo desde cualquier archivo dentro de la bar usando require('foo') .
Tenga en cuenta que el nodo solo coincidirá con el módulo más cercano al archivo en la jerarquía del sistema de archivos, comenzando desde (el directorio actual del archivo / node_modules). El nodo coincide con los directorios de esta manera hasta la raíz del sistema de archivos.
Puede instalar nuevos módulos desde el registro npm u otros registros npm, o puede crear los suyos propios.
Carpeta como modulo
Los módulos se pueden dividir en muchos archivos .js en la misma carpeta. Un ejemplo en una carpeta my_module :
function_one.js
module.exports = function() {
return 1;
}
function_two.js
module.exports = function() {
return 2;
}
index.js
exports.f_one = require('./function_one.js');
exports.f_two = require('./function_two.js');
Un módulo como este se usa refiriéndose a él por el nombre de la carpeta:
var split_module = require('./my_module');
Tenga en cuenta que si lo requirió omitiendo ./ o cualquier indicación de una ruta a una carpeta desde el argumento de la función requerida, Node intentará cargar un módulo desde la carpeta node_modules .
Alternativamente, puede crear en la misma carpeta un archivo package.json con estos contenidos:
{
"name": "my_module",
"main": "./your_main_entry_point.js"
}
De esta manera, no es necesario que nombre el archivo de módulo principal "índice".