Início / coding / Perguntas / 79555663
Accepted
Harald
Asked: 2025-04-04 23:00:08 +0800 CST

Digitação de função genérica para criar n-tuplas de parâmetros e chamar um consumidor

  • 772

Considere o seguinte pseudo-TypeScript, onde Classdenota algo parecido com um construtor:

function convert<C extends Class>(
  stuff: unknown,
  mappers: [Mapper<unknown, parameter i of constructor C>],
  c: constructor of C
): C {
  return c(...mappers.map((f) => f(stuff))
}

A ideia é que cada um mapperextraia um parâmetro do construtor stuffe a tupla de resultado seja passada ao construtor.

Nesta forma simples seria um tanto bobo, pois eu sempre poderia chamar o construtor como new C(map1(stuff), map2(stuff), ...)em vez de chamar esta construção elaborada. Mas uma vez que eu tenha o acima, eu quero adicionar tratamento de erro para os mapeadores de forma que o construtor seja chamado somente se nenhum tiver um problema.

O que tenho até agora:

type Class = abstract new (...args: any) => any;
type Func<A, C> = (a: A) => C;
type FuncTuple<A, TUP> = { [P in keyof TUP]: Func<A, TUP[P]> };
type ParamFuncTuple<A, C extends Class> = FuncTuple<A, ConstructorParameters<C>>;

function boo<C extends Class>(
  text: unknown,
  funcs: ParamFuncTuple<unknown, C>,
  c: Class
) {
  const params = funcs.map((f) => f(text))
}

Aqui o compilador diz const paramshas type any[]o que não é muito promissor. Isso é possível?

typescript

1 respostas

  1. Best Answer

    Eu sugeriria escrever a assinatura de chamada convert()assim:

    declare function convert<T, A extends any[], O extends object>(
  mapperArg: T,
  mappers: { [I in keyof A]: (mapperArg: T) => A[I] },
  ctor: new (...args: A) => O
): O;

    Existem três parâmetros de tipo genéricoT : corresponde à entrada para os mapeadores (você chamou assim, stuffmas eu nomeei mapperArgaqui); Acorresponde à tupla de tipos de parâmetros do construtor; e Ocorresponde ao tipo de instância construído.

    O importante aqui é que o tipo de mappersé um tipo de tupla mapeado sobre os índices de A; para cada índice Ido Atipo de tupla, onde A[I]é o tipo de elemento de Anaquele índice, o tipo de elemento de mappersnaquele índice é o tipo de função (mapperArg: T) => A[I].

    Vamos testar essa digitação:

    class Foo {
  a: string; b: number; c: boolean;
  constructor(a: string, b: number, c: boolean) {
    this.a = a;
    this.b = b;
    this.c = c;
  }
}

const foo = convert("hello", [s => s, s => s.length, s => s.length < 4], Foo);
// convert<string, [a: string, b: number, c: boolean], Foo>
// mappers: [a: (m: string) => string, b: (m: string) => number, c: (m: string) => boolean]
// const foo: Foo;

    Aqui o TypeScript infere que Té string, que Oé (o tipo de instância) Fooe que Aé o tipo de tupla [a: string, b: number, c: boolean]. Portanto, o tipo de mappersé computado para ser o tipo de tupla mapeado [a: (mapperArg: string) => string, b: (mapperArg: string) => number, c: (mapperArg: string) => boolean], conforme desejado.

    Quanto à implementação de convert(), poderia ser assim:

    function convert<T, A extends any[], O extends object>(
  mapperArg: T,
  mappers: { [I in keyof A]: (mapperArg: T) => A[I] },
  ctor: new (...args: A) => O
): O {
  return new ctor(...(mappers.map(fn => fn(mapperArg)) as A));
}

    Observe que o resultado de mappers.map(fn => fn(mapperArg))tem que ser afirmado como A; não é realmente possível para o compilador TypeScript verificar se o resultado é do tipo A, porque o sistema de tipos não é expressivo o suficiente para capturar o que Array.prototype.mapacontece com tipos de tupla arbitrários para funções de retorno de chamada arbitrárias. Veja Mapeando valor de tipo de tupla para valor de tipo de tupla diferente sem conversões . Você se deparou com isso com const paramshas type any[]; pode não ser promissor, mas também não é realmente evitável, então é razoável usar uma única afirmação de tipo e seguir em frente.

    Link do playground para o código

    • 2

relate perguntas