我最近一直在使用nodejs，仍然在掌握模块系统，所以如果这是一个明显的问题，那么很抱歉。我希望代码大致如下:
A.js(主文件与node一起运行)
var ClassB = require("./b");
var ClassA = function() {
this.thing = new ClassB();
this.property = 5;
}
var a = new ClassA();
module.exports = a;
b.js
var a = require("./a");
var ClassB = function() {
}
ClassB.prototype.doSomethingLater() {
util.log(a.property);
}
module.exports = ClassB;
我的问题似乎是我不能从ClassB的实例中访问ClassA的实例。
有什么正确的/更好的方法来构建模块来实现我想要的? 是否有更好的方法在模块间共享变量?
当前回答
现在不是2015年，大多数库(例如express)已经更新了更好的模式，因此不再需要循环依赖。我建议不要使用它们。
我知道我挖出了一个老答案…… 这里的问题是这个模块。exports定义在您需要ClassB之后。 (JohnnyHK的链接显示) 循环依赖关系在Node中工作得很好，它们是同步定义的。 如果使用得当，它们实际上解决了许多常见的节点问题(比如从其他文件访问express.js应用程序)
只需确保在需要具有循环依赖关系的文件之前定义了必要的导出。
这将打破:
var ClassA = function(){};
var ClassB = require('classB'); //will require ClassA, which has no exports yet
module.exports = ClassA;
这是可行的:
var ClassA = module.exports = function(){};
var ClassB = require('classB');
我一直使用这个模式来访问其他文件中的express.js应用程序:
var express = require('express');
var app = module.exports = express();
// load in other dependencies, which can now require this file and use app
其他回答
你可以很容易地解决这个问题:在你需要使用module.exports的模块中任何其他东西之前，只需导出你的数据:
classA.js
class ClassA {
constructor(){
ClassB.someMethod();
ClassB.anotherMethod();
};
static someMethod () {
console.log( 'Class A Doing someMethod' );
};
static anotherMethod () {
console.log( 'Class A Doing anotherMethod' );
};
};
module.exports = ClassA;
var ClassB = require( "./classB.js" );
let classX = new ClassA();
classB.js
class ClassB {
constructor(){
ClassA.someMethod();
ClassA.anotherMethod();
};
static someMethod () {
console.log( 'Class B Doing someMethod' );
};
static anotherMethod () {
console.log( 'Class A Doing anotherMethod' );
};
};
module.exports = ClassB;
var ClassA = require( "./classA.js" );
let classX = new ClassB();
需要最小变化的解决方案是扩展模块。导出而不是重写它。
A.js -应用程序入口点和模块，使用方法做从b.js*
_ = require('underscore'); //underscore provides extend() for shallow extend
b = require('./b'); //module `a` uses module `b`
_.extend(module.exports, {
do: function () {
console.log('doing a');
}
});
b.do();//call `b.do()` which in turn will circularly call `a.do()`
B.js -模块使用方法做从a.js
_ = require('underscore');
a = require('./a');
_.extend(module.exports, {
do: function(){
console.log('doing b');
a.do();//Call `b.do()` from `a.do()` when `a` just initalized
}
})
它将工作和生产:
doing b
doing a
虽然这段代码将不起作用:
a.js
b = require('./b');
module.exports = {
do: function () {
console.log('doing a');
}
};
b.do();
b.js
a = require('./a');
module.exports = {
do: function () {
console.log('doing b');
}
};
a.do();
输出:
node a.js
b.js:7
a.do();
^
TypeError: a.do is not a function
解决方案是在需要任何其他控制器之前“向前声明”导出对象。所以如果你像这样构建你所有的模块，你就不会遇到这样的问题:
// Module exports forward declaration:
module.exports = {
};
// Controllers:
var other_module = require('./other_module');
// Functions:
var foo = function () {
};
// Module exports injects:
module.exports.foo = foo;
现在不是2015年，大多数库(例如express)已经更新了更好的模式，因此不再需要循环依赖。我建议不要使用它们。
我知道我挖出了一个老答案…… 这里的问题是这个模块。exports定义在您需要ClassB之后。 (JohnnyHK的链接显示) 循环依赖关系在Node中工作得很好，它们是同步定义的。 如果使用得当，它们实际上解决了许多常见的节点问题(比如从其他文件访问express.js应用程序)
只需确保在需要具有循环依赖关系的文件之前定义了必要的导出。
这将打破:
var ClassA = function(){};
var ClassB = require('classB'); //will require ClassA, which has no exports yet
module.exports = ClassA;
这是可行的:
var ClassA = module.exports = function(){};
var ClassB = require('classB');
我一直使用这个模式来访问其他文件中的express.js应用程序:
var express = require('express');
var app = module.exports = express();
// load in other dependencies, which can now require this file and use app
我见过的另一种方法是在第一行导出，并将其保存为一个局部变量，如下所示:
let self = module.exports = {};
const a = require('./a');
// Exporting the necessary functions
self.func = function() { ... }
我倾向于用这种方法，你知道它有什么缺点吗?
