Início / coding / Perguntas / 76923047
Accepted
land
Asked: 2023-08-17 23:37:46 +0800 CST

Por que usamos colchetes `[]` em condicionais?

  • 772

Neste exemplo:

type Action<T extends string, P = never> = {
  type: T;
} & ([P] extends [never]
  ? {}
  : {
      payload: P;
    });

Por que precisamos de colchetes em torno do condicional [P] extends [never]e qual é a diferença se não o usarmos assim P extends never?

Entendo o que esse tipo está fazendo, mas não consigo encontrar uma explicação sobre por que realmente precisamos de colchetes e por que não funciona sem eles.

EDIT: Deixe-me tentar com um exemplo mais simples:


type GetTest<T = never> = [T] extends [never] ? string : number;

type Test = GetTest; // type Test = string;

Aqui está type Test = stringo esperado. Mas o que não entendi é o que acontece com a condição quando não temos colchetes, não obtemos, stringmas também não obtemos um number, em vez disso, obtemostype Test = never

type GetTest<T = never> = T extends never ? string : number;

type Test = GetTest; // type Test = never
typescript

1 respostas

  1. Best Answer

    Se você tiver um tipo condicional em que o tipo que está sendo verificado (à esquerda de extends) é um parâmetro de tipo genérico , ele se torna um tipo condicional distributivo . Então em

    type GetTestDist<T = never> = T extends never ? string : number;
type GetTestNonDist<T = never> = [T] extends [never] ? string : number;

    GetTestDist<T>é um tipo condicional distributivo porque Té um parâmetro de tipo genérico, enquanto GetTestNonDist<T>não é porque [T]não é um parâmetro de tipo genérico.

    Sim, [T] envolve o parâmetro de tipo genérico T, mas não é um parâmetro de tipo em si. Às vezes, as pessoas dizem que o Tin T extends never ? ⋯ : ⋯é um parâmetro de tipo nu ou um parâmetro de tipo nu , em oposição ao Tin [T] extends [never] ? ⋯ : ⋯, que é, digamos, "vestido".

    Portanto, um tipo condicional em que o tipo que está sendo verificado é um parâmetro de tipo nu é um tipo condicional distributivo. Mas o que isso significa?

    Quando uma função de tipo F<T>é um tipo condicional distributivo, a operação distribui sobre as uniões em T, o que significa que ela atua em cada membro da união individualmente e junta o resultado novamente em uma união. Então, por exemplo, F<A | B | C>será avaliado como o mesmo que F<A> | F<B> | F<C>.

    Além disso, o nevertipo é considerado a união vazia , portanto, F<never>sempre será, nevernão importa o que aconteça. (consulte o comentário relevante em microsoft/TypeScript#23182 para obter uma fonte confiável).

    Este tratamento neverpode ser confuso, mas é consistente. O nevertipo é absorvido pelas uniões: isto é, X | neveré reduzido a Xnão importa o que Xseja. (Se você tiver um valor xdo tipo , X | neverentão xé do tipo Xou do tipo never, mas não há valores do tipo never, portanto, x deve ser do tipo X. Portanto, todos os valores atribuíveis a X | neverdevem ser atribuíveis a X, e o verificador de tipo observa isso absorvendo neverem unions. Consulte Por que nunca é atribuível a todos os tipos? para obter mais informações.) Você pode pensar nisso nevercomo o elemento de identidade da operação de união.

    Portanto, se X | neveré equivalente a never, então F<X>e F<X | never>são iguais. Se F<T>é distributivo, então F<X | never>é equivalente a F<X> | F<never>. Isso implica F<X>é o mesmo que F<X> | F<never>para todos X. A maneira mais fácil de isso ser verdade é if F<never>is just never.

    (Por analogia, imagine que você tem uma função matemática ?(?) que é distributiva sobre a adição , de modo que ?(?) + ?(?) = ?(?+?). A adição tem um elemento de identidade: 0, porque ?+ 0 = ?. Isso implica que ?(0) deve ser 0, porque ?(?) + ?(0) = ?(?+0) = ?(?). 0 é "a soma vazia" e é "a soma nevervazia União".)

    Muitas vezes, o comportamento distributivo é desejado, mas às vezes não é. A maneira de desativar esse comportamento é, portanto, "vestir" o parâmetro de tipo nu e o tipo que você está verificando com alguma função de tipo covarianteC<T> . (Consulte Diferença entre variação, covariância, contravariância e bivariância no TypeScript para obter mais informações sobre variação).

    type Distrib<T> = T extends U ? X : Y
type NonDistrib<T> = C<T> extends C<U> ? X : Y

    Você precisa fazer isso em ambos os lados extendsde modo que esteja fazendo a mesma verificação (se C<T>for covariante em Tentão C<A> extends C<B>implica A extends B). Qualquer "roupa" covariante será suficiente aqui.

    Mas se você está procurando as roupas "mais curtas" para economizar o máximo de pressionamentos de tecla possível, use [T]. Para o bem ou para o mal, o TypeScript considera os tipos de matriz como covariantes (consulte Por que as matrizes do TypeScript são covariantes? ), e uma tupla de um elemento é um tipo de matriz. Não há nada mais "correto" sobre o uso [T]de qualquer outra função de tipo covariante, é apenas o mais conveniente.

    E, portanto, geralmente é recomendado que, se você quiser desativar a distribuição sobre uniões em um tipo condicional, envolva os dois lados do extendscom [⋯ ]:

    type Distrib<T> = T extends U ? X : Y
type NonDistrib<T> = [T] extends [U] ? X : Y
    • 2

relate perguntas