如何处理Node.js中的循环依赖关系

我最近一直在使用nodejs，并且仍然要处理模块系统，因此很抱歉这是一个明显的问题。我想要大致如下的代码：

a.js（主文件与节点一起运行）

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实例。

有没有正确/更好的方法来构造模块来实现我想要的？是否有更好的方式在模块之间共享变量？

尽管node.js确实允许循环require依赖，但正如您所发现的那样，它可能很杂乱，您最好重组代码以使其不需要。也许创建一个使用其他两个类来完成您需要的第三类。

尝试在上设置属性module.exports，而不是完全替换它。例如，module.exports.instance = new ClassA()在a.js，module.exports.ClassB = ClassB在b.js。当您建立循环模块依赖关系时，需求模块会module.exports从需求模块中获取不完整的引用，您可以在后面添加其他属性，但是当您设置了整个模块时module.exports，您实际上创建了一个新对象，该对象没有需求模块访问方式。

[编辑]现在不是2015年，大多数库（即express）都以更好的模式进行了更新，因此不再需要循环依赖。我建议根本不使用它们。

只需确保在定义需要循环导出的文件之前定义了必要的导出即可。

这会中断：

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');

我一直使用这种模式来访问app其他文件中的express.js ：

var express = require('express');
var app = module.exports = express();
// load in other dependencies, which can now require this file and use app

有时引入第三类是真的是人为的（正如JohnnyHK所建议的那样），因此除了Ianzz：如果您确实想替换module.exports，例如，如果您正在创建一个类（例如，其中的b.js文件）。上面的示例），这也是可能的，只需确保在开始循环require的文件中，“ module.exports = ...”语句出现在require语句之前。

a.js（主文件与节点一起运行）

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

解决方案是在需要任何其他控制器之前“预先声明”您的导出对象。因此，如果您像这样构造所有模块，则不会遇到任何类似问题：

// 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而不是覆盖它。

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

那么只有在需要时才需要懒惰吗？因此，您的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等）要好。

我见过人们做的另一种方法是在第一行导出并将其保存为本地变量，如下所示：

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

与lanzz和setect的答案类似，我一直在使用以下模式：

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

将Object.assign()成员复制到exports已提供给其他模块的对象中。

该=分配在逻辑上是多余的，因为它只是module.exports对其自身进行设置，但是我正在使用它，因为它可以帮助我的IDE（WebStorm）识别这firstMember是该模块的属性，因此“转到->声明”（Cmd-B）其他工具也可以在其他文件中使用。

这种模式不是很漂亮，因此我仅在需要解决循环依赖问题时才使用它。

这是我发现已用完的快速解决方法。

在文件“ 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语句将按预期工作。

实际上，我最终要求依赖

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

不漂亮，但可以。它比更改b.js（例如，仅增加modules.export）更容易理解和诚实，否则它就是完美的。

避免这种情况的一种方法是，不需要其他文件，只需将其作为函数的参数传递给另一个文件即可。通过这种方式，永远不会出现循环依赖。