Tipar Variáveis no TypeScript:

O Que É Tipagem de Variáveis no TypeScript

Tipar variáveis é dizer pro compilador exatamente que tipo de dado uma variável vai guardar. No JavaScript, uma variável aceita qualquer coisa: string, number, array, objeto. Não tem regra. Isso é liberdade, mas também é caos. Quem já passou horas debugando um undefined sabe bem do que eu tô falando.

TypeScript resolve esse problema. Quando você declara uma variável com tipo, o compilador garante que ninguém vai atribuir um valor errado ali. Se alguém tentar colocar um número onde deveria ter uma string, o editor já sublinha de vermelho antes de você executar qualquer coisa. Zero surpresas em runtime.

A sacada é que TypeScript tem inferência de tipos. Nem sempre você precisa escrever o tipo manualmente. Se você faz let nome = "Maria", o compilador já sabe que nome é string. Mas em situações mais complexas, tipar explicitamente evita dor de cabeça. A regra geral é: se o tipo não tá óbvio pelo valor, declare ele.

Os tipos básicos do TypeScript são: string, number, boolean, null, undefined, void, any, unknown, never e symbol. Cada um tem um papel específico. Galera que tá começando costuma usar any pra tudo, mas isso mata a vantagem de usar TypeScript. É como comprar um carro blindado e andar com a janela aberta.

Outra coisa que pega muita gente: TypeScript é um superset de JavaScript. Todo código JS válido é TS válido. Você não precisa reescrever seu projeto inteiro. Dá pra ir adicionando tipos arquivo por arquivo, começando pelos mais críticos. Essa migração gradual é uma das maiores forças da linguagem.

Como Tipar Variáveis Passo a Passo

Vamos do zero. Cada passo te leva mais perto de tipar com confiança no dia a dia. Não precisa decorar tudo de uma vez. Pratica um passo, absorve, e avança pro próximo.

Exemplos Práticos de Tipagem

Nada melhor que código pra entender. Veja como cada tipo funciona na prática e quando usar cada um deles.

Tipos Primitivos: string, number, boolean

// String - texto
let nome: string = "João";
let sobrenome: string = 'Silva';
let frase: string = `Olá, ${nome} ${sobrenome}`;

// Number - inteiros e decimais
let idade: number = 28;
let preco: number = 49.90;
let hex: number = 0xff;

// Boolean - true ou false
let ativo: boolean = true;
let aprovado: boolean = false;

Esses três são os mais usados. String cobre qualquer texto, number cobre inteiros e decimais (TypeScript não separa int e float como outras linguagens), e boolean é sim ou não. Se você vem do JavaScript, a única diferença aqui é adicionar o : tipo depois do nome da variável.

Inferência de Tipos em Ação

// TypeScript infere o tipo automaticamente
let cidade = "São Paulo";  // tipo: string
let quantidade = 42;        // tipo: number
let ligado = true;          // tipo: boolean

// Com const, o tipo é literal
const STATUS = "ativo";     // tipo: "ativo" (não string)
const MAX = 100;            // tipo: 100 (não number)

// Isso dá erro:
// cidade = 123;  // Error: Type 'number' is not assignable to type 'string'

A inferência é esperta. Com let, o tipo é genérico (string, number) porque o valor pode mudar. Com const, o tipo é o valor literal em si, porque const nunca muda. Essa diferença é sutil mas poderosa quando você trabalha com discriminated unions e pattern matching.

any vs unknown: A Diferença que Importa

// any - EVITE. Desliga totalmente a checagem
let qualquerCoisa: any = "texto";
qualquerCoisa = 42;
qualquerCoisa = true;
qualquerCoisa.metodoQueNaoExiste(); // sem erro! Perigoso.

// unknown - SEGURO. Obriga verificação antes de usar
let dadoExterno: unknown = "texto vindo de API";

// dadoExterno.toUpperCase(); // Error! Precisa verificar primeiro

if (typeof dadoExterno === "string") {
  console.log(dadoExterno.toUpperCase()); // Agora sim!
}

