структура приложения кругового модуля nodejs

Question

У меня есть 3 файла в следующей структуре:

1. root.js
2. mod1.js
3. mod2.js

mod1.js и mod2.js оба требуются / создаются в root.js, а оба mod1.js и mod2.js требуют ("root.js");Так что я могу выполнять обратные вызовы для публичных функций в root.js ... У меня проблема в том, что const root = require ("root.js");это либо {}, либо пустой объект как в mod1.js, так и в mod2.js.Особенно, когда я добавляю больше кода в mod1 и mod2, они оба оказываются {}

Снимок экрана ошибки можно увидеть здесь: https://github.com/DarceyLloyd/NodeAppArchitecture/blob/master/issue.png

Так что вопрос в том, какая структура или какой коддостигает возврата каждого класса / функции / объекта правильно во время реализации?Структурные изменения?Я проверил это с помощью функции keyup, сопоставленной с телом, поэтому при нажатии spac eit требуется 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();

}

// Кэшированный вывод, так что new всегда вызывается только один раз module.exports = new Root ();`` ``

mod1.js

`` `` var Mod1 = function () {const root = require ("./ root.js");

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

init();

}

// Кэшированный вывод, так что new всегда вызывается только один раз module.exports = new Mod1 ();`` ``

mod2.js

`` `` var Mod2 = function () {const root = require ("./ root.js");

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

init();

}

// Кэшированный вывод, так что new всегда вызывается только один раз module.exports = new Mod2 ();`` `` `

Answer 1

Обычно циклические зависимости означают отсутствие архитектуры, наличие системы связи, поэтому всегда хорошо избегать циклических зависимостей.Если модуль A использует модуль B, а модуль B использует модуль A (A -> B, B -> A), то это может быть тот же модуль, или даже опция пытается разделить на более мелкие функции, чтобы импортировать только минимальные.Предложенное решение @Vitiok это нормально, требуется модуль в функции инициализации.Имейте в виду, что требуется синхронизация, и если у вас есть веб-приложение, оно может заморозить ваш процессор, если вы слишком часто запускаете это решение.

Мой совет: если вы хотите избежать проблем, которые трудно отладить, не делайтесоздать круговые зависимости.

Answer 2

Извините, я вас разочаровываю, но вы не получите правильное "создание экземпляров", пока выполняете циклический импорт в приложении.Для достижения правильного поведения НЕ следует импортировать по кругу.В настоящий момент вы создаете экземпляр одного объекта, а другой еще не создан.Я бы предложил вам следующее решение, чтобы убедиться, что объект, к которому вы пытаетесь получить доступ, создан.

        // 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;