<\> Casa do Dev
Notícias abrir
Ferramentas abrir
Vagas abrir
Aprender abrir
Comunidade abrir
Guia de Compras abrir

TypeScript do zero: a tipagem que pega bug antes de rodar

DA

8 min

TypeScript do zero: a tipagem que pega bug antes de rodar

Aprenda TypeScript do zero: tipos básicos, interfaces, generics e strict mode, com exemplos e os erros comuns de iniciante.

Neste artigo

TypeScript é JavaScript com uma camada de tipos que pega o erro antes de você abrir o navegador. Em vez de descobrir que aquela variável virou undefined em produção, você descobre no editor, enquanto ainda está escrevendo. Este guia leva do primeiro tipo até generics, no ritmo de quem já programa em JavaScript.

TypeScript adiciona tipos ao JavaScript sem trocar a linguagem: você declara o tipo de variáveis, parâmetros e retornos, e o compilador reclama na hora quando o valor não bate. O básico para começar são tipos primitivos, objetos e unions, e em seguida interfaces e generics. Se a sua base de JavaScript ainda tem pontas soltas, consolide primeiro no guia completo de JavaScript.

Qual a diferença entre JavaScript e TypeScript?

TypeScript não é uma linguagem nova: é um superset de JavaScript que compila de volta para o JavaScript puro. Todo código JavaScript válido é válido em TypeScript, então você pode migrar aos poucos, arquivo por arquivo. A diferença prática é que o TypeScript conhece o formato dos seus dados e avisa quando você usa errado, antes de qualquer execução.

💡 Dica: TypeScript não deixa o seu código livre de bug: ele pega o erro de contrato, não o erro de lógica. Continue escrevendo teste para o comportamento. Os dois se complementam.

Tipos básicos: o primeiro contato

A anotação de tipo vem depois do nome com dois-pontos. Primeiro os primitivos, que cobrem o grosso do dia a dia.

let idade: number = 32;
let nome: string = "Maria";
let ativo: boolean = true;
let id: string | number = "abc-123"; // union: aceita ambos

O union (|) vale destaque: é o jeito honesto de expressar "isto pode ser mais de um tipo", caso comum em entrada de API. Sem ele, você cai no any, que desliga a checagem e joga fora a vantagem do TypeScript.

Interfaces e tipos de objeto

Para dados estruturados, você descreve a forma do objeto com uma interface. É o que torna o autocomplete útil de verdade: o editor passa a saber os campos e aponta acesso errado antes de rodar.

interface Usuario {
  id: number;
  nome: string;
  email?: string; // opcional
}

function saudar(usuario: Usuario): string {
  return `Olá, ${usuario.nome}`;
}

O ponto de interrogação marca campo opcional. Com ele, você documenta o contrato no próprio código e o editor impede usar um campo que pode não existir sem tratar o caso primeiro.

Generics: reutilizar sem abrir mão do tipo

Generics entram quando a função precisa funcionar com mais de um tipo, mas ainda assim devolver o tipo certo. Em vez de devolver any, você parametriza o tipo e o compilador mantém a relação entre entrada e saída.

function primeira(lista: T[]): T | undefined {
  return lista[0];
}

const primeiroNome = primeira(["Ana", "Bia"]); // string | undefined
const primeiroNumero = primeira([1, 2, 3]);     // number | undefined

É a peça que muita gente acha difícil, mas no fundo é só um tipo que se adapta ao que você passa. Uma vez que a ficha cai, você usa em funções de utilidade e em chamadas de API sem repetir código.

Type narrowing: o compilador afunila o tipo sozinho

TypeScript é esperto o bastante para afunilar um tipo quando você verifica uma condição. Dentro de um if que checa o tipo, o editor passa a saber qual é o valor exato, sem você anotar de novo. Esse recurso, chamado de type narrowing, é o que torna o union utilizável no dia a dia.

function formatar(valor: string | number): string {
  if (typeof valor === "number") {
    return valor.toFixed(2);   // aqui valor é number
  }
  return valor.trim();          // aqui valor é string
}

O afunilamento elimina uma classe inteira de erros de union, porque o compilador confirma o tipo dentro de cada ramo. É o primeiro passo para trabalhar com dado que vem de fora, como resposta de API, sem recorrer ao any.

Strict mode: por que ativar desde o início

O strict: true no tsconfig.json liga um conjunto de checagens mais rígidas, incluindo a que impede acessar variável sem garantir que não é nula. É chato em código legado, mas em projeto novo evita uma classe inteira de erro. Ative desde o começo, porque migrar strict depois é mais doloroso que adotá-lo no início.

