As novidades do TypeScript 5.5
Paulo Clemente
Navegação Rápida:
A versão final do TypeScript 5.5 foi lançada nesta semana, trazendo muitas novidades que podem ajudar desenvolvedores a escrever código mais eficiente, seguro e alinhado com as últimas novidades do ECMAScript. Vamos explorar as principais mudanças e como elas beneficiam diretamente o seu trabalho.
Inferência de Predicados de Tipo
A inferência automática de predicados de tipo significa que o TypeScript agora pode determinar o tipo retornado por funções que verificam tipos. Isso simplifica o código, reduz a necessidade de declarações explícitas e melhora a precisão dos tipos retornados.
Exemplo:
Antes:
function isString(value: any): value is string { return typeof value === "string"; }
Agora:
function isString(value: any) { return typeof value === "string"; } // TypeScript infere automaticamente o predicado de tipo
Benefício: Menos código redundante e mais precisão nos tipos.
Estreitamento de Fluxo de Controle para Acessos Indexados Constantes
O TypeScript 5.5 melhora a verificação de tipos ao acessar elementos de arrays ou objetos com índices constantes, resultando em código mais seguro e menos propenso a erros.
function f1(obj: Record<string, unknown>, key: string) { if (typeof obj[key] === "string") { // Agora isso é permitido, anteriormente era um erro obj[key].toUpperCase(); } }
Neste exemplo, o TypeScript entende que, se
typeof obj[key] === "string", então obj[key] pode ser tratado como uma string após essa verificação, permitindo o uso de métodos de string como toUpperCase() sem gerar erros de tipo.Benefício: Esse aprimoramento melhora a precisão da verificação de tipos e reduz a necessidade de declarações adicionais, tornando o código mais claro e seguro.
Tag @import no JSDoc
A nova etiqueta
@import no JSDoc traz uma simplificação significativa na importação de tipos para verificação em JavaScript. Aqui está um resumo comparando o método antigo com o novo, incluindo exemplos de código:Método Antigo
Antes, importar tipos sem causar erros de tempo de execução era complicado e repetitivo. Por exemplo:
Importação Direta (Erro em Tempo de Execução):
// ./some-module.d.ts export interface SomeType { // ... } // ./index.js import { SomeType } from "./some-module"; // ❌ runtime error! /** * @param {SomeType} myValue */ function doSomething(myValue) { // ... }
Importação de Namespace:
import * as someModule from "./some-module"; /** * @param {someModule.SomeType} myValue */ function doSomething(myValue) { // ... }
Uso de
import(...) nos Comentários JSDoc:/** * @param {import("./some-module").SomeType} myValue */ function doSomething(myValue) { // ... }
Uso de
typedef para Evitar Repetição:/** * @typedef {import("./some-module").SomeType} SomeType */ /** * @param {SomeType} myValue */ function doSomething(myValue) { // ... }
Novo Método com @import
A etiqueta
@import simplifica esse processo:Importação Nomeada Direta:
/** @import { SomeType } from "some-module" */ /** * @param {SomeType} myValue */ function doSomething(myValue) { // ... }
Importação de Namespace:
/** @import * as someModule from "some-module" */ /** * @param {someModule.SomeType} myValue */ function doSomething(myValue) { // ... }
Principais Benefícios
Simplicidade e Clareza: A importação de tipos é mais direta e menos propensa a erros.
Reutilização: Tipos podem ser reutilizados em vários lugares sem
typedefs repetitivos.Sem Impacto no Tempo de Execução: Como essas importações estão nos comentários, não afetam o comportamento do tempo de execução do código.
Novos Métodos do ECMAScript Set
Um dos destaques do TypeScript 5.5 é o suporte para novos métodos do tipo
Set do ECMAScript. Métodos como union, intersection, difference e symmetricDifference pegam outro Set e retornam um novo Set como resultado. Métodos que retornam valores booleanos, como isSubsetOf, isSupersetOf e isDisjointFrom, também foram adicionados. Esses métodos não alteram os Sets originais e são muito aguardados desde 2018.Exemplo de
Set.prototype.intersection:const setA = new Set([1, 2, 3]); const setB = new Set([2, 3, 4]); const intersection = setA.intersection(setB); // Set {2, 3}
Benefício: Mais funcionalidades e operações avançadas disponíveis nativamente.
A versão 5.5 do TypeScript também marca a desativação de funcionalidades obsoletas desde a versão 5.0, incluindo a opção
ignoreDeprecations. Com a nova versão, consumir APIs de módulos ECMAScript ficou mais fácil, graças à tag
@import. A Microsoft já anunciou que a versão 5.6 estará disponível em setembro, continuando a evolução do TypeScript.Essas atualizações tornam o desenvolvimento mais eficiente, seguro e alinhado com as novas funcionalidades do JavaScript. Para mais informações, confira a documentação oficial.
