world tutorial proyecto node how hello framework crear node.js express

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