Fundamentos do TypeScript

O que é TypeScript?

TypeScript é um superconjunto tipado de JavaScript que compila para JS puro. Adiciona tipos estáticos opcionais, interfaces, generics e ferramentas de produtividade.

// JavaScript válido é TypeScript válido
const mensagem = "Hello, TypeScript!";
console.log(mensagem);

Por que TypeScript?

• Erros em tempo de compilação: pega bugs antes de executar
• Autocompletar e documentação: IDEs entendem seu código
• Refatoração segura: o compilador aponta todos os pontos afetados
• Legibilidade: tipos documentam a intenção do código

Instalação e Configuração

# Instalação global
npm install -g typescript

# Verificar versão
tsc --version

# Compilar um arquivo
tsc arquivo.ts

# Inicializar tsconfig.json
tsc --init

tsconfig.json Básico

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "strict": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "esModuleInterop": true
  },
  "include": ["src"],
  "exclude": ["node_modules"]
}

Tipos Primitivos

// string, number, boolean
const nome: string = "Alice";
const idade: number = 30;
const ativo: boolean = true;

// null e undefined
const nulo: null = null;
const indefinido: undefined = undefined;

// bigint e symbol
const grande: bigint = 100n;
const simbolo: symbol = Symbol("id");

Inferência de Tipos

TypeScript infere o tipo automaticamente quando possível:

let nome = "Alice";    // inferido como string
let idade = 30;        // inferido como number
let items = [1, 2, 3]; // inferido como number[]

// Erro: Type 'number' is not assignable to type 'string'
nome = 42;

any vs unknown vs never

// any — desliga a verificação (evitar!)
let qualquer: any = 42;
qualquer = "texto";
qualquer.toUpperCase(); // sem erro, mas perigoso

// unknown — tipo seguro para valores desconhecidos
let desconhecido: unknown = JSON.parse('{"nome":"Alice"}');

// Precisa de type guard antes de usar
if (typeof desconhecido === "object" && desconhecido !== null) {
  console.log((desconhecido as Record<string, unknown>).nome);
}

// never — nunca ocorre (funções que lançam erro)
function erro(mensagem: string): never {
  throw new Error(mensagem);
}

Union e Intersection Types

// Union type: um OU outro
type Id = string | number;

function buscarPorId(id: Id) {
  if (typeof id === "string") {
    return id.toUpperCase();
  }
  return id.toFixed(0);
}

// Intersection type: um E outro
type ComNome = { nome: string };
type ComIdade = { idade: number };
type Pessoa = ComNome & ComIdade;

const alice: Pessoa = { nome: "Alice", idade: 30 };

Type Aliases

type Coordenadas = {
  x: number;
  y: number;
};

type Status = "ativo" | "inativo" | "pendente";

type Callback = (erro: Error | null, resultado?: string) => void;

Strict Mode

Ativar strict: true no tsconfig.json habilita todas as verificações rigorosas:

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

Isso ativa:

• noImplicitAny — erro se tipo não puder ser inferido
• strictNullChecks — null/undefined não são atribuíveis a outros tipos
• strictFunctionTypes — checagem de variância em funções
• strictBindCallApply — checagem de tipos em bind/call/apply

// Com strictNullChecks, isso é erro:
function saudacao(nome: string | null) {
  // Object is possibly 'null'
  console.log(nome.toUpperCase());
}

// Correção:
function saudacao(nome: string | null) {
  if (nome === null) return "Olá, visitante!";
  console.log(nome.toUpperCase());
}

Lab: Configurar e Testar TypeScript

# 1. Criar projeto
mkdir meu-ts && cd meu-ts
npm init -y

# 2. Instalar TypeScript
npm install typescript --save-dev

# 3. Criar tsconfig.json
npx tsc --init --strict --target ES2022 --outDir dist --rootDir src

# 4. Criar arquivo
mkdir src
cat > src/index.ts << 'EOF'
function saudar(nome: string): string {
  return `Olá, ${nome}!`;
}

const mensagem = saudar("TypeScript");
console.log(mensagem);
EOF

# 5. Compilar e executar
npx tsc
node dist/index.js

Sempre use strict: true. Ele pega a maioria dos bugs que passariam despercebidos em JavaScript puro.