// Use unknown para dados que vêm de fora (APIs, inputs, etc.)

Essa é a diferença mais importante pra quem tá começando. any é uma saída de emergência que deveria ser usada quase nunca. unknown é a alternativa segura. Com unknown, o TypeScript obriga você a verificar o tipo antes de fazer qualquer operação. É como um guarda na porta: você entra, mas só depois de mostrar a identidade.

Na prática, dados de APIs externas, formulários de usuário e qualquer input que vem de fora do seu controle deve ser unknown. Você recebe, verifica o tipo com typeof ou instanceof, e só então usa. Esse pattern elimina uma classe inteira de erros de runtime.

void, null e undefined

// void - para funções que não retornam nada
function logMensagem(msg: string): void {
  console.log(msg);
}

// null e undefined - com strictNullChecks ativado
let nulo: null = null;
let indefinido: undefined = undefined;

// Union com null para valores opcionais
let usuario: string | null = null;
usuario = "Maria"; // OK
usuario = null;     // OK
// usuario = 42;    // Error!

// Verificação antes de usar
if (usuario !== null) {
  console.log(usuario.toUpperCase());
}

void é exclusivo pra funções que não retornam nada. Não confunda com undefined. Uma função void retorna undefined implicitamente, mas semanticamente ela "não retorna". Já null é um valor intencional que significa "vazio de propósito". Undefined é "não definido". Parece a mesma coisa, mas tratá-los de forma diferente torna o código mais claro.

Union Types: Combinando Tipos

// Variável que aceita mais de um tipo
let id: string | number;
id = "abc-123";
id = 456;

// Muito usado em funções
function formatar(valor: string | number): string {
  if (typeof valor === "string") {
    return valor.toUpperCase();
  }
  return valor.toFixed(2);
}

console.log(formatar("hello")); // "HELLO"
console.log(formatar(3.14159)); // "3.14"

Union types são o começo da tipagem avançada. O pipe (|) diz "pode ser esse OU aquele tipo". O TypeScript obriga você a verificar qual tipo é antes de usar métodos específicos. Esse processo se chama narrowing e é uma das features mais poderosas da linguagem. Com o tempo, você vai usar unions em todo canto.

never: O Tipo que Nunca Acontece

// never - função que nunca retorna
function lancarErro(mensagem: string): never {
  throw new Error(mensagem);
}

// never em switch exaustivo
type Status = "ativo" | "inativo";

function checarStatus(status: Status): string {
  switch (status) {
    case "ativo":
      return "Usuário ativo";
    case "inativo":
      return "Usuário inativo";
    default:
      // Se alguém adicionar um novo status e esquecer de tratar aqui,
      // o TypeScript mostra erro nessa linha
      const _exaustivo: never = status;
      return _exaustivo;
  }
}

never é o tipo pra situações impossíveis. Função que sempre dá throw? Retorna never. Loop infinito? Retorna never. O uso mais prático é em switches exaustivos: se você cobre todos os cases de um union, o default recebe never. Se um dia alguém adiciona um valor novo ao union e esquece de tratar no switch, o TypeScript avisa. É segurança extra sem esforço.

Quando Usar Tipo Explícito vs Inferência

Essa é uma dúvida que pega todo mundo no início. A regra é direta: se a inferência resolve, confie nela. Se não resolve ou se o tipo não tá óbvio pra quem vai ler o código, declare explicitamente.

Declare tipo explícito em variáveis sem valor inicial (let dados: string[]), em retornos de funções complexas, em parâmetros de função (sempre), e quando a inferência gera um tipo mais amplo do que você quer. Use inferência em variáveis com valor literal claro, em variáveis de loop (for const item of lista) e em destructuring de objetos já tipados.

O equilíbrio é: não tipar demais (redundante e poluído) nem tipar de menos (ambíguo e perigoso). Com prática, isso vira natural. Você olha pro código e sabe na hora se precisa declarar ou não.

Erros Comuns ao Tipar Variáveis