O time do TypeScript anunciou recentemente a versão 3.0 do TypeScript, a introdução de uma nova técnica para criação e dimensionamento de projetos, operações sobre lista de parâmetros, novos tipos para impor verificações explícitas, e melhorias na experiência do desenvolvedor no tratamento de erros reportados pelo TypeScript.
O TypeScript 3.0 intencionalmente possui poucas alterações da versão 2.x com a esperança de facilitar a atualização dos projetos. As alterações importantes a serem lembradas ao atualizar incluem:
- unknown foi adicionado como um tipo interno. Assim, a palavra "unkown" é agora um é nome de tipo reservado e não é mais utilizada em declarações de tipos;
- O método interno LanguageService#getSourceFile foi removido depois de ser marcado como obsoleto há dois anos;
- A função TypeChecker#getSymbolDisplayBuilder e suas interfaces associadas foram removidas após um aviso de descontinuação. Estes devem ser substituídos por emmiter e um node builder;
- As funções escapeIdentifier e unescapedIdentifier foram removidas após serem marcadas como obsoletas;
- As funções a seguir foram movidas para os métodos internos do TypeScript e não fazem mais parte da API pública do TypeScript:
TypeChecker#getSuggestionForNonexistentProperty, TypeChecker#getSuggestionForNonexistentSymbol e TypeChecker#getSuggestionForNonexistentModule.
A alteração mais notável no TypeScript 3.0 é a referência a projeto, que reduz a complexidade ao gerenciar múltiplas dependências do TypeScript. Referências a projetos permitem que os arquivos de configuração do TypeScript (tsconfig.json) façam referência a outros arquivos de configuração, ficando mais simples a separação dos diretórios do código fonte em projetos pequenos. O TypeScript e suas ferramentas foram atualizadas para entender as referências a projetos e a ordem em que os projetos são construídos e precisam ser estruturados.
Os principais recursos apresentados como parte da melhoria de referências a projeto incluem construções mais rápidas e incrementais e uma edição e refatoração entre projetos. Dois novos campos foram incluídos no tsconfig.json para suportar referencias a projeto:
- composite: um booleano especificando que um projeto pode ser referenciado e construído de forma incremental.
- references: um objeto na qual o campo de caminho permite que o TypeScript conheça os requisitos do projeto atual construindo uma referência a um projeto antes de ser construído.
Além de permitir que ferramentas de terceiros aproveitem os recursos de compilação incremental do TypeScript, o TypeScript 3.0 também incluiu uma nova flag --build para executar simples operações de compilação.
Maior controle sobre as estruturas de saídas em um projeto é outro benefício de construção para uma nova referência a projetos. Um caso de uso típico apresentando é o código fonte compartilhado entre as aplicações do lado cliente e do lado do servidor. Anteriormente este código deveria ser construído duas vezes e agora com a referência a projetos, o compartilhamento de dependências precisa somente ser construído uma única vez.
Como esse é um recurso muito novo, a equipe do TypeScript espera que outros autores da ferramenta possam suportar facilmente referências a projetos, e o gerente de programa do TypeScript, Daniel Rosenwasser, "para referências de projeto serem tão simples quanto um código de autoria com um único tsconfig.json". A equipe do TypeScript está ativamente buscando feedback sobre como tornar as referências do projeto e as construções mais fáceis de usar.
O projeto TypeScript adiciona tipos de tupla mais ricas, incluindo elementos opcionais, elementos de reestruturação no final da tupla e tipos de tupla vazias. Essas melhorias ajudaram a tornar possível extrair e distribuir listas de parâmetros com tuplas.
O benefício é uma grande redução nas definições complexas de sobrecarga, um ponto problemático significativo nas versões anteriores do TypeScript. Um exemplo fornecido pela equipe do TypeScript mostra que uma definição de tipo que se parecia com:
// TODO : 5 overloads should *probably* be enough for anybody?
function call<T1, T2, T3, T4, R>(fn: (param1: T1, param2: T2, param3: T3, param4: T4) => R, param1: T1, param2: T2, param3: T3, param4: T4): R
function call<T1, T2, T3, R>(fn: (param1: T1, param2: T2, param3: T3) => R, param1: T1, param2: T2, param3: T3): R
function call<T1, T2, R>(fn: (param1: T1, param2: T2) => R, param1: T1, param2: T2): R
function call<T1, R>(fn: (param1: T1) => R, param1: T1): R;
function call<R>(fn: () => R, param1: T1): R;
function call(fn: (...args: any[]) => any, ...args: any[]) {
return fn(...args);
}
Que agora pode ser reduzido para algo mais conciso:
function call(fn: (arg1: number, arg2: string) => string, arg1: number, arg2: string): string
As melhorias na experiência do usuário em caso de erro incluem fornecer contexto adicional sobre a possível fonte dos erros, bem como refinar muitas mensagens de erros mais obtusas em explicações que explicam mais claramente a origem de um erro.
Os usuários do JSX no React e outras implementações de DOM virtual também se beneficiam de mais aprimoramentos no tratamento de JSX do TypeScript, em particular o suporte para defaultProps.
O tipo unknown é uma resposta ao uso excessivo de qualquer tipo. Os desafios com qualquer tipo, de acordo com Rosenwasser:
O tipo any é o tipo com maior capacidade no TypeScript - embora englobe o tipo de todo valor possível, ele não nos força a fazer nenhuma verificação antes de tentarmos chamar, construir ou acessar propriedades nesses valores. Também nos permite atribuir valores do tipo any a valores que esperam qualquer outro tipo. Isso é muito útil, mas pode ser um pouco negligente.
Nos cenários em que os desenvolvedores desejam explicar que algo pode ter algum valor, mas alguma verificação deve ser realizada antes de usá-lo para evitar mais problemas, eles são encorajados a usar o tipo unknown. Ao contrário de any, o tipo unknown é atribuído a quase nada mais sem uma afirmação de tipo.
O TypeScript 3.0 oferece vários refinamentos e melhorias adicionais.
O suporte da comunidade para o TypeScript e a versão 3.0 está crescendo, com muitos projetos proeminentes que dependem do TypeScript, incluindo Angular, Dojo, Ionic, Stencil, Deno e Nest.js. O CEO da Ionic, Max Lynch, escreveu recentemente um artigo sobre como construir uma empresa em torno do TypeScript:
Agora estou completamente arrebatado, usando o TypeScript para cada projeto de frontend em que já trabalhei e para cada projeto que criamos na Ionic.
Para começar com o TypeScript, instale-o usando o npm:
npm install -g typescript
Esforços já estão em andamento para o TypeScript 3.1, com suporte para o BigInt, uma proposta do ECMAScript de estágio 3 que deve fazer parte da atualização do ES2019 para JavaScript.
O TypeScript é um software de código aberto disponível sob a licença do Apache 2. Contribuições e feedback são incentivados através do projeto TypeScript GitHub.