A autora do material, cuja tradução publicamos hoje, diz que está obcecada em escrever código limpo. Ela acredita que o código deve ser escrito para que, em primeiro lugar, no futuro, seja conveniente que outros programadores trabalhem com ele, incluindo seu autor, e, em segundo lugar, levando em consideração a possibilidade de expandir esse código. Ou seja, precisamos nos esforçar para tornar relativamente fácil adicionar novos recursos ao aplicativo e facilitar a manutenção de sua base de códigos. Se os programas foram escritos levando em consideração apenas as necessidades dos computadores, provavelmente os programadores poderiam expressar seus pensamentos apenas com a ajuda de zeros e uns, sem se preocupar com mais nada. Este artigo fornece algumas diretrizes para escrever código de qualidade, ilustrado com exemplos de JavaScript.
1. Use nomes amigáveis de variáveis e funções
O código é muito mais fácil de ler quando escrito, usando nomes claros e descritivos de funções e variáveis. Aqui está o código que não está muito claro:
function avg (a) { let s = a.reduce((x, y) => x + y) return s / a.length }
Sua legibilidade melhorará significativamente se você usar os nomes amigáveis de variáveis e funções que refletem seu significado.
function averageArray (array) { let sum = array.reduce((number, currentSum) => number + currentSum) return sum / array.length }
Não se esforce pelo minimalismo ao escrever textos de programas. Use nomes de variáveis completos que qualquer pessoa que trabalhe com seu código no futuro possa entender facilmente.
2. Escreva funções curtas que resolvam um problema
As funções são mais fáceis de manter, tornam-se muito mais compreensíveis e legíveis se visam solucionar apenas um problema. Se encontrarmos um erro, ao usar pequenas funções, fica muito mais fácil encontrar a fonte desse erro. Além disso, os recursos de reutilização de código foram aprimorados. Por exemplo, a função acima pode ser chamada
sumAndAverageArray , pois nela calculamos a soma dos valores dos elementos da matriz usando o método
reduce e, em seguida, encontramos o valor médio, dividindo a quantidade resultante pelo número de elementos na matriz. Aqui está a função.
function sumAndAverageArray(array) { let sum = array.reduce((number, currentSum) => number + currentSum) return sum / array.length }
Ele pode ser dividido em duas funções, e o papel de cada parte do código se tornará mais compreensível. Além disso, se criarmos um programa grande, a presença da função
sumArray pode ser muito útil. Aqui está o código para dois novos recursos. Um calcula a soma dos elementos da matriz, o segundo retorna seu valor médio.
function sumArray(array) { return array.reduce((number, currentSum) => number + currentSum) } function averageArray(array) { return sumArray(array) / array.length }
Um sinal de que a função pode ser dividida em duas é a possibilidade de usar a palavra "e" em seu nome.
3. Documente o código
Escreva boa documentação para o seu código - alguém que se deparar com isso no futuro entenderá o que está sendo feito nesse código e por quê. Aqui está um exemplo de uma função com falha. Alguns "números mágicos" são usados aqui, seu significado não é explicado em lugar algum.
function areaOfCircle (radius) { return 3.14 * radius ** 2 }
Você pode adicionar comentários aqui para tornar esse código mais compreensível para alguém que não conhece a fórmula para calcular a área de um círculo.
const PI = 3.14 // , function areaOfCircle (radius) { // : // return PI * radius ** 2 }
Este código é apenas um exemplo. Provavelmente, nessa situação, em vez de introduzir sua própria constante armazenando o número Pi, seria melhor usar a propriedade
Math.PI padrão.
Comentários sobre o código devem responder à pergunta "por que".
Observe que, para fins de documentação do código, faz sentido usar ferramentas especiais e as regras de comentários de código correspondentes. Quando aplicado ao Python, gosto do
Google Style Docstrings , quando aplicado ao JavaScript, gosto do
JSDoc .
4. Pense em usar as regras de Sandy Metz
Sandy Metz é uma grande programadora de Ruby, faz apresentações interessantes e escreve livros. Ela formulou quatro regras para escrever código limpo em linguagens orientadas a objetos. Aqui estão eles.
- As classes não devem ter mais de 100 linhas de código.
- Métodos e funções não devem ter mais de 5 linhas de código.
- Os métodos devem passar no máximo 4 parâmetros.
- Os controladores podem inicializar apenas um objeto.
Eu recomendo assistir o
desempenho dela em relação a essas regras.
Eu tenho seguido essas regras há cerca de dois anos, e elas se tornaram tão firmemente enraizadas em minha mente que eu as sigo, literalmente, "na máquina". Gosto deles e acredito que o uso deles aumenta a conveniência de manter o código.
Observe que essas regras são apenas recomendações, mas usá-las tornará seu código muito melhor.
5. Aplique as regras selecionadas sequencialmente
A aplicação consistente das regras para escrever código é muito importante, independentemente de você escrever o código de um projeto ou trabalhar em equipe. Em particular, isso se expressa no fato de que quem lê código resultante do desenvolvimento da equipe deve percebê-lo como um todo. Com essa abordagem, a autoria de linhas de código individuais só pode ser estabelecida entrando em contato com o Git. Se você, em JavaScript, usar um ponto-e-vírgula - coloque-o onde precisar. O mesmo se aplica às aspas - selecione aspas duplas ou simples e, se não houver um bom motivo, sempre use o que você escolher.
Eu recomendo aplicar o guia de estilo de código e o linter, o que permite levar o código ao padrão selecionado. Por exemplo, para JavaScript eu gosto das regras do
Standard JS , para Python eu gosto das regras do
PEP8 .
De fato, o principal aqui é encontrar as regras de design do código e segui-las.
6. Lembre-se do princípio DRY
Uma das primeiras idéias que as pessoas tentam transmitir a alguém que quer se tornar um programador é: "Não se repita, SECO". Se você notar fragmentos duplicados em seus projetos, use construções de software que reduzirão repetições do mesmo código. Costumo aconselhar meus alunos a jogar o jogo
SET , a fim de melhorar suas habilidades de reconhecimento de padrões.
No entanto, se você decidir aplicar fanaticamente o princípio DRY ou abstrair os modelos mal selecionados, a legibilidade do código poderá se deteriorar seriamente e, mais tarde, talvez seja necessário recorrer à criação de cópias das mesmas construções com mais frequência. Sandy Metz, a propósito, tem um ótimo artigo sobre como a duplicação de código é menos prejudicial do que uma
falha na abstração .
Como resultado, não vale a pena repetir, mas também não vale a pena, na luta para observar o princípio DRY, para modificar o código a tal ponto que pode ficar difícil de entender.
7. Use as idéias de encapsulamento e modularidade.
Agrupe variáveis e funções relacionadas para tornar seu código mais fácil de entender e melhorá-lo em termos de reutilização. Aqui está um exemplo de código não muito bem organizado, no qual as informações sobre uma pessoa são apresentadas na forma de variáveis separadas.
let name = 'Ali' let age = 24 let job = 'Software Engineer' let getBio = (name, age, job) => `${name} is a ${age} year-old ${job}`
Se em um programa desse tipo for necessário processar os dados de muitas pessoas, seria melhor usar algo como a seguinte construção nele.
class Person { constructor (name, age, job) { this.name = name this.age = age this.job = job } getBio () { return `${this.name} is a ${this.age} year-old ${this.job}` } }
E se o programa precisar trabalhar apenas com dados de uma pessoa, eles poderão ser organizados conforme mostrado abaixo.
const ali = { name: 'Ali', age: 24, job: 'Software Engineer', getBio: function () { return `${this.name} is a ${this.age} year-old ${this.job}` } }
De maneira semelhante, deve-se abordar a divisão de programas longos em módulos, em arquivos separados. Isso facilitará o uso do código alocado em arquivos separados em diferentes projetos. Em arquivos grandes com código de programa, muitas vezes é difícil navegar, e pequenos módulos compreensíveis são fáceis de usar no projeto para o qual foram criados e, se necessário, em outros projetos. Portanto, esforce-se para escrever código modular compreensível combinando elementos logicamente relacionados.
Sumário
Neste artigo, compartilhamos com você algumas recomendações para escrever código limpo e compreensível. No entanto, estas são apenas recomendações. Estas são dicas para ajudá-lo a escrever textos de programas de qualidade. Se você aplicar sistematicamente regras semelhantes às descritas aqui, em comparação com o código que não usa algo semelhante, o código escrito usando regras será mais compreensível, será mais fácil estendê-lo, mantê-lo e reutilizá-lo.
Caros leitores! Quais regras você segue para o seu código?
