虽然node.js确实允许循环的require依赖关系，但你已经发现它可能非常混乱，你最好重新构造你的代码以不需要它。也许可以创建第三个类，使用另外两个类来完成您所需要的。

尝试在模块上设置属性。出口，而不是完全取代它。例如，module.exports.instance = a.js中的新ClassA()， module.exports.ClassB = b.js中的ClassB。当你创建循环模块依赖关系时，需要的模块将得到一个不完整模块的引用。从所需的模块导出，您可以稍后添加其他属性，但当您设置整个模块时。导出，你实际上创建了一个新对象，所需的模块没有办法访问。

有时引入第三个类(JohnnyHK建议)确实是人为的，所以除了Ianzz之外: 如果您确实需要更换模块。导出，例如，如果你正在创建一个类(如上面例子中的b.js文件)，这也是可能的，只要确保在开始循环require的文件中，'模块。出口=…`语句发生在require语句之前。

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 ClassB = function() {
}

ClassB.prototype.doSomethingLater() {
    util.log(a.property);
}

module.exports = ClassB;

var a = require("./a"); // <------ this is the only necessary change

现在不是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

需要最小变化的解决方案是扩展模块。导出而不是重写它。

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;

重要的是不要重新分配模块。导出您已经被给予的对象，因为该对象可能已经被给予周期中的其他模块!只需在模块内分配属性。导出和其他模块将看到它们出现。

所以一个简单的解决方案是:

module.exports.firstMember = ___;
module.exports.secondMember = ___;

唯一的缺点是需要重复module.exports。很多次了。

类似于lanzz和setec的回答，我一直在使用以下模式，它感觉更像是声明性的:

module.exports = Object.assign(module.exports, {
    firstMember: ___,
    secondMember: ___,
});

object .assign()将成员复制到已经分配给其他模块的exports对象中。

=赋值在逻辑上是冗余的，因为它只是一个设置模块。出口到自己，但我使用它，因为它帮助我的IDE (WebStorm)识别firstMember是这个模块的属性，所以“转到->声明”(Cmd-B)和其他工具将从其他文件工作。

这个模式不是很漂亮，所以我只在需要解决循环依赖关系问题时使用它。

它非常适合于显示模式，因为您可以轻松地从对象中添加和删除导出，特别是在使用ES6的属性简写时。

Object.assign(module.exports, {
    firstMember,
    //secondMember,
});

懒惰只在你需要的时候才要求呢?b。js是这样的

var ClassB = function() {
}
ClassB.prototype.doSomethingLater() {
    var a = require("./a");    //a.js has finished by now
    util.log(a.property);
}
module.exports = ClassB;

当然，将所有require语句放在文件的顶部是一个很好的实践。但在某些情况下，我原谅自己从一个不相关的模块中选择了一些内容。称其为hack，但有时这比引入进一步的依赖项，或添加额外的模块或添加新的结构(EventEmitter等)要好。

事实上，我最终需要我的依赖

 var a = null;
 process.nextTick(()=>a=require("./a")); //Circular reference!

虽然不漂亮，但很管用。这比更改b.js(例如只增加modules.export)更容易理解和诚实，因为后者是完美的。

我见过的另一种方法是在第一行导出，并将其保存为一个局部变量，如下所示:

let self = module.exports = {};

const a = require('./a');

// Exporting the necessary functions
self.func = function() { ... }

我倾向于用这种方法，你知道它有什么缺点吗?

你可以很容易地解决这个问题:在你需要使用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上

let B;
class A{
  constructor(){
    process.nextTick(()=>{
      B = require('./b')
    })
  } 
}
module.exports = new A();

在文件'b.js'上写以下内容

let A;
class B{
  constructor(){
    process.nextTick(()=>{
      A = require('./a')
    })
  } 
}
module.exports = new B();

这样，在事件循环的下一次迭代中，类将被正确定义，并且那些require语句将按预期工作。

避免它的一种方法是不需要在另一个文件中要求它，只要将它作为一个函数的参数传递给另一个文件。 这样就不会产生循环依赖。

如果你不能消除循环依赖(例如useraccount <——> userlogin)，还有一个选择…

它就像使用setTimeout()一样简单

//useraccount.js

let UserLogin = {};

setTimeout(()=>UserLogin=require('./userlogin.js'), 10);

class UserAccount{
 
getLogin(){
return new UserLogin(this.email);

}

}



//userlogin.js

let UserAccount ={};

setTimeout(()=>UserAccount=require('./useraccount.js'), 15);


class UserLogin{

getUser(){

return new User(this.token);

}

}

博士TL;

只需使用导出。somember = somember而不是module。Exports ={//新对象}。

扩展的回答

在读完lanzz的回答后，我终于可以弄清楚这里发生了什么，所以我会就这个问题发表我的意见，扩展他的回答。

让我们来看看这个例子:

a.js

console.log("a starting");

console.log("a requires b");
const b = require("./b");
console.log("a gets b =", b);

function functionA() {
  console.log("function a");
}

console.log("a done");
exports.functionA = functionA;

b.js

console.log("b starting");

console.log("b requires a");
const a = require("./a");
console.log("b gets a =", a);

function functionB() {
  console.log("On b, a =", a)
}

console.log("b done");
exports.functionB = functionB;

main.js

const a = require("./a");
const b = require("./b");

b.functionB()

输出

a starting
a requires b
b starting
b requires a
b gets a = {}
b done
a gets b = { functionB: [Function: functionB] }
a done
On b, a = { functionA: [Function: functionA] }

在这里，我们可以看到b首先接收一个空对象作为a，然后一旦a完全加载，该引用将通过导出更新。functionA = functionA。如果将整个模块替换为另一个对象，则通过module。导出，那么b将失去来自a的引用，因为它将从开始指向相同的空对象，而不是指向新的对象。

如果你像这样导出:module。exports = {functionA: functionA}，那么输出将是:

a starting
a requires b
b starting
b requires a
b gets a = {}
b done
a gets b = { functionB: [Function: functionB] }
a done
On b, a = {} // same empty object

最简单的解决方法通常是:

通常你会把要求放在文件的顶部…

var script = require('./script')
function stuff() {
      script.farfunction()
}

相反，只需“在函数中”要求它

function stuff() {
      var _script = require('./script')
      _script.farfunction()
}