Typescript :: 抽象静态方法

Question

在我的一些个人项目中，我试图设计几种对象和列表类型。这些对象和列表应该是可序列化的（即具有toJSON()和fromJSON()方法）。一个示例对象和列表将具有以下基本代码：

type IPerson = {
  id: number;
  name: string;
  // additional properties
}

class Person {
  id: number;
  name: string;
  // additional properties
  constructor(id: number, name: string, ...) { ... }
  toJSON(): IPerson { return { ... } }
  static fromJSON(json: IPerson): Person { return new Person(...) }
  // additional methods
}

class PersonList {
  list: Person[];
  constructor(list: Person[]) { ... }
  findById(id: number) { return this.list.find(it => it.id === id) }
  findByName(name: string) { return this.list.find(it => it.name === name) }
  add(person: Person) { this.list.push(person) }
  remove(person: Person) { this.list = this.list.filter(it => it !== person) }
  toJSON(): IPerson[] { return this.list.map(it => it.toJSON()) }
  static fromJSON(json: IPerson[]): PersonList { return new PersonList(json.map(it => Person.fromJSON(it))) }
  // additional methods
}

我正在处理的所有对象和列表都至少有此处列出的方法。

现在，我正在尝试将其转换为通用解决方案，使得：

type JSON = {
  id: number;
  name: string;
}

abstract class BaseObject<T extends JSON> {
  abstract get id();
  abstract get name();
  constructor(id: number, name: string) { ... }
  abstract toJSON(): T
  abstract static fromJSON(json: T): BaseObject<T>
}

class BaseList<T, U> {
  list: BaseObject<T>[];
  constructor(list: BaseObject<T>[]) { ... }
  findById(id: number) { return this.list.find(it => it.id === id) }
  findByName(name: string) { return this.list.find(it => it.name === name) }
  add(obj: BaseObject<T>) { this.list.push(obj) }
  remove(obj: BaseObject<T>) { this.list = this.list.filter(it => it !== obj) }
  toJSON(): U[] { return this.list.map(it => it.toJSON()) }
  static fromJSON(json: U[]): BaseList<T, U> { return new BaseList<T, U>(json.map(it => BaseObject<T>.fromJSON(it))) }
}

如果这个结构起作用的话（但实际上它并没有），那么我的生活就会变得像这样简单：

type IPerson = JSON & {
  // additional fields
}

class Person extends BaseObject<IPerson> {
  get id() { ... }
  get name() { ... }
  // additional getters for other fields
  toJSON(): IPerson { return { ... } }
  static fromJSON(json: IPerson): Person { return new Person(...) }
  // additional methods
}

class PersonList extends BaseList<Person, IPerson> {
  // additional methods
}

// other object and list types definitions follow

然而，我的解决方案在以下几个点上失败：

1. BaseObject 不能有抽象静态的 fromJSON() 方法。
2. BaseList 不能有抽象静态的 fromJSON() 方法。
3. BaseList.fromJSON() 不能实例化新的列表，也不能调用 BaseObject.fromJSON() 实例化新对象。

我该如何避开这些问题？我是否错过了更好的设计模式？

- AweSIM

---

请参阅 https://dev59.com/8pvga4cB1Zd3GeqPwRFV。 - Francis M. Bacon

Answer 1

由于我无法定义静态抽象函数，所以这里是我采用的实现方式：

type BaseJson = {
    id: string;
}
abstract class BaseObj<U> {
    abstract get id(): string;
    abstract toJSON(): U;
}
abstract class BaseList<T extends BaseObj<U>, U> {
    list: BaseObj<U>[] = [];
    add(x: BaseObj<U>) { this.list.push(x) }
    remove(x: BaseObj<U>) { this.list = this.list.filter(it => it !== x) }
    toJSON(): U[] { return this.list.map(it => it.toJSON()) }
}

type IPerson = BaseJson & {
    name: string;
}
class Person extends BaseObj<IPerson> {
    data: IPerson;
    constructor(data: IPerson) { super(); this.data = data }
    get id() { return this.data.id }
    get name() { return this.data.name }
    toJSON(): IPerson { return { id: this.id, name: this.name } }
    static fromJSON(json: IPerson): Person { return new Person(json) }
}
class PersonList extends BaseList<Person, IPerson> {
    constructor(list: Person[]) { super(); this.list = list }
    static fromJSON(json: IPerson[]): PersonList { return new PersonList(json.map(it => Person.fromJSON(it))) }
}

底线：我将不得不在所有我的对象和列表类中定义静态的fromJSON()方法。这些方法并不是那么复杂，因此这是一个舒适的双赢局面。=)

- AweSIM

---

不介意的话，能否请您解释一下您的解决方案。我认为这可能会增加您回答的实用性。 - J-Cake