Início / coding / Perguntas / 78160759
Accepted
Oktay Yuzcan
Asked: 2024-03-14 21:08:39 +0800 CST

A função genérica obtém o tipo mesmo que não seja fornecida

  • 772

Não entendo por que uma função genérica obtém o tipo genérico automaticamente, sem fornecer nada a ela.

type T<G = Record<string, any>> = {
     id: keyof G
     label: string
     somethingElse?: string
}

Esta função retorna um objeto que possui uma propriedade especial id, que deverá ter um tipo "random"se sourcea propriedade não for passada para ele. Se sourcefor aprovado, o retornado iddeverá obter o tipo desource

const element = <ID extends string = 'random'>({ source }: { source?: ID } = {}) =>
    ({
        id: (source || 'random') as ID,
        label: 'Element1',
    }) as const satisfies T  
    // I don't want the return type to be "T", I want what it returns to satisfy "T".
    // as you see I dont provide "somethingElse" key here, so I don't want it in the return type

type Data = { a: string; b: number }

Isso me dá o erro exato que desejo, mas apenas se eu usar variáveis:

const el1 = element()                   // el1 gets type { readonly id: "random";  readonly label: "Element1"; }
const el2 = element({source: 'b'})     // el2 gets type { readonly id: "b";  readonly label: "Element1"; }
const el3 = element({source: 'else'})   // el3 gets type { readonly id: "else";  readonly label: "Element1"; }

const b: T<Data>[] = [el, el2, el3]   // el1 and el3 invalid, el2 valid. It is all correct

Mas por que isso é válido quando eu uso diretamente sem variável? Deve gerar um erro

const a: T<Data>[] = [element()]   
// No generic or property is provided to it "element()", 
// why the return type of "element()" is { readonly id: keyof Data; readonly label: "Element1"; } ??

Parque TypeScript

typescript

1 respostas

  1. Best Answer

    TypeScript pode usar tipos de retorno de função como alvos de inferência , o que significa que uma função genérica pode ter seus parâmetros de tipo inferidos pelo tipo contextual de seu retorno, bem como pelos tipos conhecidos de seus argumentos. Em

    const a: T<Data>[] = [element()]

    o compilador espera [element()]ser do tipo T<Data>[]e, portanto, element()ser do tipo T<Data>e, portanto , IDser keyof Datae não há erro.

    Se você não gosta disso e deseja que o tipo de retorno não seja usado como site de inferência, você pode usar o NoInfertipo de utilitário para bloquear a inferência dessa posição:

    const element = <ID extends string = 'random'>({ source }: { source?: ID } = {}) =>
   ({
       id: (source || 'random') as NoInfer<ID>, // <-- here
       label: 'Element1',
   }) as const satisfies T

    Nos casos em que IDnão foi inferido a partir do tipo de retorno, isso não deverá ter efeito e todos os outros exemplos são iguais:

    const el1 = element()             
// el1 gets type { readonly id: "random";  readonly label: "Element1"; }. 
const el2 = element({source: 'b'})   
// el2 gets type { readonly id: "b";  readonly label: "Element1"; }.
const el3 = element({source: 'else'})   
// el3 gets type { readonly id: "else";  readonly label: "Element1"; }.
const b: T<Data>[] = [el1, el2, el3]   // el1 and el3 invalid, el2 valid.

    Mas agora você obtém o erro desejado no seu último exemplo, já que o T<Data>contexto não afeta ID. E como IDagora não tem nenhum site de inferência, ele volta ao padrão"random" :

    const a: T<Data>[] = [element()]  // error!
// Type '{ readonly id: "random"; readonly label: "Element1"; }' 
// is not assignable to type 'T<Data>'.

    Link do Playground para o código

    • 1

relate perguntas