node.js - tutorial - Llame a una función "local" dentro de module.exports desde otra función en module.exports?
node.js express framework exploit (8)
¿Cómo llamar a una función desde dentro de otra función en una declaración module.exports
?
Aquí hay un código simplificado.
En mi app.js, hago lo siguiente:
var bla = require(''./bla.js'');
console.log(bla.bar());
y dentro de bla.js es
module.exports = {
foo: function (req, res, next) {
return (''foo'');
},
bar: function(req, res, next) {
this.foo();
}
}
Estoy intentando acceder a la función foo
desde la bar
funciones, y obtengo:
TypeError: Object # has no method ''foo''
Si cambio this.foo()
a solo foo()
obtengo:
ReferenceError: foo is not defined
Creo que lo tengo. Acabo de cambiar this.foo()
por module.exports.foo()
y parece estar funcionando.
Si alguien tiene un método mejor o más adecuado, no dude en corregirme.
En NodeJs seguí este enfoque:
class MyClass {
constructor() {}
foo(req, res, next) {
return (''foo'');
}
bar(req, res, next) {
this.foo();
}
}
module.exports = new MyClass();
Esto creará una instancia de la clase solo una vez, debido al almacenamiento en caché del módulo de Node:
https://nodejs.org/api/modules.html#modules_caching
Otra opción, y más cercana al estilo original del OP, es colocar el objeto que desea exportar en una variable y hacer referencia a esa variable para hacer llamadas a otros métodos en el objeto. Luego puedes exportar esa variable y listo.
var self = {
foo: function (req, res, next) {
return (''foo'');
},
bar: function (req, res, next) {
return self.foo();
}
};
module.exports = self;
Para solucionar su problema, he hecho algunos cambios en bla.js y está funcionando,
var foo= function (req, res, next) {
console.log(''inside foo'');
return ("foo");
}
var bar= function(req, res, next) {
this.foo();
}
module.exports = {bar,foo};
y ninguna modificación en app.js
var bla = require(''./bla.js'');
console.log(bla.bar());
Podría declarar sus funciones fuera del bloque module.exports.
var foo = function (req, res, next) {
return (''foo'');
}
var bar = function (req, res, next) {
return foo();
}
Entonces:
module.exports = {
foo: foo,
bar: bar
}
También puede guardar una referencia al alcance global del módulo fuera de la definición del módulo ().
var _this = this;
exports.somefunction = function() {
console.log(''hello'');
}
exports.someotherfunction = function() {
_this.somefunction();
}
También puede hacer esto para hacerlo más conciso y legible. Esto es lo que he visto hacer en varios de los módulos de código abierto bien escritos:
var self = module.exports = {
foo: function (req, res, next) {
return (''foo'');
},
bar: function(req, res, next) {
self.foo();
}
}
const Service = {
foo: (a, b) => a + b,
bar: (a, b) => Service.foo(a, b) * b
}
module.exports = Service