Conheça um dos princípios SOLID mais importantes: Single Responsibility Principle

Um dos princípios SOLID mais importantes é o Single Responsibility Principle (SRP), ou Princípio da Responsabilidade Única (em português). 

De acordo com Robert C. Martin (Uncle Bob) em seu livro Clean Code, uma função deve ter apenas uma responsabilidade.

Durante a leitura do livro, me deparei com um caso onde o autor aplicou técnicas de refatoração em um código legado, deixando uma função o mais enxuta possível. 

Para o autor, aquela função, após ser refatorada, passou a fazer apenas uma ação. Veja:

A questão é que, analisando a função, identifiquei que ela executa três ações:

• Verifica se é uma página de teste; 
• Caso seja uma página de teste, inclui setups e teardowns; 
• Retorna o html da página.

Níveis de abstração

A partir desse momento, o autor passa a discutir os  “níveis de abstração” do Single Responsibility Principle (SRP). Ele afirma que:

“Uma função faz apenas uma única coisa se todas as instruções dentro dela estão no mesmo nível de abstração”.

Confesso que, mesmo após ter lido várias vezes essa frase, não compreendi como aquela função fazia apenas uma coisa. Até que decidi colocar a mão na massa. Foi aí que tudo fez sentido!

Para explorar um pouco mais o SRP, vamos utilizar um exemplo fictício:

Considere que, em uma das classes do nosso sistema, existe uma função responsável por processar a aprovação de alunos. O processamento da aprovação consiste em atualizar os dados do aluno e enviar um e-mail notificando que o estudante foi aprovado.

Abaixo, o código que representa essa função:

Conforme podemos conferir na imagem, a função acima executa mais do que uma ação. Para evidenciar isso, separei elas por comentários:

Nessa etapa, ficou muito óbvio que a nossa função faz mais de uma coisa. Porém, a pergunta é: será que a função consegue perceber os diferentes níveis de abstração que ela possui?

O objetivo dessa função é processar a aprovação. “O processamento de aprovação consiste em atualizar os dados do aluno e enviar um email notificando que o aluno foi aprovado”.

Ou seja, enviar e-mail faz parte das responsabilidades da nossa função. Porém, colocar a frase “Bom dia” no corpo do e-mail já é um detalhe que a função não precisa saber. Ou melhor, ela não precisa saber se o e-mail deve começar com “Bom dia” ou “Olá”. Isso está em um nível mais baixo de abstração.

Separação dos níveis

A ideia, agora, é separar cada nível de abstração por uma nova função.

Aplicando a técnica de extração de métodos, podemos extrair a atualização dos dados do nosso aluno para outra função:

Aplicando a mesma técnica, podemos extrair também o envio do e-mail por diferentes níveis de abstração:

Perceba que criei uma função para montar o e-mail colocando os destinatários e o conteúdo do mesmo e outra função somente para montar esse conteúdo. Isso porque as duas “tarefas” estão em níveis diferentes de abstração.

Com isso, a nossa função principal ficou da seguinte forma:

Agora, se eu te perguntar “quantas coisas essa função faz?”, é provável que você responda: “duas coisas: ela atualiza os dados do aluno e envia o e-mail”. 

Se essa for sua a resposta, você não está errado, mas também não está certo.

Vou te explicar o porquê.

Lembra dos requisitos da nossa função?

“O processamento da aprovação consiste em atualizar os dados do aluno e enviar um e-mail notificando que o aluno foi aprovado”. Ou seja, atualizar os dados e enviar o e-mail estão no mesmo nível de abstração. Portanto, podemos concluir que a nossa função faz apenas uma única coisa: processa aprovação de alunos.

Gostou de aprender um pouquinho mais sobre Single Responsibility Principle?

Confira mais conteúdos como esse em nosso Blog!

Quer ser nosso próximo Tech Writer? Confira nossas vagas!