如何构建带层级属性分组的类并实现内部属性互通？

下面提供三种基于Class语法的实现方案，既能保留对象的层级结构，又能实现不同子属性组之间的属性互通，同时支持多实例化：

方案一：子类持有父类实例引用 #

通过在子类初始化时传入父类this引用，让子类可以直接访问父类下的其他子属性组，每个父类实例的子属性组都独立关联自身，不会互相干扰。

class A {
  #parent; // 私有属性，避免外部直接修改

  constructor(prop1, parent) {
    this.property = prop1;
    this.#parent = parent;
  }

  // 示例：访问B类的属性
  getBProperty() {
    return this.#parent.PropertyB.property;
  }
}

class B {
  #parent;

  constructor(prop2, parent) {
    this.property = prop2;
    this.#parent = parent;
  }

  // 示例：访问A类的属性
  getAProperty() {
    return this.#parent.PropertyA.property;
  }
}

class C {
  constructor(prop1, prop2) {
    this.PropertyA = new A(prop1, this);
    this.PropertyB = new B(prop2, this);
  }
}

// 测试多实例
const obj1 = new C(10, 20);
console.log(obj1.PropertyA.getBProperty()); // 输出 20
console.log(obj1.PropertyB.getAProperty()); // 输出 10

const obj2 = new C(30, 40);
console.log(obj2.PropertyA.getBProperty()); // 输出 40
console.log(obj2.PropertyB.getAProperty()); // 输出 30

方案二：父类统一管理状态，子类做属性代理 #

将实际数据存储在父类中，子类通过getter/setter代理访问父类的状态，实现子属性组之间的属性互通，同时避免循环引用风险。

class A {
  #parent;

  constructor(parent) {
    this.#parent = parent;
  }

  get property() {
    return this.#parent._prop1;
  }

  set property(value) {
    this.#parent._prop1 = value;
  }

  getBProperty() {
    return this.#parent._prop2;
  }
}

class B {
  #parent;

  constructor(parent) {
    this.#parent = parent;
  }

  get property() {
    return this.#parent._prop2;
  }

  set property(value) {
    this.#parent._prop2 = value;
  }

  getAProperty() {
    return this.#parent._prop1;
  }
}

class C {
  constructor(prop1, prop2) {
    this._prop1 = prop1; // 父类内部存储状态
    this._prop2 = prop2;
    this.PropertyA = new A(this);
    this.PropertyB = new B(this);
  }
}

const obj = new C(1, 2);
console.log(obj.PropertyA.property); // 输出 1
console.log(obj.PropertyB.getAProperty()); // 输出 1
obj.PropertyA.property = 5;
console.log(obj.PropertyB.getAProperty()); // 输出 5

方案三：子类直接持有兄弟实例引用 #

如果子属性组之间需要频繁交互，可以在父类初始化时，直接将兄弟实例传递给对应的子类，实现更直接的属性访问。

class A {
  constructor(prop1, siblingB) {
    this.property = prop1;
    this.siblingB = siblingB;
  }
}

class B {
  constructor(prop2, siblingA) {
    this.property = prop2;
    this.siblingA = siblingA;
  }
}

class C {
  constructor(prop1, prop2) {
    // 先创建空实例，再关联兄弟引用
    this.PropertyA = new A(prop1, null);
    this.PropertyB = new B(prop2, this.PropertyA);
    this.PropertyA.siblingB = this.PropertyB;
  }
}

const obj = new C(100, 200);
console.log(obj.PropertyA.siblingB.property); // 输出 200
console.log(obj.PropertyB.siblingA.property); // 输出 100

方案选择建议 #

• 若仅需偶尔跨组访问属性，方案一最简洁直接；
• 若需要统一管理状态、避免数据分散，方案二更合适；
• 若子属性组之间交互频繁，方案三的访问效率更高。

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