JavaScript ES6中如何在类内调用其他类方法？规避重复实例化与不当继承

嘿，这个问题我太有共鸣了——重复new实例不仅冗余，还可能导致不必要的资源消耗，继承又完全不符合你的类关系场景，给你几个实用的解决方案，你可以根据项目规模和需求来选：

1. 单例模式：确保全局唯一实例 #

让目标类自己控制实例的创建逻辑，保证整个应用里只有一个实例。这样你在任何需要的地方，都只需要获取这个唯一实例，不用重复new。

举个JavaScript的例子：

class TargetClass {
  // 私有静态属性存储唯一实例
  static #instance;

  // 私有构造函数，禁止外部直接new
  constructor() {
    if (TargetClass.#instance) {
      return TargetClass.#instance;
    }
    TargetClass.#instance = this;
    // 初始化你的属性
  }

  // 对外提供获取实例的方法
  static getInstance() {
    if (!TargetClass.#instance) {
      new TargetClass();
    }
    return TargetClass.#instance;
  }

  // 你需要调用的业务方法
  yourBusinessMethod() {
    console.log("执行目标方法逻辑");
  }
}

调用的时候，直接通过getInstance()获取实例：

// 在类A中调用
class ClassA {
  doTask() {
    const targetInstance = TargetClass.getInstance();
    targetInstance.yourBusinessMethod();
  }
}

// 在类B中调用
class ClassB {
  doAnotherTask() {
    const targetInstance = TargetClass.getInstance();
    targetInstance.yourBusinessMethod();
  }
}

⚠️ 注意：单例会引入全局状态，可能让单元测试变复杂（比如需要重置实例），小型项目用着方便，大型项目要谨慎。

2. 依赖注入：解耦的最优解 #

这是中大型项目最推荐的方案——核心思路是谁用谁不创建，由外部统一注入实例。不在需要调用方法的类内部new目标实例，而是在外部创建好后，通过构造函数、方法参数传递进去。

例子：

// 目标类
class TargetClass {
  yourBusinessMethod() {
    console.log("执行目标方法逻辑");
  }
}

// 需要调用方法的类A
class ClassA {
  // 通过构造函数注入目标实例
  constructor(targetInstance) {
    this.target = targetInstance;
  }

  doTask() {
    this.target.yourBusinessMethod();
  }
}

// 需要调用方法的类B
class ClassB {
  constructor(targetInstance) {
    this.target = targetInstance;
  }

  doAnotherTask() {
    this.target.yourBusinessMethod();
  }
}

// 外部统一创建实例，注入给所有需要的类
const sharedTargetInstance = new TargetClass();
const classA = new ClassA(sharedTargetInstance);
const classB = new ClassB(sharedTargetInstance);

这种方式的好处是类之间的依赖关系清晰，单元测试时可以轻松替换成mock实例，完全解耦，维护性拉满。如果你的项目用了框架（比如Spring、Vue/React的依赖注入机制），直接用框架自带的DI会更省心。

3. 静态方法：简单场景的快速方案 #

如果你的目标方法不需要依赖类的实例属性（比如不需要访问this里的成员），那直接把方法改成静态的，调用时不用实例化，直接通过类名调用。

例子：

class TargetClass {
  // 静态方法，无需实例化即可调用
  static yourBusinessMethod() {
    console.log("执行静态目标方法逻辑");
  }
}

// 在其他类中直接调用
class ClassA {
  doTask() {
    TargetClass.yourBusinessMethod();
  }
}

这个方案最简单，但局限性也大：如果方法需要依赖实例状态，就没法用；而且静态方法本质是全局访问，同样会带来测试和维护的问题，适合非常简单的场景。

4. 服务容器/工厂模式：大型项目的实例管理方案 #

如果你的项目里有很多这类需要共享的类，用服务容器或者工厂类来统一创建、存储和分发实例会更高效。相当于一个全局的实例仓库，需要的时候从仓库里取。

例子：

// 简单的服务容器实现
class ServiceContainer {
  static #services = new Map();

  // 注册服务实例
  static register(key, instance) {
    this.#services.set(key, instance);
  }

  // 获取服务实例
  static get(key) {
    return this.#services.get(key);
  }
}

// 注册目标类实例
const targetInstance = new TargetClass();
ServiceContainer.register('targetService', targetInstance);

// 在其他类中获取并调用
class ClassA {
  doTask() {
    const targetService = ServiceContainer.get('targetService');
    targetService.yourBusinessMethod();
  }
}

这个方案适合大型项目，能统一管理所有服务实例，避免到处零散创建，扩展和维护都很方便。

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