Escrever código que só precisa ser usado uma vez pode ser feito da maneira que você quiser. Mas, na maioria dos casos, é essencial aderir às práticas recomendadas e manter um código limpo.

Lembre-se de que seu código provavelmente será lido por outro desenvolvedor, ou até mesmo por você, posteriormente. Quando chegar a hora, seu código deverá ser autoexplicativo. Cada variável, função e comentário deve ser preciso, limpo e fácil de entender. Essa abordagem não apenas facilita a manutenção, mas também promove a colaboração e a eficiência dentro de sua equipe de desenvolvimento.

Assim, quando alguém (ou você) voltar para adicionar ou modificar seu código, será fácil entender o que cada linha de código faz. Caso contrário, a maior parte do seu tempo será gasta apenas tentando entender o código. O mesmo problema surgirá para um novo desenvolvedor trabalhando em sua base de código. Eles não entenderão o código se não estiver limpo. Portanto, é muito importante escrever um código limpo.

O que é Código Limpo?

Código limpo refere-se basicamente ao código que é

1. Fácil de entender
2. Fácil de depurar
3. De fácil manutenção
4. Os comentários são bem escritos, curtos e compreensíveis
5. Nenhum código duplicado (redundante) e segue a regra KISS (mantenha a simplicidade, estúpido!)

Com isso, para escrever código limpo, o desenvolvedor precisa manter a consistência no código e o desenvolvedor precisa seguir as práticas recomendadas para a linguagem específica.

Por que o Código Limpo é importante?

Quando as equipes seguem princípios de código limpo, a base de código se torna mais fácil de ler e navegar. Isso ajuda os desenvolvedores a entender rapidamente o código e começar a contribuir. Aqui estão alguns motivos pelos quais o código limpo é importante.

1. Legibilidade e manutenção: É fácil ler e entender o código quando ele está bem escrito, tem bons comentários e segue as melhores práticas. Assim que surgir um problema ou bug, você saberá exatamente onde encontrá-lo.

2. Depuração: O código limpo é projetado com clareza e simplicidade, tornando mais fácil localizar e compreender seções específicas da base de código. Estrutura clara, nomes de variáveis ​​significativos e funções bem definidas facilitam a identificação e a resolução de problemas.

3. Melhor qualidade e confiabilidade: O código limpo segue as melhores práticas de linguagens específicas e prioriza o código bem estruturado. Acrescenta qualidade e melhora a confiabilidade. Assim, elimina os erros que podem ocorrer devido a códigos com erros e não estruturados.

Agora que entendemos por que um código limpo é crucial, vamos nos aprofundar em algumas práticas e princípios recomendados para ajudá-lo a escrever um código limpo.

Princípios do Código Limpo

Para criar um ótimo código, é preciso aderir aos princípios e práticas do código limpo, como usar métodos pequenos e bem definidos.

Vamos ver isso em detalhes.

1. Evite números codificados

Em vez de usar valor diretamente, podemos usar constante e atribuir esse valor a ele. Assim, no futuro, se precisarmos atualizar esse valor, teremos que atualizá-lo em apenas um local.

Exemplo

function getDate() {
  const date = new Date();
  return "Today's date: "   date;
}

function getFormattedDate() {
  const date = new Date().toLocaleString();
  return "Today's date: "   date;
}

Neste código, em algum momento há uma mudança que em vez de "Data de hoje:" precisa se tornar "Data:". Isso pode ser melhorado atribuindo essa string a uma variável.

Código aprimorado:

const todaysDateLabel = "Today's date: ";

function getDate() {
  const date = new Date();
  return todaysDateLabel   date;
}

function getFormattedDate() {
  const date = new Date().toLocaleString();
  return todaysDateLabel   date;
}

No código acima fica fácil alterar a string de data sempre que necessário. Melhora a capacidade de manutenção.

2. Use nomes significativos e descritivos
Em vez de usar nomes de variáveis ​​comuns em todos os lugares, podemos usar nomes um pouco mais descritivos, que são autoexplicativos. O próprio nome da variável deve definir o uso dela.

Regras de nomes

1. Escolha nomes descritivos e inequívocos.
2. Faça uma distinção significativa.
3. Use nomes pronunciáveis.
4. Use nomes pesquisáveis.
5. Substitua números mágicos por constantes nomeadas.
6. Evite codificações. Não anexe prefixos nem digite informações.

Exemplo

// Calculate the area of a rectangle
function calc(w, h) {
    return w * h;
}

const w = 5;
const h = 10;
const a = calc(w, h);
console.log(`Area: ${a}`);

Aqui o código está correto, mas há alguma imprecisão no código. Vamos ver o código onde os nomes descritivos são usados.

Código aprimorado

// Calculate the area of a rectangle
function calculateRectangleArea(width, height) {
    return width * height;
}

const rectangleWidth = 5;
const rectangleHeight = 10;
const area = calculateRectangleArea(rectangleWidth, rectangleHeight);
console.log(`Area of the rectangle: ${area}`);

