如何让不同类（Class）之间共享属性、方法及各类成员？

你的核心需求是让类的所有属性、方法及成员能被其他类、函数或外部对象访问，同时实现不同类间的共享。先修正你示例代码里的语法问题，再给出几种可行的实现方案：

一、修正基础示例代码 #

你原代码存在语法错误，比如函数嵌套定义、类内直接赋值实例属性等，先修正为合法的JavaScript代码：

// 全局共享容器
const StoragePoint = {};

class AllCanShareWithMe {
  // 保存数据到共享容器
  giveItHere(key, value) {
    StoragePoint[key] = value;
  }

  // 从共享容器取出数据
  takeItBack(key) {
    return StoragePoint[key];
  }
}

class IHaveSomethingToShare {
  constructor() {
    // 实例属性
    this.something = "popcorn";
  }

  // 发送自身属性到共享类实例
  sendTo(shareInstance) {
    shareInstance.giveItHere("snack", this.something);
  }

  // 从共享类实例获取数据
  accessFrom(shareInstance) {
    return shareInstance.takeItBack("snack");
  }
}

二、具体实现方案 #

1. 全局存储容器方案（最贴合你的初始思路） #

利用全局对象作为中转，所有需要共享的内容都存入这个容器，任何类、函数或外部都可以直接访问容器，或者通过共享类的方法操作容器：

// 全局共享容器，外部可直接访问
const StoragePoint = {};

class AllCanShareWithMe {
  // 存入共享数据
  save(key, value) {
    StoragePoint[key] = value;
  }

  // 获取共享数据
  get(key) {
    return StoragePoint[key];
  }

  // 共享方法，外部也可直接调用
  static sharedMethod() {
    console.log("这是一个可共享的方法");
  }
}

class IHaveSomethingToShare {
  constructor() {
    this.something = "popcorn";
  }

  sendToShare() {
    const sharer = new AllCanShareWithMe();
    sharer.save("snack", this.something);
  }

  getFromShare() {
    const sharer = new AllCanShareWithMe();
    return sharer.get("snack");
  }
}

// 外部直接访问共享容器
StoragePoint.directData = "外部存入的数据";
console.log(StoragePoint.directData); // 输出：外部存入的数据

// 外部直接调用共享类的静态方法
AllCanShareWithMe.sharedMethod(); // 输出：这是一个可共享的方法

// 类之间的共享示例
const sharer = new AllCanShareWithMe();
const sharerUser = new IHaveSomethingToShare();
sharerUser.sendToShare();
console.log(sharerUser.getFromShare()); // 输出：popcorn

2. 静态成员共享方案 #

将需要共享的属性和方法定义为类的静态成员，无需实例化即可访问，其他类或外部直接通过类名调用：

class SharedContainer {
  // 静态共享属性
  static sharedProperty = "共享的属性值";

  // 静态共享方法
  static sharedMethod() {
    return "这是一个共享方法的返回值";
  }
}

class ClassA {
  useSharedContent() {
    // 访问共享类的静态属性
    console.log(SharedContainer.sharedProperty);
    // 调用共享类的静态方法
    console.log(SharedContainer.sharedMethod());
  }
}

class ClassB {
  modifySharedProperty() {
    // 修改共享属性，所有访问该属性的地方都会同步变化
    SharedContainer.sharedProperty = "修改后的共享属性值";
  }
}

// 外部直接访问静态成员
console.log(SharedContainer.sharedProperty); // 输出：共享的属性值

const a = new ClassA();
const b = new ClassB();
a.useSharedContent(); // 输出：共享的属性值、这是一个共享方法的返回值
b.modifySharedProperty();
a.useSharedContent(); // 输出：修改后的共享属性值、这是一个共享方法的返回值

3. 混入（Mixin）模式共享 #

将共享的属性和方法封装成混入对象，让多个类通过Object.assign或类继承的方式拥有这些成员，实现代码复用：

// 定义混入对象，包含共享的属性和方法
const SharedMixin = {
  sharedProperty: "混入的共享属性",
  sharedMethod() {
    console.log(`调用了混入的共享方法，属性值：${this.sharedProperty}`);
  }
};

// 类A通过Object.assign混入共享内容
class ClassA {
  constructor() {
    Object.assign(this, SharedMixin);
  }
}

// 类B通过继承的方式混入（需要借助一个中间类）
class SharedClass extends Object {
  constructor() {
    super();
    Object.assign(this, SharedMixin);
  }
}
class ClassB extends SharedClass {}

// 测试共享效果
const a = new ClassA();
const b = new ClassB();

a.sharedMethod(); // 输出：调用了混入的共享方法，属性值：混入的共享属性
b.sharedMethod(); // 输出：调用了混入的共享方法，属性值：混入的共享属性

// 修改类A的共享属性，不会影响类B（因为是实例属性）
a.sharedProperty = "类A修改后的属性";
a.sharedMethod(); // 输出：调用了混入的共享方法，属性值：类A修改后的属性
b.sharedMethod(); // 输出：调用了混入的共享方法，属性值：混入的共享属性

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