TypeScript 2025: roteiro de júnior a sênior

Por que TypeScript é indispensável em 2025?

Se você ainda escreve em JavaScript puro e acha que "tipos são uma dor de cabeça desnecessária", 2025 pode ser um banho de água fria para você. TypeScript deixou de ser apenas um "complemento" — é o padrão da indústria. Grandes projetos (React, Angular, NestJS, Next.js) são escritos nele ou o exigem para um trabalho confortável. A demanda por desenvolvedores que dominam o roteiro TypeScript 2025 cresce exponencialmente.

Neste artigo, vamos construir um roteiro claro: do iniciante ao profissional. Você aprenderá o que estudar, em qual ordem e, principalmente, como aplicar esse conhecimento na prática. Vamos lá!

Etapa 1: Fundamentos — mais do que apenas tipos

Muitos começam com o básico: "let x: number = 5". Mas o verdadeiro fundamento é entender o sistema de tipos. Não se apresse em mergulhar nas complexidades — primeiro, domine os conceitos básicos.

1.1 Tipos básicos e anotações

TypeScript é sobre controle. Você diz ao compilador: "Esta variável é uma string, e ponto final". Comece com os primitivos: string, number, boolean, null, undefined. Depois, passe para arrays e tuplas.

let username: string = 'Alexei';\nlet age: number = 30;\nlet isActive: boolean = true;\n// Tupla — array fixo\nlet person: [string, number] = ['Alexei', 30];

Já nesta etapa, você notará como a IDE começa a destacar erros antes da execução do código. Essa é a magia da tipagem estática.

1.2 Interfaces e tipos (Interface vs Type)

No TypeScript, existem duas ferramentas principais para descrever a forma de objetos: interface e type. Muitos se confundem, mas a regra é simples: interfaces podem ser estendidas (extends), e tipos podem ser combinados por interseção (&).

interface User {\n  id: number;\n  name: string;\n}\n\ntype Admin = User & { role: 'admin' };\n\nconst admin: Admin = { id: 1, name: 'Ivan', role: 'admin' };

Dica: Para descrever APIs e classes, use interface. Para composições complexas, use type.

Etapa 2: Genéricos — sua principal ferramenta

Sem genéricos, TypeScript se torna um invólucro chato. Genéricos permitem escrever funções e classes que funcionam com qualquer tipo, mas mantendo o rigor. É indispensável para quem estuda TypeScript para júnior e além.

2.1 Genéricos simples

Imagine uma função que retorna o primeiro elemento de um array. Sem genéricos, você escreveria any e perderia o tipo. Com genéricos, tudo é transparente:

function first<T>(arr: T[]): T | undefined {\n  return arr[0];\n}\n\nconst num = first([1, 2, 3]); // tipo number\nconst str = first(['a', 'b']); // tipo string

2.2 Restrições de genéricos (extends)

Às vezes, é preciso dizer: "Meu genérico deve ser pelo menos…". Use extends para restringir.

function getLength<T extends { length: number }>(item: T): number {\n  return item.length;\n}\n\ngetLength('hello'); // 5\ngetLength([1, 2, 3]); // 3

Essa é a base para escrever funções flexíveis, mas seguras. Sem isso, não se vai longe no TypeScript avançado.

Etapa 3: Tipos utilitários — mágica pronta para uso

TypeScript fornece tipos internos poderosos que economizam horas de trabalho. Se você quer percorrer o roteiro TypeScript 2025 rapidamente, estude-os.

3.1 Partial, Required, Pick, Omit

Esses quatro são a base. Partial torna todos os campos opcionais, Required os torna obrigatórios, Pick seleciona campos, Omit os exclui.

interface User {\n  id: number;\n  name: string;\n  email: string;\n}\n\n// Atualizando apenas nome e email\ntype UpdateUser = Partial<Pick<U