TypeScript Para Desenvolvedores JavaScript: Guia de Transição e Por Que Vale a Pena

Por Que TypeScript É Obrigatório Para Vagas Internacionais em 2026

Em 2026, TypeScript não é mais um diferencial — é o padrão de mercado. 79% dos desenvolvedores JavaScript usam TypeScript regularmente (State of JS 2024). Vagas de nível pleno e sênior em empresas americanas listam TypeScript como requisito, não como opcional.

Se você ainda trabalha exclusivamente com JavaScript puro, está se candidatando para apenas 20-30% das vagas disponíveis. A transição para TypeScript é uma das alavancas mais rápidas para aumentar sua empregabilidade internacional.

O Que Realmente Muda de JS Para TS

TypeScript é JavaScript com tipagem estática opcional. Tudo que funciona em JavaScript funciona em TypeScript. A diferença é que você adiciona tipos — e o compilador te avisa de erros antes de rodar o código.

// JavaScript (sem tipos)
function calcularBonus(salario, percentual) {
  return salario * percentual;  // E se percentual vier como string "0.15"?
}

// TypeScript (com tipos)
function calcularBonus(salario: number, percentual: number): number {
  return salario * percentual;  // Erro em compile time se percentual for string
}

Essa diferença parece pequena, mas em sistemas grandes com múltiplos desenvolvedores, TypeScript elimina uma categoria inteira de bugs em runtime.

Configurando TypeScript: tsconfig.json Para Projetos Profissionais

O tsconfig.json controla o comportamento do compilador. Para projetos sérios, use configuração strict:

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022"],
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,              // Habilita todos os strict checks
    "noUncheckedIndexedAccess": true,  // Arrays podem ser undefined
    "exactOptionalPropertyTypes": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true
  }
}

Muitos devs iniciantes em TS desabilitam strict para evitar os erros. Não faça isso — os erros estão te protegendo. Aprenda a resolver cada um.

Os Tipos Que Você Mais Vai Usar

Tipos Primitivos e Básicos

const nome: string = "João"
const idade: number = 28
const ativo: boolean = true
const ids: number[] = [1, 2, 3]
const ponto: [number, number] = [10, 20]  // tuple

Interfaces e Types

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

type Status = "ativo" | "inativo" | "pendente"  // union type

type UsuarioComStatus = Usuario & { status: Status }  // intersection type

Generics: O Conceito Mais Poderoso

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

const numero = primeiroItem([1, 2, 3])    // T = number
const texto = primeiroItem(["a", "b"])     // T = string

// Generic com constraint
function buscarPorId(items: T[], id: number): T | undefined {
  return items.find(item => item.id === id)
}

Utility Types Mais Usados

interface Produto {
  id: number
  nome: string
  preco: number
  descricao: string
}

type CriarProduto = Omit<Produto, "id">           // sem id
type AtualizarProduto = Partial<Produto>           // todos opcionais
type ProdutoPublico = Pick<Produto, "nome" | "preco">  // só nome e preco
type SomenteLeitura = Readonly<Produto>            // imutável

// Record — mapa de tipos
type StockPorId = Record<number, number>           // { [id]: quantidade }

Plano de Transição de 30 Dias

• Dias 1-5: Instale TypeScript em um projeto JavaScript existente. Renomeie .js para .ts. Resolva os erros de compilação um por um — não desabilite nada no tsconfig.
• Dias 6-15: Pratique tipos no TypeScript Playground (typescriptlang.org/play). Complete o "TypeScript Handbook" oficial. Foco em: interfaces, generics, utility types.
• Dias 16-25: Construa um projeto novo do zero em TypeScript strict. Use zod para validação de dados externos (nunca confie em dados da API sem validar o tipo).
• Dias 26-30: Leia code base de projetos TypeScript reais no GitHub — Next.js, tRPC, Prisma são excelentes exemplos de TypeScript bem escrito.

Erros Mais Comuns de Devs Migrando Para TypeScript

• Usar `any` para escapar de erros: `any` desabilita a tipagem — é pior do que JavaScript. Use `unknown` com type guard quando precisar de flexibilidade.
• Asserções de tipo sem necessidade: `value as string` sem verificar — pode esconder bugs reais. Prefira type guards (`if (typeof value === "string")`).
• Não tipar retornos de função: TypeScript infere, mas tipar explicitamente documenta e protege contra mudanças acidentais.
• Ignorar o tsconfig.json: sem `strict: true`, TypeScript é apenas JavaScript com sintaxe extra — você não está aproveitando o valor real.