Question

我在执行module.exports =＆lt; ClassName＆gt;时遇到循环依赖问题。

这是一个例子。 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结束时，module.exports被ClassC覆盖，而对该对象的引用在classA.js保持不变。

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

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

不要覆盖module.exports并执行module.exports.class = ClassC;之类的操作，然后实例化new ClassC.class();，但这也会导致继承和笨拙代码的更多困难。
请改用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()将导致最大调用堆栈错误。但是所有类引用都按照您的预期解决了。

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

1 个答案: