Wywołać funkcję „lokalną” w module.exports z innej funkcji w module.exports?

Jak wywołać funkcję z poziomu innej funkcji w module.exportsdeklaracji?

var bla = require('./bla.js');
console.log(bla.bar());

module.exports = {

  foo: function (req, res, next) {
    return ('foo');
  },

  bar: function(req, res, next) {
    this.foo();
  }

}

Próbuję uzyskać dostęp do funkcji fooz poziomu funkcji bari otrzymuję:

TypeError: Object # nie ma metody „foo”

Jeśli zmienię this.foo()tylko na foo():

ReferenceError: foo nie jest zdefiniowany

Zmień this.foo()namodule.exports.foo()

Możesz zadeklarować swoje funkcje poza module.exportsblokiem.

var foo = function (req, res, next) {
  return ('foo');
}

var bar = function (req, res, next) {
  return foo();
}

Następnie:

module.exports = {
  foo: foo,
  bar: bar
}

Możesz to również zrobić, aby uczynić go bardziej zwięzłym i czytelnym. Oto, co widziałem w kilku dobrze napisanych modułach open source:

var self = module.exports = {

  foo: function (req, res, next) {
    return ('foo');
  },

  bar: function(req, res, next) {
    self.foo();
  }

}

Można również zapisać odwołanie do globalnego zasięgu modułu poza definicją (module.) Exports.somemodule:

var _this = this;

exports.somefunction = function() {
   console.log('hello');
}

exports.someotherfunction = function() {
   _this.somefunction();
}

Inną opcją i bliższą oryginalnemu stylowi OP jest umieszczenie obiektu, który chcesz wyeksportować, w zmiennej i odwołanie się do tej zmiennej w celu wywołania innych metod w obiekcie. Następnie możesz wyeksportować tę zmienną i gotowe.

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

Począwszy od wersji 13 Node.js , możesz skorzystać z modułów ES6 .

export function foo() {
    return 'foo';
}

export function bar() {
    return foo();
}

Zgodnie z podejściem klasowym:

class MyClass {

    foo() {
        return 'foo';
    }

    bar() {
        return this.foo();
    }
}

module.exports = new MyClass();

Spowoduje to utworzenie instancji klasy tylko raz, ze względu na buforowanie modułu Node:
https://nodejs.org/api/modules.html#modules_caching

Aby rozwiązać problem, wprowadziłem kilka zmian w pliku bla.js i działa,

var foo= function (req, res, next) {
  console.log('inside foo');
  return ("foo");
}

var  bar= function(req, res, next) {
  this.foo();
}
module.exports = {bar,foo};

i bez modyfikacji w app.js

var bla = require('./bla.js');
console.log(bla.bar());