从另外一个 module.exports 导出的函数中调用本地 module.exports 导出的 “local” 函数

将this.foo()更改为module.exports.foo()

你可以在module.exports块之外声明你的函数。

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


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

然后:

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

您还可以在(module.)导出之外保存对模块全局作用域的引用。somemodule定义:

var _this = this;


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


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

另一种更接近OP原始风格的方法是，将想要导出的对象放入一个变量中，并引用该变量来调用对象中的其他方法。然后就可以导出这个变量了。

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

你也可以这样做，使它更简洁和可读。这是我在几个写得很好的开源模块中看到的:

var self = module.exports = {


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


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


}

从Node.js版本13开始，你可以利用ES6模块。

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


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

遵循Class方法:

class MyClass {


foo() {
return 'foo';
}


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


module.exports = new MyClass();

const Service = {
foo: (a, b) => a + b,
bar: (a, b) => Service.foo(a, b) * b
}


module.exports = Service

为了解决你的问题，我在bla.js中做了一些改变，它正在工作，

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


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

在app.js中没有任何修改

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

我所做的是创建一个独立的foo函数，并在两个地方引用它。

这样，无论使用箭头还是常规函数，它都可以防止this出现任何问题

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

然后我可以在这两个地方引用foo

module.exports = {


foo, // ES6 for foo:foo


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


}