Aqui todos os nomes de variáveis ​​são autoexplicativos. Assim, fica fácil entender o código e melhora a qualidade do código.

3. Use comentários apenas onde for necessário
Você não precisa escrever comentários em todos os lugares. Basta escrever onde for necessário e escrever de forma curta e fácil de entender. Muitos comentários levarão à confusão e a uma base de código confusa.

Regras de comentários

1. Sempre tente se explicar em código.
2. Não seja redundante.
3. Não adicione ruído óbvio.
4. Não use comentários com chaves de fechamento.
5. Não comente o código. Basta remover.
6. Use como explicação da intenção.
7. Use como esclarecimento do código.
8. Use como aviso de consequências.

Exemplo

// Function to get the square of a number
function square(n) {
    // Multiply the number by itself
    var result = n * n; // Calculate square
    // Return the result
    return result; // Done
}

var num = 4; // Number to square
var squared = square(num); // Call function

// Output the result
console.log(squared); // Print squared number

Aqui podemos ver que os comentários são usados ​​para definir etapas que podem ser facilmente compreendidas pela leitura do código. Esses comentários são desnecessários e tornam o código confuso. Vamos ver o uso correto dos comentários.

Código aprimorado

/**
 * Returns the square of a number.
 * @param {number} n - The number to be squared.
 * @return {number} The square of the input number.
 */
function square(n) {
    return n * n;
}

var num = 4;
var squared = square(num); // Get the square of num

console.log(squared); // Output the result

No exemplo acima, os comentários são usados ​​apenas quando necessário. Esta é uma boa prática para tornar seu código limpo.

4. Escreva funções que fazem apenas uma coisa
Ao escrever funções, não adicione muitas responsabilidades a elas. Siga o Princípio da Responsabilidade Única (SRP). Isso torna a função mais fácil de entender e simplifica a escrita de testes unitários para ela.

Regras de funções

1. Mantenha-o pequeno.
2. Faça uma coisa.
3. Use nomes descritivos.
4. Prefira menos argumentos.
5. Divida o método em vários métodos independentes que podem ser chamados pelo cliente.

Exemplo

async function fetchDataAndProcess(url) {
    // Fetches data from an API and processes it in the same function
    try {
        const response = await fetch(url);
        const data = await response.json();

        // Process data (e.g., filter items with value greater than 10)
        const processedData = data.filter(item => item.value > 10);

        console.log(processedData);
    } catch (error) {
        console.error('Error:', error);
    }
}

// Usage
const apiUrl = 'https://api.example.com/data';
fetchDataAndProcess(apiUrl);

No exemplo acima, podemos ver uma função que busca dados usando uma API e os processa. Isso pode ser feito por outra função. Atualmente, a função de processamento de dados é muito pequena, mas em um projeto de nível de produção, o processamento de dados pode ser muito complexo. Nesse momento, não é uma boa prática manter isso na mesma função. Isso tornará seu código complexo e difícil de entender de uma só vez.
Vamos ver a versão limpa disso.

Código aprimorado

async function fetchData(url) {
    // Fetches data from an API
    try {
        const response = await fetch(url);
        return await response.json();
    } catch (error) {
        console.error('Error:', error);
        throw error;
    }
}

function processData(data) {
    // Processes the fetched data (e.g., filter items with value greater than 10)
    return data.filter(item => item.value > 10);
}

// Usage
const apiUrl = 'https://api.example.com/data';

fetchData(apiUrl)
    .then(data => {
        const processedData = processData(data);
        console.log(processedData);
    })
    .catch(error => {
        console.error('Error:', error);
    });

Neste exemplo, as responsabilidades são separadas: a função fetchData trata da chamada da API e a função processData trata do processamento de dados. Isso torna o código mais fácil de entender, manter e testar.

5. Evite a duplicação de código (siga o princípio DRY - não se repita)

Para melhorar a manutenção e a limpeza do código, esforce-se para criar funções reutilizáveis ​​ou reutilizar o código existente sempre que possível. Por exemplo, se você estiver buscando dados de uma API para exibir em uma página, você escreveria uma função que recupera os dados e os passa para um renderizador para exibição na IU. Se os mesmos dados precisarem ser mostrados em outra página, em vez de escrever a mesma função novamente, você deverá mover a função para um arquivo utilitário. Isso permite importar e usar a função em ambas as instâncias, promovendo a reutilização e a consistência em toda a sua base de código.

Outras regras gerais para escrever código limpo

• Siga as convenções padrão (para JavaScript Camel Case).
• Mantenha isso simples, idiota. Mais simples é sempre melhor. Reduza a complexidade tanto quanto possível.
• Regra dos escoteiros. Deixe o acampamento mais limpo do que você encontrou.
• Sempre encontre a causa raiz. Procure sempre a causa raiz de um problema.
• Escreva um código fácil de entender

Implemente estas práticas e princípios a partir de hoje para escrever um Código Limpo.