Question

我有以下结构中的3个文件：

root.js
mod1.js
mod2.js

mod1.js和mod2.js都在root.js中需要/实例化，mod1.js和mod2.js都需要（＆＃34; root.js＆＃34;）;这样我就可以在root.js中执行对公共函数的回调...我遇到的问题是const root = require（＆＃34; root.js＆＃34;）; mod1.js和mod2.js中都是{}或空对象。特别是当我在mod1和mod2中添加更多代码时，它们最终都是{}

错误屏幕截图可以在这里看到： https://github.com/DarceyLloyd/NodeAppArchitecture/blob/master/issue.png

所以问题是，在实例化期间，什么结构或什么代码能够正确地返回每个类/函数/对象？结构变化？我已经使用映射到正文的键盘函数对此进行了测试，这样当我按下空格时，需要root.js然后运行其getA函数就好了，但它只在按键时执行此操作，因此在类/函数/对象期间不会这样做实例化/创建。想法？

所有文件都可以在这里看到： https://github.com/DarceyLloyd/NodeAppArchitecture

对于stackoverflow参考：

root.js

```` var Root = function（）{ this.a = -1; this.b = -1;

const mod1 = require("./mod1.js"); // Runs 2nd?
const mod2 = require("./mod2.js"); // Runs 1st?

function init(){
    this.a = 0;
    this.b = 0;
}

this.incA = function() { this.a++; }
this.incB = function() { this.a++; }
this.getA = function() { return this.a; console.log(a); }
this.getB = function() { return this.b; console.log(b); }

init();

}

//缓存输出，所以新的只被调用一次 module.exports = new Root（）; ````

mod1.js

```` var Mod1 = function（）{ const root = require（＆＃34; ./ root.js＆＃34;）;

function init(){
    console.log("Mod1()");
    console.log(root); // result is {}
    //root.incA(); // error incA doesn't exist on object root
}

init();

}

//缓存输出，所以新的只被调用一次 module.exports = new Mod1（）; ````

mod2.js

```` var Mod2 = function（）{ const root = require（＆＃34; ./ root.js＆＃34;）;

function init(){
    console.log("Mod2()");
    console.log(root); // result is {}
    //root.incB(); // error incB doesn't exist on object root
}

init();

}

//缓存输出，所以新的只被调用一次 module.exports = new Mod2（）; ````

Answer 1

抱歉，我很失望，但是你没有得到正确的解释，并且＃34;实例化＆＃34;只要您在申请中进行循环导入。为了实现正确的行为，您不应以循环方式导入。在您实例化一个对象的那一刻，另一个对象尚未实例化。我建议你使用以下解决方案来确保你试图访问的对象被实例化。

        // ROOT 
        const mod1 = require("./mod1.js"); // Runs 2nd?
        const mod2 = require("./mod2.js"); // Runs 1st?

        var Root = function(){
            this.a = -1;
            this.b = -1;

            this.init = function(){
                this.a = 0;
                this.b = 0;
            }

            this.incA = function() { this.a++; }
            this.incB = function() { this.a++; }
            this.getA = function() { return this.a; console.log(a); }
            this.getB = function() { return this.b; console.log(b); }
        }


        // Cached output so new only ever gets called once
        module.exports = new Root();

        mod2.init()
        mod1.init()


    // MOD2
    var Mod2 = function(){

        this.init = function() {
            const root = require("./root.js");
            console.log("Mod2()");
            root.init()
            console.log(root); // result is {}
            root.incB(); // error incB doesn't exist on object root
        }
    }

    // Cached output so new only ever gets called once
    module.exports = new Mod2;


    // Mod1
    var Mod1 = function(){
        this.init = function() {
            const root = require("./root.js");
            root.init()
            console.log("Mod1()");
            console.log(root); // result is {}
            root.incA(); // error incA doesn't exist on object root
        }
    }

    // Cached output so new only ever gets called once
    module.exports = new Mod1;

Answer 2

通常，循环依赖意味着缺乏架构，具有耦合系统，因此，它总是很好地避免循环依赖。如果模块A使用模块B而模块B使用模块A（A - > B，B - > A）那么这可能是相同的模块，或者甚至一个选项试图分成更小的功能以仅导入最小的模块。 @Vitiok建议的解决方案没问题，需要init函数中的模块。请记住要求是同步，如果您有一个Web应用程序，如果您多次使用此解决方案，这可能会冻结您的CPU。

我的建议：如果你想避免难以调试的问题，不要创建循环依赖。

nodejs循环模块app结构

2 个答案: