Blog,Código Limpo Código-Limpo Parte 2: Funções Pequenas

Código-Limpo Parte 2: Funções Pequenas

Código-Limpo Parte 2: Funções Pequenas post thumbnail image

No mundo do desenvolvimento de software, a qualidade do código é um fator determinante para a manutenção, evolução e sucesso de um projeto. Uma das práticas fundamentais para alcançar um código-limpo é a utilização de funções pequenas e focadas. Conforme discutido por Robert C. Martin em seu livro “Código-Limpo”, funções pequenas são essenciais para criar um código mais legível, testável e sustentável. Neste artigo, vamos explorar a importância das funções pequenas, as vantagens de adotá-las e como implementá-las de forma eficaz.

Por que é importante um código-limpo?

Código-limpo é aquele que é fácil de ler, entender e modificar. Manter um código-limpo traz várias vantagens, incluindo:

  1. Legibilidade: Um código fácil de ler é mais fácil de entender, o que é crucial para a colaboração entre desenvolvedores.
  2. Manutenção: Código claro e bem-estruturado facilita a manutenção e a refatoração, reduzindo o tempo e esforço necessários para essas tarefas.
  3. Colaboração: Facilita a colaboração entre desenvolvedores, permitindo que todos possam rapidamente entender a lógica e o fluxo do código.
  4. Redução de Erros: Código bem-organizado e legível é menos propenso a erros, pois é mais fácil identificar e corrigir problemas.

Os principais pilares

Os principais pilares do código-limpo são práticas e princípios que guiam os desenvolvedores na criação de código de alta qualidade. Cada pilar aborda um aspecto específico do desenvolvimento de software, contribuindo para a criação de um sistema que é fácil de entender, manter e evoluir. Aqui estão os principais pilares do código-limpo:

  1. Nomes significativos
  2. Funções pequenas e focadas
  3. Comentários eficientes
  4. Formatação consistente
  5. Tratamento adequado de erros
  6. Estrutura coesa e baixo acoplamento
  7. Testes automatizados
  8. Refatoração contínua
  9. Código simples e direto
  10. Princípios SOLID

Neste artigo, focaremos no segundo pilar: Funções Pequenas.

Segundo pilar: Funções Pequenas e Focadas

Funções pequenas e focadas são essenciais para a legibilidade e manutenibilidade do código. A ideia é que cada função deve realizar uma única tarefa ou ter uma única responsabilidade, tornando-a mais fácil de entender, testar e manter.

Vantagens de Funções Pequenas

  1. Legibilidade: Funções pequenas são mais fáceis de ler e entender. Quando uma função é curta, é mais provável que um desenvolvedor consiga entender o que ela faz rapidamente.
  2. Manutenção: Funções pequenas são mais fáceis de manter. Alterar uma pequena parte do código em uma função curta é mais seguro e menos propenso a introduzir erros do que modificar uma grande função que realiza muitas tarefas.
  3. Testabilidade: Funções pequenas são mais fáceis de testar. É mais simples escrever testes unitários para funções que têm uma única responsabilidade, o que melhora a cobertura de testes e a confiabilidade do software.
  4. Reutilização: Funções focadas podem ser reutilizadas em diferentes partes do código. Quando uma função realiza uma tarefa específica, ela pode ser chamada em diferentes contextos, evitando a duplicação de código.

Implementação de Funções Pequenas e Focadas

  1. Identificar Responsabilidades: O primeiro passo é identificar as diferentes responsabilidades dentro de uma função grande. Cada bloco de código que realiza uma tarefa distinta deve ser extraído para uma função separada.
  2. Nomear Funções de Forma Clara: As funções devem ter nomes que descrevam claramente o que fazem. Nomes bem escolhidos aumentam a legibilidade e tornam o código mais autoexplicativo.
  3. Manter o Tamanho Ideal: Embora não haja uma regra rígida sobre o tamanho exato de uma função, um bom guia é que a função deve caber na tela sem precisar rolar. Idealmente, uma função deve ter entre 5 e 15 linhas de código.
  4. Evitar Parâmetros Excessivos: Funções pequenas e focadas tendem a ter poucos parâmetros. Se uma função precisa de muitos parâmetros, isso pode ser um sinal de que ela está fazendo mais do que deveria e pode ser subdividida ainda mais.
  5. Refatoração Contínua: A criação de funções pequenas é um processo contínuo. À medida que o código evolui, novas oportunidades para extrair funções menores podem surgir. Refatorar regularmente para manter funções pequenas é uma prática recomendada.

04 exemplos em Delphi com Antes e Depois

  1. Processamento de Dados

Antes: Funções longas que processam dados de várias formas.

Depois: Funções menores e focadas em tarefas específicas.

Perceba nesse primeiro exemplo, que criamos outros métodos que possuem suas próprias responsabilidades. A função principal “ProcessarDados” ficou apenas com 02 linhas, diferentemente da versão anterior, onde fazia mais do que apenas processar os arquivos.

  1. Cálculo de Total

    Antes: Funções que calculam total de várias formas em um único método.

    Depois: Funções separadas para cálculos específicos.

    Tenho certeza que está pensando: Mas a função já era pequena antes. Pois bem, reduzimos ainda mais e separamos as responsabilidades.

    1. Conexão com Banco de Dados

    Antes: Função única que lida com conexão, consulta e processamento de resultados.

    Depois: Funções separadas para cada responsabilidade.

    1. Envio de Email

    Antes: Função única que lida com a construção e envio de email.

    Depois: Funções separadas para construir e enviar o email.

    Conclusão

    Funções pequenas e focadas são essenciais para alcançar um código-limpo e de alta qualidade. Elas melhoram significativamente a legibilidade, facilitam a manutenção e aumentam a testabilidade do código. Ao dividir responsabilidades em funções menores, os desenvolvedores criam um código mais modular e fácil de entender, o que, por sua vez, promove uma maior colaboração e eficiência dentro da equipe. Implementar funções pequenas não só reduz a complexidade, mas também permite uma melhor reutilização de código e uma refatoração contínua mais segura. Ao adotar essa prática, os desenvolvedores garantem que seu software não apenas funcione bem hoje, mas também possa evoluir e se adaptar às necessidades futuras com mais facilidade e menos risco de introduzir novos problemas. No próximo artigo, exploraremos o terceiro pilar do código-limpo: Comentários Eficientes.

    Comunidade no Telegram

    🚀Comente no campo abaixo 👇👇👇 o que achou e qual sua dúvida.

    Te vejo na próxima

    Adriano Santos

    2 thoughts on “Código-Limpo Parte 2: Funções Pequenas”

    Deixe sua resposta

    O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

    Posts Relacionados