Clean Code: Aprimorando a Qualidade do Desenvolvimento

Texto de Paulo Clemente Desenvolvedor e redator de mídias sociais na Rocketseat

Clean Code, ou "Código Limpo", é um termo popularizado por Uncle Bob (Robert C. Martin) que define uma série de práticas destinadas a melhorar a qualidade do código de programação. Este conceito vai além da quantidade de linhas escritas, focando-se na legibilidade, simplicidade e eficiência do código. O objetivo principal é tornar o código mais fácil de ler, compreender e, consequentemente, manter.

Por Que Clean Code é Importante?

Mais de 80% do tempo de um programador é gasto com a manutenção de códigos existentes. Portanto, um código bem escrito, seguindo os princípios de Clean Code, economiza tempo e recursos valiosos, facilitando tanto a correção de bugs quanto a implementação de novas funcionalidades.

Quem Deve Aprender Clean Code?

Clean Code é essencial para todos os desenvolvedores, independentemente do nível de experiência. Para iniciantes, é importante aprender essas práticas desde o início para construir uma base sólida. Já para os mais experientes, aprofundar-se no Clean Code pode aprimorar ainda mais suas habilidades e eficiência.

### Princípios Fundamentais do Clean Code

1. Nomenclatura Clara e Significativa

A escolha dos nomes para variáveis e funções deve ser feita com cuidado. Um bom nome explica claramente o propósito da variável ou função, facilitando a compreensão do código. Evite abreviações obscuras e seja descritivo. Por exemplo, use totalHoursInAYear em vez de simplesmente h.

//abreviação obscura
const h = 8760
for (i=0;  i < h; i++) {

}
//forma descritiva
const totalHoursInAYear = 8760
for (i=0;  i < totalHoursInYear; i++) {

}

2. Evite Números Mágicos

Números mágicos são valores numéricos com significado não claro no código. Substitua-os por constantes nomeadas para tornar o código mais legível. Por exemplo, substitua 86400 (número de segundos em um dia) por SEGUNDOS_POR_DIA.

3. Reduza Comentários Desnecessários

Comentários devem ser usados para documentar o código, não para explicar o que uma variável ou função faz. Um código bem escrito deve ser autoexplicativo. Se sentir necessidade de adicionar um comentário para explicar o que uma linha de código faz, considere refatorar essa linha para torná-la mais clara.

4. Funções Curtas e Focadas

Cada função deve ter um único propósito e executá-lo bem. Evite funções longas e complexas, dividindo-as em funções menores se necessário. Isso não apenas torna o código mais limpo, mas também facilita o teste e a manutenção.

Um código sem aplicação dessa estratégia:

async function notifyUsers(userIds, message) {
    for (const userId of userIds) {
        const user = await User.findByPk(userId);
        if (user && user.isSubscribed) {
            await Notifications.create({
                date: new Date(),
                user_id: userId,
                message,
                emailNotify: true
            });
        } else {
            await Notifications.create({
                date: new Date(),
                user_id: userId,
                message,
                emailNotify: false
            });
        }
    }
}

Um código com aplicação dessa estratégia:

const createNotification = async (user, message) => {
    await Notifications.create({
        date: new Date(),
        user_id: user.id,
        message,
        emailNotify: user.isSubscribed
    });
};

async function notifyUsers(userIds, message) {
    for (const userId of userIds) {
        const user = await User.findByPk(userId);
        if (user) {
            await createNotification(user, message);
        }
    }
}

No primeiro código, a lógica para criar uma notificação estava sendo repetida em dois lugares dentro da mesma função. E com a refatoração usando essa estratégia conseguimos eliminar essa repetição, assim o princípio DRY (Don't Repeat Yourself) é aplicado, que é uma prática fundamental no desenvolvimento de software para reduzir a duplicação e facilitar futuras alterações.

5. Encapsule Condições

Encapsular condições complexas em variáveis ou funções torna o código mais legível. Em vez de ter uma longa expressão condicional, use uma variável com um nome descritivo que explique o propósito da condição.

//Forma não encapsulada
const getUSTime = time => {
    if(time =< 12) {
        return time + "AM"
    } else {
        return time + "PM"
    }
}

//Forma encapsulada
const getUSTime = time => {
    const timeIsEqualsOrBellowTwelve = time =< 12
    if(timeIsEqualsOrBellowTwelve) {
        return time + "AM"
    } 
    return time + "PM"
}

6. Evite Estruturas de Controle Complexas Prefira estruturas de controle simples e evite aninhamentos profundos. Use retornos antecipados para reduzir a complexidade e melhorar a legibilidade.

O Clean Code é uma prática essencial para qualquer desenvolvedor que busca melhorar a qualidade e a manutenção de seus códigos. Implementar essas práticas não apenas facilita a vida de quem escreve o código, mas também de todos que irão trabalhar com ele no futuro. Como desenvolvedores, devemos nos esforçar constantemente para escrever códigos que sejam limpos, claros e eficientes. Com a aplicação dos princípios de Clean Code, estamos no caminho certo para alcançar essa meta.

Veja na prática com o Mayk Brito: https://youtu.be/HZPS_uxT6sw

thaisvilarinho / github-blog