Tipos de template literal são construídos sobre tipos de string literal e têm a capacidade de se expandir em muitas strings por meio de uniões.
Eles têm a mesma sintaxe dos template literals de strings em JavaScript, mas são usados em posições de tipo. Quando usado com tipos literais concretos, um template literal produz um novo tipo de string literal, concatenando o conteúdo.
tsTrytypeWorld = "world";typeGreeting = `hello ${World }`;
Quando uma união é usada na posição interpolada, o tipo é o conjunto de todos os string literals possíveis que cada membro da união pode representar:
tsTrytypeEmailLocaleIDs = "welcome_email" | "email_heading";typeFooterLocaleIDs = "footer_title" | "footer_sendoff";typeAllLocaleIDs = `${EmailLocaleIDs |FooterLocaleIDs }_id`;
Para cada posição interpolada no template literal, as uniões são multiplicadas em produto cartesiano:
tsTrytypeAllLocaleIDs = `${EmailLocaleIDs |FooterLocaleIDs }_id`;typeLang = "en" | "ja" | "pt";typeLocaleMessageIDs = `${Lang }_${AllLocaleIDs }`;
Em geral, recomendamos gerar com antecedência as uniões de strings grandes, mas isso é útil em casos menores.
Uniões de strings em tipos
O poder dos template literals aparece quando você define uma nova string com base em informações dentro de um tipo.
Considere o caso em que uma função (makeWatchedObject) adiciona uma nova função chamada on() a um objeto passado para ela.
Em JavaScript, a chamada poderia ser assim:
makeWatchedObject(baseObject). Podemos imaginar que o objeto base seja assim:
tsTryconstpassedObject = {firstName : "Saoirse",lastName : "Ronan",age : 26,};
A função on que será adicionada ao objeto base espera dois argumentos: um eventName (uma string) e um callback (uma function).
O eventName deve ter a forma propriedadeDoObjetoPassado + "Changed"; assim, firstNameChanged é derivado da propriedade firstName do objeto base.
A função callback, quando chamada:
- Deve receber um valor do tipo associado ao nome
propriedadeDoObjetoPassado; assim, comofirstNameé tipada comostring, o callback do eventofirstNameChangedespera receber umastringno momento da chamada. Da mesma forma, eventos associados aagedevem esperar ser chamados com um argumentonumber - Deve ter tipo de retorno
void(por simplicidade da demonstração)
A assinatura ingênua da função on() poderia então ser: on(eventName: string, callback: (newValue: any) => void). No entanto, na descrição anterior, identificamos restrições de tipo importantes que gostaríamos de documentar no nosso código. Tipos de template literal nos permitem trazer essas restrições para o código.
tsTryconstperson =makeWatchedObject ({firstName : "Saoirse",lastName : "Ronan",age : 26,});// makeWatchedObject has added `on` to the anonymous Objectperson .on ("firstNameChanged", (newValue ) => {console .log (`firstName was changed to ${newValue }!`);});
Repare que on escuta o evento "firstNameChanged", e não apenas "firstName". Nossa especificação ingênua de on() poderia ser mais robusta se garantíssemos que o conjunto de nomes de evento elegíveis fosse restrito à união dos nomes de atributos do objeto observado com “Changed” no final. Embora estejamos à vontade para fazer esse cálculo em JavaScript, isto é, Object.keys(passedObject).map(x => `${x}Changed`), template literals dentro do sistema de tipos oferecem uma abordagem semelhante para manipulação de strings:
tsTrytypePropEventSource <Type > = {on (eventName : `${string & keyofType }Changed`,callback : (newValue : any) => void): void;};/// Create a "watched object" with an `on` method/// so that you can watch for changes to properties.declare functionmakeWatchedObject <Type >(obj :Type ):Type &PropEventSource <Type >;
Com isso, podemos construir algo que gera erro quando recebe a propriedade errada:
tsTryconstperson =makeWatchedObject ({firstName : "Saoirse",lastName : "Ronan",age : 26});person .on ("firstNameChanged", () => {});// Prevent easy human error (using the key instead of the event name)Argument of type '"firstName"' is not assignable to parameter of type '"firstNameChanged" | "lastNameChanged" | "ageChanged"'.2345Argument of type '"firstName"' is not assignable to parameter of type '"firstNameChanged" | "lastNameChanged" | "ageChanged"'.person .on ("firstName" , () => {});// It's typo-resistantArgument of type '"frstNameChanged"' is not assignable to parameter of type '"firstNameChanged" | "lastNameChanged" | "ageChanged"'.2345Argument of type '"frstNameChanged"' is not assignable to parameter of type '"firstNameChanged" | "lastNameChanged" | "ageChanged"'.person .on ("frstNameChanged" , () => {});
Inferência com template literals
Repare que não aproveitamos todas as informações fornecidas no objeto original passado. Dada a mudança de um firstName (ou seja, um evento firstNameChanged), devemos esperar que o callback receba um argumento do tipo string. Da mesma forma, o callback para a mudança de age deve receber um argumento number. Estamos usando any de forma ingênua para tipar o argumento do callback. Mais uma vez, tipos de template literal tornam possível garantir que o tipo de dado de um atributo seja o mesmo tipo do primeiro argumento do callback desse atributo.
A ideia-chave que torna isso possível é: podemos usar uma função com um genérico de modo que:
- O literal usado no primeiro argumento seja capturado como um tipo literal
- Esse tipo literal possa ser validado como pertencente à união dos atributos válidos no genérico
- O tipo do atributo validado possa ser buscado na estrutura do genérico usando Indexed Access
- Essa informação de tipo então possa ser aplicada para garantir que o argumento da função callback seja do mesmo tipo
tsTrytypePropEventSource <Type > = {on <Key extends string & keyofType >(eventName : `${Key }Changed`,callback : (newValue :Type [Key ]) => void): void;};declare functionmakeWatchedObject <Type >(obj :Type ):Type &PropEventSource <Type >;constperson =makeWatchedObject ({firstName : "Saoirse",lastName : "Ronan",age : 26});person .on ("firstNameChanged",newName => {console .log (`new name is ${newName .toUpperCase ()}`);});person .on ("ageChanged",newAge => {if (newAge < 0) {console .warn ("warning! negative age");}})
Aqui transformamos on em um método genérico.
Quando o usuário chama com a string "firstNameChanged", o TypeScript tenta inferir o tipo certo para Key.
Para isso, ele compara Key com o conteúdo antes de "Changed" e infere a string "firstName".
Depois que o TypeScript descobre isso, o método on pode buscar o tipo de firstName no objeto original, que neste caso é string.
Da mesma forma, quando chamado com "ageChanged", o TypeScript encontra o tipo da propriedade age, que é number.
A inferência pode ser combinada de diferentes maneiras, muitas vezes para desconstruir strings e reconstruí-las de outras formas.
Tipos intrínsecos de manipulação de strings
Para ajudar na manipulação de strings, o TypeScript inclui um conjunto de tipos que podem ser usados nessa tarefa. Esses tipos vêm integrados ao compilador por questão de desempenho e não podem ser encontrados nos arquivos .d.ts incluídos com o TypeScript.
Uppercase<StringType>
Converte cada caractere da string para sua versão em maiúsculas.
Exemplo
tsTrytypeGreeting = "Hello, world"typeShoutyGreeting =Uppercase <Greeting >typeASCIICacheKey <Str extends string> = `ID-${Uppercase <Str >}`typeMainID =ASCIICacheKey <"my_app">
Lowercase<StringType>
Converte cada caractere da string para o equivalente em minúsculas.
Exemplo
tsTrytypeGreeting = "Hello, world"typeQuietGreeting =Lowercase <Greeting >typeASCIICacheKey <Str extends string> = `id-${Lowercase <Str >}`typeMainID =ASCIICacheKey <"MY_APP">
Capitalize<StringType>
Converte o primeiro caractere da string para o equivalente em maiúsculas.
Exemplo
tsTrytypeLowercaseGreeting = "hello, world";typeGreeting =Capitalize <LowercaseGreeting >;
Uncapitalize<StringType>
Converte o primeiro caractere da string para o equivalente em minúsculas.
Exemplo
tsTrytypeUppercaseGreeting = "HELLO WORLD";typeUncomfortableGreeting =Uncapitalize <UppercaseGreeting >;
Detalhes técnicos sobre os tipos intrínsecos de manipulação de strings
O código, a partir do TypeScript 4.1, dessas funções intrínsecas usa diretamente as funções de string do runtime JavaScript para a manipulação e não é sensível à localidade (locale).
function applyStringMapping(symbol: Symbol, str: string) {
switch (intrinsicTypeKinds.get(symbol.escapedName as string)) {
case IntrinsicTypeKind.Uppercase: return str.toUpperCase();
case IntrinsicTypeKind.Lowercase: return str.toLowerCase();
case IntrinsicTypeKind.Capitalize: return str.charAt(0).toUpperCase() + str.slice(1);
case IntrinsicTypeKind.Uncapitalize: return str.charAt(0).toLowerCase() + str.slice(1);
}
return str;
}