Clean Code em TypeScript: princípios e exemplos para iniciantes

Clean Code em TypeScript: princípios e exemplos para iniciantes

Código limpo (Clean Code) não é apenas um termo da moda, mas uma filosofia de desenvolvimento que ajuda a escrever programas compreensíveis para outros desenvolvedores (e para você mesmo daqui a seis meses). Para programadores iniciantes em TypeScript, dominar os princípios do código limpo é um passo fundamental para o crescimento profissional. Neste artigo, vamos analisar as regras principais, dar exemplos práticos e mostrar como tornar seu código em TypeScript elegante e sustentável.

Por que o código limpo é importante?

Imagine que você está lendo um livro sem parágrafos, sinais de pontuação e com todas as palavras escritas juntas. É mais ou menos assim que um código sujo parece para outro desenvolvedor. O código limpo economiza tempo de depuração, simplifica a adição de novas funcionalidades e reduz o número de bugs. O TypeScript, com sua tipagem forte, já ajuda a escrever um código mais confiável, mas sem seguir os princípios de limpeza, até mesmo o código tipado pode se tornar ilegível.

// Ruim: ilegívelfunction d(a:any,b:any){if(a>b){return a}else{return b}}

// Bom: limpo e clarofunction findMaxValue(firstNumber: number, secondNumber: number): number {    if (firstNumber > secondNumber) {        return firstNumber;    }    return secondNumber;}

Princípios fundamentais do Clean Code em TypeScript

1. Nomes significativos para variáveis e funções

O nome deve responder às perguntas "o quê?" e "para quê?". Evite abreviações de uma letra (exceto para índices de loops) e nomes abstratos. Use camelCase para variáveis e PascalCase para classes.

// Ruimconst d = new Date();const arr = [1, 2, 3];function p(x: number) { return x * 2; }

// Bomconst currentDate = new Date();const numbersList: number[] = [1, 2, 3];function doubleValue(value: number): number {    return value * 2;}

2. Funções devem fazer apenas uma coisa

Cada função deve resolver uma única tarefa. Se uma função faz mais de uma ação — divida-a em várias funções menores. Isso melhora a legibilidade e a testabilidade.

// Ruim: a função faz tudo de uma vezfunction processUserData(userData: string): void {    const parsed = JSON.parse(userData);    const isValid = parsed.name && parsed.email;    if (isValid) {        console.log(`User ${parsed.name} registered`);        saveToDatabase(parsed);    }}

// Bom: cada função é responsável por sua partefunction parseUserData(rawData: string): User {    return JSON.parse(rawData);}

function validateUserData(user: User): boolean {    return !!user.name && !!user.email;}

function registerUser(userData: string): void {    const user = parseUserData(userData);    if (validateUserData(user)) {        console.log(`User ${user.name} registered`);        saveToDatabase(user);    }}

3. Evite números e strings mágicos

Números mágicos são literais cujo valor não é claro sem contexto. Coloque-os em constantes com nomes significativos.

// Ruimif (user.age > 18) {    // ...}const discount = price * 0.1;

// Bomconst ADULT_AGE = 18;const STANDARD_DISCOUNT_RATE = 0.1;

if (user.age > ADULT_AGE) {    // ...}const discount = price * STANDARD_DISCOUNT_RATE;

4. Use tipos e interfaces corretamente

O TypeScript oferece ferramentas poderosas para descrever dados. Não abuse do any, prefira tipos específicos. Crie interfaces para objetos complexos.

// Ruimfunction createUser(name: any, age: any) {    return { name, age, createdAt: new Date() };}

// Bominterface User {    name: string;    age: number;    createdAt: Date;}

function createUser(name: string, age: number): User {    return {        name,        age,        createdAt: new Date()    };}