{
  "compilerOptions": {
    "strict": true
  }
}

Erros comuns de quem está começando

O erro número um é despejar any para calar o compilador. O segundo é tipar demais e travar o próprio progresso brigando com tipo complexo. O terceiro é achar que TypeScript substitui teste. O caminho do meio: tipa o contrato, use unknown em vez de any quando não souber, e deixe o teste cobrir a lógica.

ErroPor que atrasaCorreção
Uso de any em tudoDesliga a checagemUsar unknown e afunilar o tipo
Tipo complexo demais cedoBloqueia o progressoComeçar simples e refatorar
Ignorar erro do editorAcumula débitoResolver na hora, não silenciar

TypeScript na carreira de quem desenvolve

TypeScript virou padrão em boa parte do frontend e cresce também no backend com Node. É rara a vaga de JavaScript que não pede alguma fluência em TypeScript hoje. Com a base de tipos sólida, a próxima curva é o ecossistema de runtime, e o guia de Node, Deno e Bun mostra onde a linguagem roda e qual escolher.

Como tipar resposta de API sem duvidar do dado

Dado que vem de API é exatamente o caso que não tem tipo garantido: você recebe JSON e precisa dizer ao TypeScript o que esperar. A abordagem firme é declarar uma interface para o formato e converter a resposta para ela. A abordagem defensiva reconhece que o servidor pode mandar algo fora do contrato, e por isso trata antes de confiar.

interface Usuario {
  id: number;
  nome: string;
}

async function buscarUsuario(id: number): Promise {
  const resposta = await fetch(`/usuarios/${id}`);
  const dados: unknown = await resposta.json();
  // valide a forma aqui, depois converta
  return dados as Usuario;
}

O ponto importante é a honestidade: declarar o tipo não valida o dado, só anota o contrato. Em produção, combine com validação de runtime na borda da API, para que um campo a menos não exploda dentro da aplicação. O TypeScript pega o erro de uso; a validação pega o erro de dados.

Union literal: o jeito moderno de modelar conjunto

Quando um campo aceita só alguns valores fixos, como o status de uma ordem, a união de literais é a forma mais direta de expressar. Diferente de usar string solta, o compilador passa a aceitar apenas os valores declarados e erra quando alguém digita um fora da lista.

type Status = "pendente" | "aprovado" | "cancelado";

function atualizar(status: Status): void {
  // só aceita os três valores declarados
}

Esse padrão substitui o uso de string livre e elimina o erro clássico de valor com typo que só estoura em produção. Sequências de estados, categorias de produto e tipos de permissão são os casos mais comuns. O autocomplete ainda lista as opções válidas, virando documentação viva no editor. E a escolha do runtime em volta fica no comparativo de Node, Deno e Bun.

Para continuar a trilha com material da casa, vale o guia completo de JavaScript, e o passo a passo do introdução ao desenvolvimento web na versão completa.

Perguntas frequentes

TypeScript é só para frontend?

Não. Nasceu no frontend, mas hoje é amplamente usado no backend com Node e em ferramentas. A tipagem ajuda em qualquer lado onde você escreve JavaScript.

Como migro um projeto JavaScript inteiro?

Não precisa de uma vez, e em projeto grande não vale. Ative o TypeScript gradualmente, começando pelo arquivo novo e renomeando os existentes para .ts aos poucos. A migração incremental aproveita que todo JavaScript é TypeScript válido.

Qual a diferença entre interface e type?

Os dois descrevem a forma de um objeto. Interface é extensível e pensada para contratos de objeto; type cobre mais casos, como union e intersecção. Na prática, escolha uma e seja consistente no projeto.

Quando usar unknown em vez de any?

Prefira unknown sempre que o tipo for desconhecido: ele obriga você a verificar antes de usar, diferente de any que libera tudo. É a escolha segura para dado vindo de fora, como resposta de API.

Preciso configurar TS na mão?

Em projeto novo, o scaffold já traz a configuração pronta. O essencial é ativar strict e entender o tsconfig, não decorar todas as opções de compilação.

Produtos relacionados

Este conteúdo tem links de afiliado: se você comprar por eles, podemos receber uma comissão sem custo extra para você. A escolha dos produtos segue critérios próprios e não é influenciada por comissão.

O que você achou deste artigo?

Responda a Pergunta do Dia Teste seu conhecimento e mantenha sua streak. Crie seu Dev Card público Perfil dev compartilhável em um único link.

Depois dessa formação...

Veja vagas em tecnologia →

Vagas relacionadas

Ver todas as vagas →
DA

Escrito por

Dagmar

Atualizado em 06/10/2026 •

Ver perfil do autor

COMPARTILHAR