在 TypeScript 中使用子类工厂模式时，超类应该是什么类型？

Question

我正在尝试在 TypeScript 3.x 中实现子类工厂模式。 考虑这个测试：

import { expect } from 'chai'

describe('subclass factory', () => {
  it('should work', () => {
    interface INameable {
      name?: string
    }

    const name = 'I am a Nameable!'

    function nameableSubclassOf<T> (superclass) {
      return class extends superclass implements INameable {
        name?: string = name
      }
    }

    class Foo {}

    const NameableFoo = nameableSubclassOf(Foo)
    const nameableFoo = new NameableFoo()

    expect(nameableFoo).to.be.instanceOf(Foo)
    expect(nameableFoo.name).to.be.ok
    expect(nameableFoo.name).to.equal(name)
  })
})

编译失败并显示以下消息：

TSError：⨯ 无法编译 TypeScript：

src/test/subclass-factory.ts(11,37)：错误 TS7006：参数“超类”隐含地具有“任何”类型。

如何更改上述代码以成功编译并返回class，它是T 的子类，同时声明它实现了INameable？

Answer 1

我认为你的选择是要么告诉 Typescript superclass 是 newable，其语法是 briefly alluded to in the TypeScript handbook：

// "new (...args: any[]) => any" means the constructor takes any number of arguments 
// and returns anything

function nameableSubclassOf<C extends new (...args: any[]) => any>(superclass: C) {
  return class extends superclass implements INameable {
    name?: string = name
  }
}

这应该允许编译器为nameableSubclassOf 的返回值推断出一个可用但相当不透明的类型：

const NameableFoo = nameableSubclassOf(Foo)
// const NameableFoo: {
//   new (...args: any[]): nameableSubclassOf<typeof Foo>.(Anonymous class);
//   prototype: nameableSubclassOf<any>.(Anonymous class);
// } & typeof Foo ?

const nameableFoo = new NameableFoo();
// const nameableFoo: nameableSubclassOf2<typeof Foo>.(Anonymous class) & Foo; ?

const fooName = nameableFoo.name;
// const fooName: string | undefined; ?

---

... 或者，如果您想要一个不依赖匿名类的更明确的类型，您可以使用泛型指定超类并使用conditional types 提取构造函数参数并从中返回类型：

function nameableSubclassOf<C extends new (...args: any[]) => any>(
  superclass: C
): C extends new (...args: infer A) => infer T ? new (...args: A) => T & INameable : never;
function nameableSubclassOf(
  superclass: new (...args: any[]) => any
): new (...args: any[]) => INameable {
  return class extends superclass implements INameable {
    name?: string = name
  }
}

请注意，我使用单个 overload 作为函数调用签名，这是调用者看到的。实现签名更宽松，因为编译器很难验证值是否可分配给条件类型......所以单签名重载是一种无需使用即可为函数调用者获得更多类型安全性的方法在实现中加载大量type assertions。

这更冗长，但是当你使用它时，你会得到更好的类型：

const NameableFoo = nameableSubclassOf(Foo)
// const NameableFoo: new () => Foo & INameable ?

const nameableFoo = new NameableFoo()
// const nameableFoo: Foo & INameable ?

const fooName = nameableFoo.name
// const fooName: string | undefined ?

---

希望其中之一有所帮助。祝你好运！

Answer 2

这边？

function nameableSubclassOf(superclass: {new(): any}) {