TypeScript essencial

Tipos de objeto, uniões, estreitamento e genéricos: o suficiente para usar TypeScript com confiança.

8 min de leitura · Iniciante · Revisado em

O que o TypeScript faz por você

TypeScript é JavaScript com tipos verificados antes de rodar. O compilador lê o código e avisa quando você chama uma função com o argumento errado, esquece um campo ou acessa algo que pode ser undefined. Depois, os tipos são apagados e sobra JavaScript comum.

O erro aparece no editor, não na tela de quem usa

function saudacao(nome: string) {
  return `Olá, ${nome.toUpperCase()}`;
}

saudacao(42);
// Erro: o argumento do tipo 'number' não pode ser
// atribuído ao parâmetro do tipo 'string'.

Os tipos que você mais vai usar

Objetos, opcionais, uniões e listas

type Status = 'rascunho' | 'publicado' | 'arquivado';

interface Post {
  id: number;
  titulo: string;
  status: Status;
  tags: string[];
  publicadoEm?: Date; // opcional: pode não existir
}

const post: Post = {
  id: 1,
  titulo: 'Olá',
  status: 'rascunho',
  tags: [],
};
Inferência
Você não precisa anotar tudo. const total = 10 já é number. Anote parâmetros de função e o formato dos dados.
União
A | B aceita um ou outro. Uniões de textos fixos substituem "strings mágicas".
type ou interface
Para objetos, os dois funcionam. type também descreve uniões. Escolha um padrão e mantenha no projeto.
unknown
Um valor que você ainda não sabe o que é. Diferente de any, obriga a verificar antes de usar.

Estreitar o tipo antes de usar

Quando um valor pode ser de mais de um tipo, o TypeScript acompanha os if e entende o que sobra em cada ramo. Isso se chama estreitamento.

Uma união discriminada: o campo "tipo" diz qual formato veio

type Resultado =
  | { tipo: 'ok'; dados: Post[] }
  | { tipo: 'erro'; mensagem: string };

function mostrar(resultado: Resultado) {
  if (resultado.tipo === 'erro') {
    return resultado.mensagem; // aqui só existe mensagem
  }
  return resultado.dados.length; // aqui só existe dados
}

Opcionais: trate o caso vazio

function dataDoPost(post: Post) {
  return post.publicadoEm?.toLocaleDateString('pt-BR') ?? 'Não publicado';
}

Genéricos sem mistério

Um genérico é um tipo como parâmetro. A função funciona com qualquer tipo, mas mantém a ligação entre a entrada e a saída.

function primeiro<T>(lista: T[]): T | undefined {
  return lista[0];
}

const nome = primeiro(['Ana', 'Bia']); // string | undefined
const post = primeiro(posts);         // Post | undefined
Utilitários prontos que evitam repetir tipos
UtilitárioResultado
Partial<Post>Todos os campos opcionais, útil para atualização parcial
Pick<Post, 'id' | 'titulo'>Só os campos escolhidos
Omit<Post, 'id'>Tudo menos os campos escolhidos, útil para criação
Record<Status, number>Um objeto com uma chave para cada status

Configuração que vale a pena

  • Ligue "strict": true no tsconfig.json desde o começo. Migrar depois é bem mais trabalhoso.
  • Rode tsc --noEmit na CI. Vite e esbuild removem os tipos sem verificá-los.
  • Evite any. Quando não souber o tipo, use unknown e estreite.
  • Evite as para "calar" o compilador. Ele não converte nada, só esconde o problema.
  • strict está ligado e o projeto compila sem erros.
  • Funções exportadas têm parâmetros e retorno claros.
  • Dados externos são validados antes de virar um tipo do projeto.
  • Não há any nem as sem uma justificativa.

Referências

Trilhas relacionadas