Início / coding / Perguntas / 78816943
Accepted
Carcigenicate
Asked: 2024-07-31 22:35:44 +0800 CST

Tipo de retorno da função base no tipo de variável local

  • 772

Existe uma maneira de definir o tipo de retorno da função para depender do tipo de uma variável local?

Eu tenho um conjunto de métodos de validação:

validateA(things: Thing[]): { badA: string[], badB: number[] }
validateB(things: Thing[]): { anotherBadA: string[], anotherBadB: number[] }

E então eu tenho um wrapper destinado a basicamente executar todos eles e mesclar seus resultados:

validateAllTheThings(things: Thing[]) {
    const problems = {
      ...this.validateA(things),
      ...this.validateB(things),
    };

    return problems;
}

Portanto, validateAllTheThingsdeve ter o tipo de retorno igual ao tipo de problems, que são todos os objetos retornados mesclados.

A maneira mais limpa que encontrei para usar ReturnType:

function validateAllTheThings(things: Thing[]): ReturnType<WrapperClass['validateA']> & ReturnType<WrapperClass['validateB']> {

Mas isso é muito detalhado e não será bem dimensionado. Seria bom se eu pudesse vincular o tipo de retorno da função ao tipo inferido de problems.

typescript

1 respostas

  1. Best Answer

    De modo geral, a maioria dos casos de uso para tipos de retorno de assinatura de chamada são atendidos por:

    • anotar explicitamente o tipo de retorno, de modo que, se os valores retornados no corpo da função mudarem para algo incompatível com o tipo de retorno, você receberá erros; ou:
    • permitindo que o TypeScript infira o tipo de retorno, de modo que, se os valores retornados no corpo da função mudarem, a assinatura da chamada seja atualizada automaticamente, dinamicamente.

    Parece que você está procurando uma maneira de obter parte ou todo o comportamento dinâmico da inferência de tipo e, ao mesmo tempo, anotar explicitamente o tipo de retorno. Não está claro para mim qual caso de uso isso serviria.

    Ainda assim, eu diria que se você está procurando uma maneira de dizer "combinar os tipos de retorno dos seguintes métodos via interseção" de uma forma menos complicada, você poderia escrever um tipo de utilitário para fazer isso:

    type MergeReturns<
    T extends Record<K, (...args: any) => any>,
    K extends keyof T
> = { [P in K]: (x: ReturnType<T[P]>) => void } extends
    Record<K, (x: infer I) => void> ? I : never;

    Este tipo apenas os usa ReturnTypee combina usando uma técnica semelhante à mostrada em Transformar tipo de união em tipo de interseção . E então você pode usá-lo:

    class WrapperClass {
    validateA(things: Thing[]): { badA: string[], badB: number[] } { ⋯ }
    validateB(things: Thing[]): { anotherBadA: string[], anotherBadB: number[] } { ⋯ }
    validateAllTheThings(things: Thing[]):
        MergeReturns<WrapperClass, "validateA" | "validateB"> {
        const problems = {
            ...this.validateA(things),
            ...this.validateB(things),
        };
        return problems;
    }
}

    e você pode verificar se o tipo retornado é equivalente ao tipo desejado:

    type Z = MergeReturns<WrapperClass, "validateA" | "validateB">;
/* type Z = {
    badA: string[];
    badB: number[];
} & {
    anotherBadA: string[];
    anotherBadB: number[];
} */

    Finalmente, considerando a questão pelo valor nominal, você poderia simplesmente anotar o tipo de retorno usando typeofa variável local:

      validateAllTheThings(things: Thing[]): typeof problems {
      const problems = {
          ...this.validateA(things),
          ...this.validateB(things),
      };
      return problems;
  }

    Mas isso só funciona se você não estiver emitindo arquivos de declaração com a --declarationopção do compilador . Caso contrário, você receberá o aviso de que o tipo de retorno declarado se refere a um nome inacessível:

    validateAllTheThings(things: Thing[]): typeof problems { // error!
//                                            ~~~~~~~~
// Return type of public method from exported class 
// has or is using private name 'problems'.
    const problems = {
        ...this.validateA(things),
        ...this.validateB(things),
    };
    return problems;
}

    Então essas são as opções que posso ver. Pessoalmente, prefiro anotar ou permitir inferências e não tentar dividir a diferença, mas pode haver casos de uso em que uma das alternativas seja preferível.

    Link do Playground para o código

    • 1

relate perguntas