Código limpo em TypeScript: regras, exemplos e dicas

Treinador Online de Python para Iniciantes

Aprenda Python facilmente sem sobrecarga teórica. Resolva tarefas práticas com verificação automática e escreva código diretamente no navegador.

Start Course

Por que código limpo em TypeScript não é luxo, mas necessidade

Cada desenvolvedor já passou pela situação: você abre um projeto escrito há alguns meses e não entende o que está acontecendo. Variáveis chamadas a, b, data, funções com 200 linhas cada, e tipos colocados de qualquer jeito. Familiar?

TypeScript nos dá uma ferramenta poderosa — a tipagem estática. Mas por si só, ela não torna o código limpo. É possível escrever código horrível em TypeScript, assim como em qualquer outra linguagem. Código limpo é disciplina, estilo e respeito por si mesmo e pelos colegas.

Neste artigo, vamos abordar como escrever código limpo em TypeScript que seja fácil de ler, manter e escalar. Você aprenderá sobre os princípios SOLID, tipagem forte, nomenclatura, trabalho com interfaces e muito mais. Vamos lá!

1. Nomenclatura — o rosto do seu código

A nomenclatura correta de variáveis, funções e classes representa 50% do sucesso. Um bom nome deve responder às perguntas: "O que é isso?" ou "O que esta função faz?".

Variáveis e constantes

Use substantivos e camelCase. Evite nomes de uma letra (exceto em loops).

// Ruimconst d = new Date();const u = users.find(u => u.id === 5);

// Bomconst currentDate = new Date();const activeUser = users.find(user => user.id === 5);

Funções

Nomes de funções devem começar com um verbo. Isso deixa claro qual ação está sendo executada.

// Ruimfunction data(id: number) { ... }

// Bomfunction fetchUserData(id: number): Promise<UserData> { ... }

Classes e interfaces

Classes — substantivos em PascalCase. Interfaces — também, mas frequentemente com o prefixo I (embora haja debates na comunidade). Melhor apenas dar um nome claro sem prefixo.

// Ruiminterface IUser {  name: string;}

// Bominterface User {  name: string;  email: string;}

2. Tipagem forte — seu melhor amigo

TypeScript foi criado para que os tipos trabalhem a seu favor. Não use any sem extrema necessidade. Cada vez que você escreve any, desliga a proteção do compilador.

Evite any

// Ruimfunction process(data: any) {  return data.name;}

// Bominterface Item {  name: string;  price: number;}

function process(data: Item): string {  return data.name;}

Use tipos Union e Intersection

Quando uma variável pode aceitar vários tipos, use Union (|). Para combinação, use Intersection (&).

type Status = 'active' | 'inactive' | 'pending';type AdminUser = User & { role: 'admin' };

Generic — funções universais

Generic permitem escrever código flexível sem perder a tipagem.

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

const num = firstElement([1, 2, 3]); // numberconst str = firstElement(['a', 'b']); // string

3. SOLID — princípios para adultos

Os princípios SOLID ajudam a construir uma arquitetura flexível e sustentável. Vamos analisar cada um com exemplos em TypeScript.

Responsabilidade Única (SRP)

Uma classe ou função deve ter apenas um motivo para ser alterada.

// Ruim: a classe faz tudoclass UserService {  createUser() { ... }  sendEmail() { ... }  generateReport() { ... }}

// Bom: dividimos a responsabilidadeclass UserCreator { ... }class EmailService { ... }class ReportGenerator { ... }