javascript - 使用类处理NodeJS 4中的循环依赖项

This question already has answers here:

How to deal with cyclic dependencies in Node.js
                                
                                    （12个答案）
                                
                        
                                3年前关闭。
            
                    
我在执行module.exports = 时遇到循环依赖问题。

这是一个例子。 ClassC需要ClassB，ClassB需要ClassA，ClassA需要ClassC。在main.js中，我们仅创建一个新的ClassC实例并调用该方法，该方法将执行一系列调用：

/* classA.js */
'use strict';

const ClassC = require('./classC.js');
class ClassA {
    foo() {
        console.log('ClassA.foo');
        var classC = new ClassC();
        classC.bar();
    }
}

module.exports = ClassA;

/* classB.js */
'use strict';

const ClassA = require('./classA.js');
class ClassB {
    foo() {
        console.log('ClassB.foo');
        var classA = new ClassA();
        classA.foo();
    }
}

module.exports = ClassB;

/* classC.js */
'use strict';

const ClassB = require('./classB.js');
class ClassC {
    foo() {
        console.log('ClassC.foo');
        var classB = new ClassB();
        classB.foo();
    }

    bar() {
        console.log('ClassC.bar');
    }
}

module.exports = ClassC;

/* main.js */
'use strict';

const ClassC = require('./classC.js');

var classC = new ClassC();
classC.foo();

因此，当我调用节点main.js时，我收到一个明显的错误，即ClassC无法解析。

D:\Projects\test-circular-reference-es6\classA.js:8
        var classC = new ClassC();
                     ^
TypeError: ClassC is not a function
    at ClassA.foo (D:\Projects\test-circular-reference-es6\classA.js:8:22)
    at ClassB.foo (D:\Projects\test-circular-reference-es6\classB.js:9:16)
    at ClassC.foo (D:\Projects\test-circular-reference-es6\classC.js:9:16)
    at Object.<anonymous> (D:\Projects\test-circular-reference-es6\main.js:7:8)
    at Module._compile (module.js:409:26)
    at Object.Module._extensions..js (module.js:416:10)
    at Module.load (module.js:343:32)
    at Function.Module._load (module.js:300:12)
    at Function.Module.runMain (module.js:441:10)
    at startup (node.js:139:18)

发生这种情况的原因是，当在ClassA中需要ClassC时，它仍然是ClassC的加载过程，因此返回了一个空对象，然后在classC.js的末尾，用ClassC覆盖了module.exports，同时引用了classA中的空对象。 js保持原样。

因此，问题是如何处理这个问题，在NodeJS 4.x（ES6）中同时具有循环引用和导出类的最佳实践是什么？

从我这边，我看到以下可能的方法：


不要覆盖module.exports并执行module.exports.class = ClassC;之类的操作，然后执行new ClassC.class();之类的实例化，但这通常也会给继承和笨拙的代码带来更多困难。
请改用TypeScript，因为它将处理这些内容。


欢迎任何建议。

最佳答案

尝试将require调用移到带有类定义的文件末尾。这是工作示例：

// a.js
class A {
    foo() {
        var c = new C();
        c.foo();
    }
}

module.exports = A;
const C = require('./c.js');

// b.js
class B {
    foo() {
        var c = new C();
        c.foo();
    }
}

module.exports = B;
const C = require('./c.js');

// c.js
class C {
    foo() {
        var a = new A();
        a.foo();
    }
}

module.exports = C;
const A = require('./a.js');

// main.js
const C = require('./c.js');
const B = require('./b.js');

const c = new C();
const b = new B();

c.foo();
b.foo();

注意该调用c.foo()将导致最大调用堆栈错误。但是，所有类引用都可以按预期解决。