Escrever código não é tão simples quanto parece. Não basta saber a linguagem e desenvolver uma aplicação extremamente complexa, o seu código deve ser legível! Hoje vamos discutir algumas técnicas e boas práticas de programação para manter o seu código limpo.
Porque código limpo
Pense sempre que você não irá trabalhar sozinho em um sistema, e mesmo que trabalhe, algum dia esse sistema precisará de manutenção, seja sua, ou de algum colega. Já pensou trabalhar em um código que você não faz a mínima ma ideia do que está escrito? É uma experiência que não recomendo a ninguém.
O objetivo de ter um código limpo é ter um código legível. De que qualquer pessoa, ou até você mesmo daqui a alguns meses, ou anos no futuro consiga voltar ao código, entender todas as funções e processos realizados.
Boas práticas
Durante o desenvolvimento aplicamos alguns conceitos que apesar de básicos, ajudam consideravelmente a manter o seu código limpo:
Nomes intuitivos
Os nomes de variáveis e funções devem ser extremamente intuitivas. Não se preocupe se o nome ficar “grande demais”, isso não é um problema. O importante aqui é que você entenda o que é essa variável, ou a função, por exemplo:
const n = 'Paulo';
const npn = () => {};
O que é variável n? O que é a função npn? Hoje você pode até entender o que significam esses termos, mas o seu colega entende? Daqui a alguns meses, depois de vários outros códigos, você irá entender? Estes são péssimos exemplos de como pode ser o seu código.
O ideal é que você use algo extremamente claro, como:
const name = 'Paulo';
const getNumberOfPostsByName = () => {};
Funções e classes são pequenas, e fazem somente o necessário
Da mesma forma que o nome de uma função é importante e deva dizer exatamente o que ela faz, é importante que essa função tenha um objetivo bastante específico e apenas um único objetivo.
Uma função que faz 3 coisas ao mesmo tempo, pode ser bastante confuso para um bom entendimento de código. Veja o exemplo:
const addNewPost = (title, content) => {
const fixedContent = content.replace(/(<([^>]+)>)/ig, "");
const post = postRepository.add(title, fixedContent);
const subscribed = newsletterRepository.getAll();
subscribed.forEach((client) => {
mailService.sendNotification(client.mail, "Novo post na devGo", post);
});
}
Uma função deve ser o mais simples possível e ter apenas uma única funcionalidade. Não se importe com o número de funções, quanto maior, melhor. Isso fará até que suas funções sejam bem menores, facilitando também a compreensão do sistema.
Pequenas funções, claras e objetivas, eliminam até mesmo a necessidade de comentários no código —outra prática que é bom ser evitada.
Veja a diferença:
const parseContent = () => {
const parsedContent = content.replace(/(<([^>]+)>)/ig, "");
return parsedContent;
}
const sendPostToNewsletter = (post) => {
const mailTitle = "Novo post na devGo";
const subscribed = newsletterRepository.getAll();
subscribed.forEach((client) => {
mailService.sendNotification(client.mail, mailTitle, post);
});
}
const handleNewPost = (title, content) => {
const parsedContent = parseContent(content);
const post = postRepository.add(title, parsedContent);
sendPostToNewsletter(post);
}
Um código bem formatado traz uma organização visual ao seu código imensa!
Existem algumas ferramentas que podem te ajudar a formatar, como o ESLint ou Prettier. Com elas você pode deixar todos os parâmetros bem configurados e com o auxílio de algumas extensões do VSCode essa organização pode acontecer automaticamente.
Commits também fazem parte do desenvolvimento
Se ainda assim o código estiver difícil de entender, vamos recorrer aos commits. Um commit deve dizer exatamente o que ocorreu naquele momento do desenvolvimento.
Commits genéricos, são uma péssima prática. Não faça nada como:
git commit -m "update code"
Tenha em mente que commits não só uma “atualização”, commits são também documentação do desenvolvimento. Uma boa prática é a cada funcionalidade acrescentada no código ter um novo commit. A ideia são sempre vários commits pequenos, documentando cada ponto acrescentado, como:
git commit -m "feat: add function to post on page"
git commit -m "feat: add trigger to new post on newsletter"
KISS, DRY e YAGNI
Os métodos trazidos aqui podem evoluir para outros princípios de design de código, como o KISS, DRY e YAGNI. Estes princípios foram pensados em como deixar o seu código organizado, estável e legível e é extremamente recomendado que você passe a utilizar em seus projetos.
- DRY - Don’t Repeat Yourself: O seu código não se repete. Divida seu sistema em funções genericas que você possa repetir em diversas pontas do sistema.
- KISS - Keep it Simple, Stupid: O seu código deve ser o mais simples possível. Não precisa exagerar nas funções e criar coisas mirabolantes, na maioria das vezes a solução menos complexa funciona e é suficiente para você
- YAGNI - You ain’t gonna need it: só faça algo se for realmente utilizar. Funções abandonadas, comentários desnecessários, variáveis exageradas, não precisam estar no seu código.
Faço ainda uma menção ao SOLID: 5 princípios bem relevantes de implementação ao seu código. SOLID acaba sendo tão importante que vamos preparar um único artigo para podermos explorar melhor todos os métodos.
Levaremos esses conceitos por todas as postagens, projetos e conteúdos produzidos aqui na devGo. A ideia por trás de todas essas práticas são ter um código limpo. É claro que para cada caso, a um método diferente, e nem tudo deve ser tratado como uma “lei”: programar é se adaptar. Apenas tenha como objetivo um código fácil de ser compreendido, compartilhado e modificado.
