TypeScript：继承类中静态方法的自引用返回类型

Question

使用 TypeScript 1.7 中的Polymorphic this，正如我发现的here，我们可以在返回类型为this 的类中定义一个方法，并且自动地，任何扩展该类并继承方法的类将将它们的返回类型设置为各自的this 类型。像这样：

class Model {
  save():this {    // return type: Model
    // save the current instance and return it
  }
}

class SomeModel extends Model {
  // inherits the save() method - return type: SomeModel
}

但是，我所追求的是继承static 方法，其返回类型引用类本身。最好在代码中描述：

class Model {
  static getAll():Model[] {
    // return all recorded instances of Model as an array
  }

  save():this {
    // save the current instance and return it
  }
}

class SomeModel extends Model {
  // inherits the save() method - return type: SomeModel
  // also inherits getAll() - return type: Model (how can we make that SomeModel?)
}

也许我必须想出一种不同的方法来实现它，因为 TypeScript 1.7 中的多态 this 不支持 static 方法设计。

编辑：我想我们会看到这个 Github 问题如何结束：https://github.com/Microsoft/TypeScript/issues/5863

Answer 1

这在 TypeScript 2.0+ 中是可行的。通过使用内联 { new(): T } 类型来捕获 this，您将得到您想要的：

type Constructor<T> = { new (): T }

class BaseModel {
  static getAll<T>(this: Constructor<T>): T[] {
    return [] // dummy impl
  }
  
  /**
   * Example of static method with an argument:
   */
  static getById<T>(this: Constructor<T>, id: number): T | undefined {
    return // dummy impl
  }

  save(): this {
    return this // dummy impl
  }
}

class SubModel extends BaseModel {}

const sub = new SubModel()
const savedSub: SubModel = sub.save()

// Behold: SubModel.getAll() returns SubModels, not BaseModel
const savedSubs: SubModel[] = SubModel.getAll()

请注意，getAll 仍然不希望这种类型的参数。

有关详细信息，请参阅https://www.typescriptlang.org/docs/handbook/2/generics.html#using-class-types-in-generics 和 https://stackoverflow.com/a/45262288/1268016

Answer 2

基于simplest answer 到GitHub issue，您可以像这样使用InstanceType<>：

class Foo {
    static create<T extends typeof Foo>(this: T): InstanceType<T> {
        return new this() as InstanceType<T>
    }

    static getAll<T extends typeof Foo>(this: T): Array<InstanceType<T>> {
        return []
    }
}

class Bar extends Foo { }

const a = Bar.getAll() // typeof a is Bar[]
const b = Bar.create() // typeof b is Bar.

我在链接的 GitHub 示例中放入 create 函数只是为了说明。

Answer 3

基于Brains answer，您可以直接使用返回类型

(typeof Class)['foo']

示例：

export class MyClass {
    myFunction(param:string):number{
        return typeof param === "string"?1:0
    }
                                             /** Just class['foo'] to normal methods */   
    static myStaticFunctions(cards: string): Parameters<MyClass['MyFunction']>[0] {
                        /** and *(typeof class)* ['foo'] to static methods */   
        const typedReturn: ReturnType<(typeof MyClass)['myStaticFunctions']> = "works"
        return typedReturn
        
    }
}

Answer 4

你期望这个静态方法在继承的子类中返回什么？是不是这样的：

class A {
    private static _instances = new Array<A>();
    static instances(): A[] { return A._instances; }
    constructor() { A._instances.push(this); }
}

class B extends A {

    static instances(): B[] { 
        return <B[]>(A.instances().filter(i => i instanceof B)); 
    }
    constructor() { super(); }; 
}

var a = new A();
var b = new B();

console.log(
     "A count: " + A.instances().length + 
    " B count: " + B.instances().length);

这将输出“A 计数：2 B 计数：1”。或者你期待什么？