Chiamare una funzione "locale" all'interno di module.exports da un'altra funzione in module.exports?

Come si chiama una funzione all'interno di un'altra funzione in una module.exportsdichiarazione?

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

}

Sto provando ad accedere alla funzione foodall'interno della funzione bare sto ottenendo:

TypeError: Object # non ha un metodo 'pippo'

Se cambio this.foo()a solo foo()ottengo:

Errore di riferimento: foo non è definito

Cambia this.foo()inmodule.exports.foo()

Potresti dichiarare le tue funzioni al di fuori del module.exportsblocco.

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

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

Poi:

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

Puoi anche farlo per renderlo più conciso e leggibile. Questo è quello che ho visto fare in molti dei moduli open source ben scritti:

var self = module.exports = {

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

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

}

È inoltre possibile salvare un riferimento all'ambito globale del modulo al di fuori della definizione (module.) Exports.somemodule:

var _this = this;

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

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

Un'altra opzione, e più vicina allo stile originale dell'OP, è quella di mettere l'oggetto che si desidera esportare in una variabile e fare riferimento a quella variabile per effettuare chiamate ad altri metodi nell'oggetto. Puoi quindi esportare quella variabile e sei a posto.

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

A partire da Node.js versione 13 è possibile sfruttare i moduli ES6 .

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

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

Seguendo l'approccio di classe:

class MyClass {

    foo() {
        return 'foo';
    }

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

module.exports = new MyClass();

Ciò creerà un'istanza della classe una sola volta, a causa della memorizzazione nella cache del modulo del nodo:
https://nodejs.org/api/modules.html#modules_caching

Per risolvere il tuo problema, ho apportato alcune modifiche a bla.js e funziona,

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

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

e nessuna modifica in app.js

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