Eine "lokale" Funktion in module.exports von einer anderen Funktion in module.exports aufrufen?

Wie ruft man eine Funktion innerhalb einer anderen Funktion in einer module.exportsDeklaration auf?

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();
  }

}

Ich versuche, fooinnerhalb der Funktion auf die Funktion zuzugreifen bar, und erhalte Folgendes:

TypeError: Objekt # hat keine Methode 'foo'

Wenn ich this.foo()zu nur wechsle , foo()bekomme ich:

ReferenceError: foo ist nicht definiert

Wechseln Sie this.foo()zumodule.exports.foo()

Sie können Ihre Funktionen außerhalb des module.exportsBlocks deklarieren .

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

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

Dann:

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

Sie können dies auch tun, um es übersichtlicher und lesbarer zu machen. Dies habe ich in einigen der gut geschriebenen Open-Source-Module gesehen:

var self = module.exports = {

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

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

}

Sie können einen Verweis auf den globalen Bereich des Moduls auch außerhalb der Definition (module.) Exports.somemodule speichern:

var _this = this;

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

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

Eine andere Option, die dem ursprünglichen Stil des OP näher kommt, besteht darin, das zu exportierende Objekt in eine Variable einzufügen und auf diese Variable zu verweisen, um andere Methoden im Objekt aufzurufen. Sie können diese Variable dann exportieren und loslegen.

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

Ab Node.js Version 13 können Sie ES6-Module nutzen .

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

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

Dem Klassenansatz folgen:

class MyClass {

    foo() {
        return 'foo';
    }

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

module.exports = new MyClass();

Dadurch wird die Klasse aufgrund des Modul-Caching von Node nur einmal instanziiert:
https://nodejs.org/api/modules.html#modules_caching

Um Ihr Problem zu beheben, habe ich einige Änderungen in bla.js vorgenommen und es funktioniert,

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

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

und keine Änderung in app.js.

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