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

Question

我在执行 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();

因此，当我调用 Node 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 末尾， module.exports 被 ClassC 覆盖，而对空对象的引用classA.js 中保持原样。

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

从我的 Angular 来看，我看到以下可能的方法:

1. 不要覆盖 module.exports 并执行类似 module.exports.class = ClassC; 的操作然后实例化像 new ClassC.class();但这也给继承和笨拙的代码带来了更多困难。
2. 改用 TypeScript，因为它可以处理这些事情。

欢迎任何建议。

Answer 1

尝试将 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()将导致最大调用堆栈错误。但所有类引用都按照您的预期得到解决。