Início / coding / Perguntas / 79495939
Accepted
user29889977
Asked: 2025-03-09 21:00:33 +0800 CST

Como você retorna uma classe em TypeScript com sua interface intacta? [duplicado]

  • 772

Gostaria de criar uma classe chamável que Foo(...args)seja idêntica e new Foo(...args)ao mesmo tempo mantenha a verificação de tipo do TypeScript satisfatória.

Em tempo de execução, isso é fácil, basta encapsular a classe com um Proxy implementando apply.

O problema é que qualquer função que retorna um Proxy não pode especificar o tipo de classe e a interface da classe passada.

No TypeScript, a class Foo ...expressão cria um valor like const Foo = ... e uma interface like interface Foo ...ao mesmo tempo.

Mas não consigo adicionar a interface ao tipo de retorno da função wrapper.

const Foo = wrap(class Foo {
  x
  y
  constructor(x: number, y: number) {
    this.x = x
    this.y = y
  }
})

function wrap<T>(ctor: T): T {
  return ctor
}

const foo: Foo = new Foo(1, 2)

Esta última linha dá o erro:

'Foo' se refere a um valor, mas está sendo usado como um tipo aqui. Você quis dizer 'typeof Foo'?ts(2749)

Mas adicionar typeof é claramente a solução errada, pois significaria o próprio Foo.

Posso resolver isso retirando a classe do wrapper:

class _Foo {
  x
  y
  constructor(x: number, y: number) {
    this.x = x
    this.y = y
  }
}

const Foo = wrap(_Foo)
interface Foo extends _Foo { }

function wrap<T>(ctor: T): T {
  return ctor
}

const foo: Foo = new Foo(1, 2)

Mas isso tem três problemas:

  1. Requer que eu use o nome _Fooque é simplesmente feio
  2. Requer que a classe esteja no contexto do valor de retorno de wrap()
  3. Requer muitas repetições da palavra Foo(cinco vezes!)

Sugestões sobre como resolver isso?

typescript

1 respostas

  1. Best Answer

    Eu recomendaria não usar essa abordagem porque:

    1. Isso parece quase impossível
    2. Usar um proxy afetará o desempenho e o impacto pode ser crítico. Por exemplo, se você quiser criar instâncias de classe a partir de 1.000 itens retornados de um banco de dados, Proxyisso pode reduzir o desempenho em cerca de 6 vezes.
    3. Você não tem habilidade para estender a classe normalmente

    Uma função de fábrica seria suficiente e suportaria herança e, portanto, manutenção/extensão:

    Parque infantil

    
class Foo{
  static create<T extends new (...args: any ) => any>(this: T, ...args: ConstructorParameters<T>){
    return new this(...args) as InstanceType<T>;
  }
  constructor(public x: number){
    
  }
  log(){
    console.log(`I'm a ${this.constructor.name} with ${JSON.stringify(this)}`);
  }
}

const foo = Foo.create(1);
foo.log();

class Bar extends Foo{
  constructor(x: number, public y: string){
    super(x);
  }
}

const bar = Bar.create(1, 'string');
bar.log();
    • 1

relate perguntas