0Pricing
TypeScript Academy · Aula

TypeScript 5.1–5.2: inferência aprimorada

Explore a independência dos tipos de getters e setters e as declarações using

TypeScript 5.1–5.2: inferência aprimorada é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Visão geral do TypeScript 5.1

TypeScript 5.1, lançado em junho de 2023, aprimorou a independência dos tipos na leitura e atribuição, a flexibilidade dos tipos de elementos JSX, os cursores vinculados nos editores e as otimizações de desempenho.

// npm install typescript@5.1

Independência de tipos entre leitura e atribuição

Antes da versão 5.1, os tipos usados para ler e atribuir precisavam ser iguais. Agora, a leitura pode retornar um tipo mais amplo do que o aceito pela atribuição — útil para padrões de coerção.

class Temperature {
  get celsius(): string { return this._c + "°C"; } // string
  set celsius(value: string | number) {             // string | number
    this._c = Number(value);
  }
  private _c = 0;
}

indefinido como filhos JSX

O TS 5.1 permite que os componentes retornem diretamente undefined (além de null) da função de renderização, em conformidade com o comportamento do React 18.

// TS 5.1+: OK
function Widget(): undefined { return undefined; }
// Before 5.1: had to return null or JSX element

Flexibilidade do tipo de elemento JSX

A nova restrição JSX.ElementType oferece mais flexibilidade para fábricas JSX personalizadas, o que é útil em ambientes que não usam React.

// Custom JSX element types supported more naturally in 5.1

Visão geral do TypeScript 5.2

O TypeScript 5.2 (lançado em agosto de 2023) introduziu declarações using (Gerenciamento Explícito de Recursos), metadados de decoradores e métodos de cópia de arrays.

// npm install typescript@5.2

Declarações de gerenciamento de recursos

using implementa a proposta de Gerenciamento Explícito de Recursos — o método [Symbol.dispose]() do recurso é chamado quando ele sai do escopo.

// Requires lib: ["es2022", "esnext.disposable"]
function getConnection(): Disposable {
  const conn = openDb();
  return { [Symbol.dispose]() { conn.close(); } };
}

{
  using conn = getConnection();
  // conn.close() called automatically at block end
}

Descarte assíncrono com gerenciamento de recursos

await using funciona como using, mas chama um método assíncrono [Symbol.asyncDispose](), permitindo a limpeza assíncrona.

async function run() {
  await using db = await connectDb();
  // db[Symbol.asyncDispose]() called on exit
}

Metadados de decoradores

O TS 5.2 implementa a proposta de metadados de decoradores do TC39, permitindo que os decoradores anexem metadados por meio de Symbol.metadata.

function meta(value: string) {
  return (_: unknown, ctx: DecoratorContext) => {
    ctx.metadata[ctx.name] = value;
  };
}

@meta("service")
class MyService {}
console.log((MyService as any)[Symbol.metadata]); // { "MyService": "service" }

Métodos de cópia de arrays

O TS 5.2 adicionou tipos para Array.prototype.toSorted, toReversed, toSpliced e with — operações imutáveis de arrays do ES2023.

const arr = [3, 1, 2];
const sorted = arr.toSorted(); // [1, 2, 3] — new array, arr unchanged
const reversed = arr.toReversed(); // [2, 1, 3]

Uso no tsconfig para a versão 5.2

Para usar declarações using, inclua a biblioteca esnext.disposable no seu tsconfig.

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022", "ESNext.Disposable"]
  }
}

Recapitulação: TS 5.1–5.2

TS 5.1: tipos independentes para métodos de leitura e escrita, além de retornos undefined em JSX. TS 5.2: declarações using para limpeza automática de recursos, metadados de decoradores e tipos de métodos de cópia imutável de arrays.

Verificação rápida

O que a declaração using faz no TypeScript 5.2?

O que você aprendeu

O TS 5.1 trouxe tipos independentes para métodos de leitura e escrita e retornos undefined em JSX. O TS 5.2 trouxe declarações using para o gerenciamento automático de recursos, metadados de decoradores e tipos de métodos de cópia imutável de arrays do ES2023.

Perguntas Frequentes

A aula “TypeScript 5.1–5.2: inferência aprimorada” é grátis?

Sim — o texto completo de “TypeScript 5.1–5.2: inferência aprimorada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “TypeScript 5.1–5.2: inferência aprimorada”?

Explore a independência dos tipos de getters e setters e as declarações using Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “TypeScript 5.1–5.2: inferência aprimorada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. TypeScript 5.0: padrão de decoradores e parâmetros const de tipo
  2. TypeScript 5.1–5.2: inferência aprimorada
  3. TypeScript 5.3–5.4: nova restrição de tipos e NoInfer
  4. TypeScript 5.5+: declarações isoladas e além
← Voltar para TypeScript Academy