如何重构存在循环依赖的代码架构？附两类示例代码

首先得明确你遇到的核心问题：父类在构造逻辑中直接依赖/实例化子类，同时子类又继承父类，这就形成了无法打破的循环依赖——创建父类需要先创建子类，而子类的初始化又依赖父类的定义完成，直接导致死胡同。下面分两种场景给你具体的重构方案：

一、针对World类的循环依赖重构 #

问题根源 #

你的World类构造函数里直接实例化ExtraWorld和SuperWorld，但这两个类又继承自World，相当于"要造爸爸得先造儿子，造儿子得先有爸爸"，完全矛盾。

重构步骤&代码示例 #

1. 拆分职责，打破循环实例化：把World改为只定义公共行为的抽象基类，不再负责创建子类实例；实例化逻辑移到外部（比如工厂类或业务代码）。
2. 重命名类，明确职责：用更清晰的命名替代模糊的Super/Extra，让类的作用一目了然。

重构后的代码：

// 抽象基类：定义所有World的公共接口
class AbstractWorld {
  constructor() {
    // 只初始化公共属性/逻辑，不实例化子类
    this.commonProperty = "shared-world-data";
  }

  // 定义公共方法，子类可以重写
  run() {
    throw new Error("子类必须实现run方法");
  }
}

// 原SuperWorld：重命名为EnhancedWorld，代表增强型世界
class EnhancedWorld extends AbstractWorld {
  run() {
    console.log("运行增强型世界逻辑");
  }
}

// 原ExtraWorld：重命名为ExtendedWorld，代表扩展型世界
class ExtendedWorld extends AbstractWorld {
  run() {
    console.log("运行扩展型世界逻辑");
  }
}

// 外部负责组合实例，避免循环
class WorldManager {
  constructor() {
    this.enhancedWorld = new EnhancedWorld();
    this.extendedWorld = new ExtendedWorld();
  }

  startAll() {
    this.enhancedWorld.run();
    this.extendedWorld.run();
  }
}

// 使用示例
const manager = new WorldManager();
manager.startAll();

二、针对Block类的循环依赖重构 #

问题根源 #

你的BasicBlock既作为所有块的基类，又承担了"包含其他块"的容器职责，导致基类直接依赖子类，形成循环。本质是把"继承关系"和"组合关系"混在了同一个类里。

重构步骤&代码示例 #

1. 拆分职责：把"块的抽象定义"和"块的容器功能"分开——抽象基类负责定义所有块的公共行为，新增一个容器类专门管理子块。
2. 重命名类，语义化命名：让每个类的名字直接反映它的作用。

重构后的代码：

// 抽象基类：定义所有块的公共接口
class AbstractBlock {
  constructor() {
    this.blockId = Math.random().toString(36).slice(2);
  }

  // 所有块必须实现的核心方法
  execute(context) {
    throw new Error("子类必须实现execute方法");
  }
}

// 原IfBlock：重命名为ConditionalBlock，明确是条件判断块
class ConditionalBlock extends AbstractBlock {
  constructor(condition, trueBlock, falseBlock) {
    super();
    this.condition = condition;
    this.trueBlock = trueBlock; // 依赖的是AbstractBlock，不是具体子类
    this.falseBlock = falseBlock;
  }

  execute(context) {
    if (this.condition(context)) {
      this.trueBlock?.execute(context);
    } else {
      this.falseBlock?.execute(context);
    }
  }
}

// 原ForBlock：重命名为LoopBlock，明确是循环块
class LoopBlock extends AbstractBlock {
  constructor(loopCondition, loopBody) {
    super();
    this.loopCondition = loopCondition;
    this.loopBody = loopBody;
  }

  execute(context) {
    while (this.loopCondition(context)) {
      this.loopBody.execute(context);
    }
  }
}

// 新增容器类：专门负责包含多个子块，也属于Block的一种（符合组合模式）
class BlockContainer extends AbstractBlock {
  constructor() {
    super();
    this.children = [];
  }

  addBlock(block) {
    if (block instanceof AbstractBlock) {
      this.children.push(block);
    }
  }

  execute(context) {
    this.children.forEach(block => block.execute(context));
  }
}

// 使用示例：组合各种块
const container = new BlockContainer();
const loop = new LoopBlock(
  (ctx) => ctx.count < 3,
  new ConditionalBlock(
    (ctx) => ctx.count % 2 === 0,
    // 可以嵌套容器或其他块
    new class extends AbstractBlock {
      execute(ctx) { console.log(`偶数：${ctx.count}`); ctx.count++; }
    },
    new class extends AbstractBlock {
      execute(ctx) { console.log(`奇数：${ctx.count}`); ctx.count++; }
    }
  )
);

container.addBlock(loop);
container.execute({ count: 0 });

核心重构原则总结 #

• 单一职责：每个类只做一件事，避免把"基类"和"容器"、"基类"和"实例化逻辑"混在一起。
• 依赖抽象而非具体：让类依赖抽象基类，而不是直接依赖子类，从根源上避免循环依赖。
• 语义化命名：用清晰的名字替代模糊的Basic/Super/Extra，降低维护成本。

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