No centro da maioria dos programas úteis, precisamos tomar decisões com base na entrada. Programas JavaScript não são diferentes, mas, como os valores podem ser facilmente inspecionados, essas decisões também se baseiam nos tipos das entradas. Tipos condicionais ajudam a descrever a relação entre os tipos de entradas e saídas.
tsTryinterfaceAnimal {live (): void;}interfaceDog extendsAnimal {woof (): void;}typeExample1 =Dog extendsAnimal ? number : string;typeExample2 =RegExp extendsAnimal ? number : string;
Tipos condicionais têm uma forma parecida com expressões condicionais (condição ? expressãoVerdadeira : expressãoFalsa) do JavaScript:
tsTrySomeType extendsOtherType ?TrueType :FalseType ;
Quando o tipo à esquerda de extends é atribuível ao da direita, você recebe o tipo do primeiro ramo (o ramo “verdadeiro”); caso contrário, recebe o tipo do ramo final (o ramo “falso”).
Pelos exemplos acima, tipos condicionais podem não parecer úteis de imediato: podemos verificar se Dog extends Animal e escolher number ou string!
Mas o poder dos tipos condicionais vem de usá-los com genéricos.
Por exemplo, vamos pegar a seguinte função createLabel:
tsTryinterfaceIdLabel {id : number /* some fields */;}interfaceNameLabel {name : string /* other fields */;}functioncreateLabel (id : number):IdLabel ;functioncreateLabel (name : string):NameLabel ;functioncreateLabel (nameOrId : string | number):IdLabel |NameLabel ;functioncreateLabel (nameOrId : string | number):IdLabel |NameLabel {throw "unimplemented";}
Essas sobrecargas de createLabel descrevem uma única função JavaScript que faz uma escolha com base nos tipos de suas entradas. Observe alguns pontos:
- Se uma biblioteca precisa fazer o mesmo tipo de escolha repetidas vezes ao longo da sua API, isso fica trabalhoso.
- Precisamos criar três sobrecargas: uma para cada caso em que temos certeza do tipo (uma para
stringe outra paranumber), e uma para o caso mais geral (que recebestring | number). Para cada novo tipo quecreateLabelpassa a tratar, o número de sobrecargas cresce exponencialmente.
Em vez disso, podemos codificar essa lógica em um tipo condicional:
tsTrytypeNameOrId <T extends number | string> =T extends number?IdLabel :NameLabel ;
Podemos então usar esse tipo condicional para reduzir nossas sobrecargas a uma única função, sem sobrecargas.
tsTryfunctioncreateLabel <T extends number | string>(idOrName :T ):NameOrId <T > {throw "unimplemented";}leta =createLabel ("typescript");letb =createLabel (2.8);letc =createLabel (Math .random () ? "hello" : 42);
Restrições em tipos condicionais
Muitas vezes, as verificações em um tipo condicional nos dão alguma informação nova. Assim como o estreitamento com type guards pode nos dar um tipo mais específico, o ramo verdadeiro de um tipo condicional restringe ainda mais os genéricos pelo tipo com que verificamos.
Por exemplo, considere o seguinte:
tsTrytypeType '"message"' cannot be used to index type 'T'.2536Type '"message"' cannot be used to index type 'T'.MessageOf <T > =T ["message"];
Neste exemplo, o TypeScript gera erro porque não se sabe que T tem uma propriedade chamada message.
Poderíamos restringir T, e o TypeScript deixaria de reclamar:
tsTrytypeMessageOf <T extends {message : unknown }> =T ["message"];interfacemessage : string;}typeEmailMessageContents =MessageOf <
No entanto, e se quiséssemos que MessageOf aceitasse qualquer tipo, e usasse como padrão algo como never caso a propriedade message não esteja disponível?
Podemos fazer isso movendo a restrição para fora e introduzindo um tipo condicional:
tsTrytypeMessageOf <T > =T extends {message : unknown } ?T ["message"] : never;interfacemessage : string;}interfaceDog {bark (): void;}typeEmailMessageContents =MessageOf <typeDogMessageContents =MessageOf <Dog >;
No ramo verdadeiro, o TypeScript sabe que T vai ter uma propriedade message.
Como outro exemplo, poderíamos também escrever um tipo chamado Flatten que achata tipos de array para os tipos de seus elementos, mas deixa os demais tipos como estão:
tsTrytypeFlatten <T > =T extends any[] ?T [number] :T ;// Extracts out the element type.typeStr =Flatten <string[]>;// Leaves the type alone.typeNum =Flatten <number>;
Quando Flatten recebe um tipo de array, ele usa um acesso indexado com number para obter o tipo do elemento de string[].
Caso contrário, simplesmente retorna o tipo que recebeu.
Inferindo dentro de tipos condicionais
Acabamos de usar tipos condicionais para aplicar restrições e depois extrair tipos. Essa operação acaba sendo tão comum que os tipos condicionais facilitam isso.
Tipos condicionais nos dão uma forma de inferir a partir dos tipos com que comparamos, no ramo verdadeiro, usando a palavra-chave infer.
Por exemplo, poderíamos ter inferido o tipo do elemento em Flatten em vez de buscá-lo “manualmente” com um tipo de acesso indexado:
tsTrytypeFlatten <Type > =Type extendsArray <inferItem > ?Item :Type ;
Aqui, usamos a palavra-chave infer para introduzir de forma declarativa uma nova variável de tipo genérica chamada Item, em vez de especificar como recuperar o tipo do elemento de Type no ramo verdadeiro.
Isso nos poupa de pensar em como percorrer e desmontar a estrutura dos tipos que nos interessam.
Podemos escrever alguns aliases de tipo auxiliares úteis usando a palavra-chave infer.
Por exemplo, em casos simples, podemos extrair o tipo de retorno de tipos de função:
tsTrytypeGetReturnType <Type > =Type extends (...args : never[]) => inferReturn ?Return : never;typeNum =GetReturnType <() => number>;typeStr =GetReturnType <(x : string) => string>;typeBools =GetReturnType <(a : boolean,b : boolean) => boolean[]>;
Ao inferir a partir de um tipo com várias assinaturas de chamada (como o tipo de uma função sobrecarregada), as inferências são feitas a partir da última assinatura (que, presumivelmente, é o caso geral mais permissivo). Não é possível fazer resolução de sobrecarga com base em uma lista de tipos de argumentos.
tsTrydeclare functionstringOrNum (x : string): number;declare functionstringOrNum (x : number): string;declare functionstringOrNum (x : string | number): string | number;typeT1 =ReturnType <typeofstringOrNum >;
Tipos condicionais distributivos
Quando tipos condicionais atuam sobre um tipo genérico, eles se tornam distributivos quando recebem um tipo união. Por exemplo, considere o seguinte:
tsTrytypeToArray <Type > =Type extends any ?Type [] : never;
Se passarmos um tipo união para ToArray, o tipo condicional será aplicado a cada membro da união.
tsTrytypeToArray <Type > =Type extends any ?Type [] : never;typeStrArrOrNumArr =ToArray <string | number>;
O que acontece aqui é que ToArray distribui sobre:
tsTrystring | number;
e mapeia cada tipo membro da união, resultando efetivamente em:
tsTryToArray <string> |ToArray <number>;
o que nos deixa com:
tsTrystring[] | number[];
Normalmente, a distributividade é o comportamento desejado.
Para evitar esse comportamento, você pode colocar colchetes em cada lado da palavra-chave extends.
tsTrytypeToArrayNonDist <Type > = [Type ] extends [any] ?Type [] : never;// 'ArrOfStrOrNum' is no longer a union.typeArrOfStrOrNum =ToArrayNonDist <string | number>;