Início / coding / Perguntas / 77025389
Accepted
Brother58697
Asked: 2023-09-02 02:41:08 +0800 CST

Os tipos de parâmetros genéricos não são restringidos quando restringidos por outros

  • 772

Minha função tem um parâmetro genérico Te outro parâmetro restrito com base no passado T.

Exemplo:

const foo = {
  a: 'hello',
  b: 'world',
} as const

function bar<T extends object, K extends keyof T>(obj: T, key1: K, key2: K) {};

bar(foo, 'a', 'b') // No error, even though key1 should narrow K to 'a'. K stays 'a'|'b'

Meu objetivo é, em última análise, passar um objeto, restringir outros parâmetros com base em seu tipo e inferir seus valores quando eles são passados ​​para restringir ainda mais outros parâmetros:

  • Parâmetros passados ​​inferem Te restringemK
  • O segundo parâmetro passado infere Ke restringeV
  • etc.
typescript

1 respostas

  1. Best Answer

    Há uma compensação quando existem vários candidatos a inferência para um argumento de tipo genérico . Se você tiver uma função como

    declare function f<T>(x: T, y: T): void;

    e alguém liga

    declare const a: A;
declare const b: B;
f(a, b); // <-- ?

    o que deveria acontecer? Em um extremo, o compilador poderia rejeitar qualquer chamada em que Ae Bnão sejam de tipos idênticos. No outro extremo, poderia aceitar qualquer coisa sintetizando o tipo união A | B . Existem casos de uso para qualquer comportamento e para algo intermediário, e pessoas diferentes desejam coisas diferentes em momentos diferentes.

    Atualmente, o TypeScript usa apenas regras heurísticas que funcionam bem em uma ampla variedade de cenários do mundo real, mas que às vezes decepcionam as pessoas.

    A heurística é principalmente que os tipos de união não serão sintetizados a menos que os múltiplos candidatos façam parte do mesmo tipo primitivo. Portanto, se em vez de "a"e "b"(ambas as strings) você usasse "a"and 3(uma string e um número), obteria o erro esperado:

    const foo = {
  a: 'hello',
  b: 'world',
  3: 'abc'
} as const

function bar<T extends object, K extends keyof T>(
  obj: T, key1: K, key2: K) { };

bar(foo, 'a', 3) // error
// ---------> ~  3 is not assignable to 'a'

    Mas quando ambos os tipos são tipos literais que seriam ampliados para o mesmo tipo primitivo, como "a"e "b"são ambos subtipos de string, o TypeScript sintetiza tipos de união para permitir que ele tenha sucesso, como você viu.

    Não é isso que você deseja, mas, novamente, essas são heurísticas que funcionam bem em muitos outros casos.

    Então, existe uma maneira de dizer ao compilador que você deseja outra coisa? Nesse caso, você gostaria de dizer " key2só deve ser verificado em relação ao tipo Kinferido de key1. Não deve ser usado para inferir Ka si mesmo". Ou seja, key2deve ser um "uso de parâmetro de tipo não inferencial", como um NoInfer<T>tipo de utilitário hipotético solicitado em microsoft/TypeScript#14829 :

    function bar<T extends object, K extends keyof T>(
  obj: T, key1: K, key2: NoInfer<K>) { };

bar(foo, 'a', 'b') // error
// ---------> ~~~ 'b' not assignable to 'a'

    Esse é um problema em aberto, então no momento não há implementação nativaNoInfer<T> do . Felizmente, existem várias abordagens discutidas que você pode usar para defini-lo sozinho, o que funciona para alguns casos de uso (mas nada parece funcionar em todos os lugares). Uma maneira descrita aqui é:

    type NoInfer<T> = T & {}

    que atribui NoInfer<T>uma prioridade de inferência mais baixa em comparação com Te, portanto, o compilador tenderá a inferir de Te não de NoInfer<T>. Se você escrever dessa maneira, obterá o comportamento desejado.

    Outra abordagem é apenas declarar outro parâmetro de tipo restrito ao primeiro. Isso bloqueará a inferência também:

    function bar<T extends object, K1 extends keyof T, K2 extends K1>(
  obj: T, key1: K1, key2: K2
) { };

bar(foo, 'a', 'b') // error

    De qualquer forma, deve funcionar, pelo menos para o código de exemplo da pergunta.

    Link do Playground para o código

    • 2

relate perguntas