Llamar a una función “local” dentro de module.exports desde otra función en module.exports?

¿Cómo se llama una función desde dentro de otra función en una statement 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 dentro de la bar funciones, y estoy obteniendo:

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() a module.exports.foo() y parece estar funcionando.

Si alguien tiene un método mejor o más adecuado, no dude en corregirme.

Puede 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 hacer esto para hacerlo más conciso y legible. Esto es lo que he visto hacer en varios de los módulos abiertos bien escritos:

 var self = module.exports = { foo: function (req, res, next) { return ('foo'); }, bar: function(req, res, next) { self.foo(); } } 

También puede guardar una referencia al scope global del módulo fuera de la definición (modules) exports.somemodule:

 var _this = this; exports.somefunction = function() { console.log('hello'); } exports.someotherfunction = function() { _this.somefunction(); } 

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. A continuación, puede exportar esa variable y está listo para comenzar.

 var self = { foo: function (req, res, next) { return ('foo'); }, bar: function (req, res, next) { return self.foo(); } }; module.exports = self; 
 const Service = { foo: (a, b) => a + b, bar: (a, b) => Service.foo(a, b) * b } module.exports = Service 

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 instanciará la clase solo una vez, debido al almacenamiento en caché del módulo de Node:
https://nodejs.org/api/modules.html#modules_caching

Para solucionar su problema, he realizado 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()); 
 module.exports = function (){ return{ adding: function(a ,b){ return a+b; }, test: function () { adding(a, b); } } 

}

¿Puedo saber cómo acceder a la función “agregar” desde “prueba”?