如何解决Node.js中的循环依赖问题？

问题 #

我有两个Node.js文件互相依赖（彼此需要对方的值）：

文件A.js需要B.js的数据，同时导出两个值：

console.log(require("./b.js"))

module.exports = {
    fromA: ()=>{console.log("message from exported A")},
    valueA: ["nesto", "josnesto"]
}

文件B.js需要A.js的模块，同时导出一个值：

console.log(require("./a.js").fromA, require("./a.js").valueA)

module.exports = {
    fromB: ()=>{console.log("message from exported B fucntion")}
}

我尝试过多种方案，比如使用Promise或中间件文件：

module.exports = {
    fromA: ()=>{return require("./a.js")},
    fromB: ()=>{return require("./b.js")}
}

但最终无法解决循环依赖问题，因为依赖链为：A.js -> middleware.js -> B.js -> middleware.js -> A.js。

补充说明：在实际代码中，我将程序拆分为两个独立处理的逻辑模块，但它们彼此需要部分数据。例如，A.js在触发特定事件时需要调用B.js的所有函数；B.js需要获取A.js中的用户数组，以便将用户名发送给对应端点。该应用是基于socket.io和web-push的Node.js应用，用于处理用户管理（类似企业中管理员与员工的聊天系统，管理员需查看在线员工）。

解决方案 #

方法1：延迟加载依赖（函数内引入） #

把依赖的require调用放到函数内部，避开模块初始化阶段的循环引用，只有当实际需要使用对方模块时才加载。

修改A.js：

// 不在模块顶部引入B，而是在需要调用的函数内加载
module.exports = {
    fromA: () => {
        const { fromB } = require("./b.js");
        fromB(); // 调用B的函数
        console.log("message from exported A");
    },
    valueA: ["nesto", "josnesto"]
}

修改B.js：

module.exports = {
    fromB: () => {
        const { valueA } = require("./a.js");
        console.log(valueA); // 获取A的数组
        console.log("message from exported B function");
    }
}

这种方式让模块初始化时互不干扰，只有执行函数时才建立依赖关系，彻底避开循环问题。

方法2：拆分共享数据到独立模块（推荐） #

把两个模块都需要的共享数据（比如你的用户数组）抽离到单独模块，让A和B都依赖这个新模块，从根源上消除循环依赖。

新建sharedData.js：

// 存放共享的在线用户数组
module.exports = {
    onlineUsers: []
}

修改A.js：

const sharedData = require("./sharedData.js");
const { fromB } = require("./b.js");

// 维护用户数组的逻辑放在A中
module.exports = {
    addOnlineUser: (user) => sharedData.onlineUsers.push(user),
    getOnlineUsers: () => sharedData.onlineUsers,
    triggerEvent: () => {
        fromB(); // 调用B的函数
        console.log("triggered event from A");
    }
}

修改B.js：

const sharedData = require("./sharedData.js");

module.exports = {
    sendToEndpoints: () => {
        const users = sharedData.onlineUsers;
        console.log("sending to users:", users);
        console.log("message from exported B function");
    }
}

这种架构更清晰，符合单一职责原则，适合你的用户管理场景。

方法3：利用模块导出的可变性（应急方案） #

Node.js模块导出的对象是可修改的，可以先导出空对象，待模块初始化完成后再补全内容，或者在另一个模块中填充依赖。

修改A.js：

// 先导出空对象
module.exports = {};

// 延迟加载B，等自身导出对象创建完成后再引入
const { fromB } = require("./b.js");

// 补全导出内容
module.exports.fromA = () => {
    fromB();
    console.log("message from exported A");
};
module.exports.valueA = ["nesto", "josnesto"];

修改B.js：

module.exports = {};

// 引入A的导出对象（此时是空的，后续会被补全）
const aModule = require("./a.js");

module.exports.fromB = () => {
    console.log(aModule.fromA, aModule.valueA);
    console.log("message from exported B function");
};

这种方法能解决问题，但会让代码逻辑变得隐晦，长期维护容易出问题，仅建议在无法重构架构时临时使用。

内容的提问来源于stack exchange，提问作者Ivan Makevic