Do Código Repetido ao Helper: A Jornada de um Dev Jr
A Situação
Era uma segunda-feira chuvosa quando Lucas, um desenvolvedor junior com apenas 6 meses de experiência, recebeu uma tarefa aparentemente simples do seu tech leader, Marina:
"Lucas, preciso que você crie um relatório de funcionários por departamento. Filtre os dados, transforme o formato e agregue as estatísticas. Tem até o final do dia."
Lucas abriu o arquivo com os dados dos funcionários e começou a escrever o código. Mas conforme avançava, percebeu algo frustrante: estava repetindo o mesmo padrão de código várias vezes. Filtrar arrays, transformar dados, agregar informações... tudo isso com callbacks aninhados e lógica duplicada.
Ele pensou: "Deve haver uma forma melhor de fazer isso."
O Problema
Vamos ver o que Lucas estava fazendo sem um Helper:
// Filtrar funcionários por departamento
$funcionarios=array_filter($dados,function($item){
if(isset($item['company']) && isset($item['company']['department'])){
return$item['company']['department']==='Desenvolvimento';
}
returnfalse;
});
// Depois, transformar os dados]
$funcionariosFormatados=array_map(function($item){
$employee=[];
$employee['name']=$item['firstName'].' '.$item['lastName'];
$employee['email']=$item['email'];
$employee['phone']=$item['phone'];
$employee['company']=$item['company']['name'];
$employee['department']=$item['company']['department'];
return$employee;
},$funcionarios);
// E depois agregar estatísticas
$total=count($funcionariosFormatados);
$somaIdades=0;
foreach ($funcionariosFormatadosas$emp) {
$somaIdades+=$emp['age'] ?? 0;
}
$mediaIdades=$total>0?$somaIdades/$total:0;
Esse código funcionava, mas era verboso, difícil de ler e, pior ainda, ele precisaria repetir essa lógica em vários lugares do projeto.
A Ideia Brilhante
Lucas se lembrou de uma aula sobre funções nativas de array do PHP e pensou: "E se eu criasse uma classe Helper que encapsulasse essas operações comuns?"
Ele criou um arquivo chamado Helper.php:
<?php
namespace Bevith\DockerPhp\Services;
class Helper
{
/**
* Filtra dados por papel (role)
*
* Exemplo: Helper::filterRole($usuarios, 'admin')
* Retorna apenas os usuários com role 'admin'
*/
public static function filterRole(array $data, string $role): array
{
return array_filter($data, function ($item) use ($role) {
return $item['role'] === $role;
});
}
/**
* Filtra dados por departamento
*
* Verifica estruturas aninhadas (company.department)
* Exemplo: Helper::filterDepartament($usuarios, 'Desenvolvimento')
*/
public static function filterDepartament(array $data, string $departament): array
{
return array_filter($data, function ($item) use ($departament) {
if(isset($item['company']) && isset($item['company']['department'])){
return $item['company']['department'] === $departament;
}
return false;
});
}
/**
* Transforma dados de funcionários em um formato padronizado
*
* Exemplo: Helper::employees($usuarios, 'Desenvolvimento')
* Retorna array com nome, email, telefone, empresa e departamento
*/
public static function employees(array $data, string $company): array
{
$data = self::filterDepartament($data, $company);
return array_map(function ($item) {
$employee = [];
$employee['name'] = $item['firstName'] . ' ' . $item['lastName'];
$employee['email'] = $item['email'];
$employee['phone'] = $item['phone'];
$employee['company'] = $item['company']['name'];
$employee['department'] = $item['company']['department'];
return $employee;
}, $data);
}
/**
* Conta funcionários por departamento
*
* Exemplo: Helper::countByDepartament($usuarios, 'Desenvolvimento')
* Retorna array associativo com contagem por departamento
*/
public static function countByDepartament(array $data, $company): array
{
$departaments = self::filterDepartament($data, $company);
return array_reduce($departaments, function($item, $value) {
$dept = $value['company']['department'];
if(!isset($item[$dept])){
$item[$dept] = 0;
}
$item[$dept]++;
return $item;
});
}
/**
* Gera um resumo estatístico do departamento
*
* Exemplo: Helper::resumeDepartament($usuarios, 'Desenvolvimento')
* Retorna total de funcionários, soma de idades, média de idades e lista de nomes
*/
public static function resumeDepartament($data, $departament)
{
$items = self::filterDepartament($data, $departament);
$result = array_reduce($items, function($dataItens, $employee) {
$dataItens['total']++;
$dataItens['sum_ages'] += $employee['age'];
$dataItens['employees'][] = $employee['firstName'] . ' ' . $employee['lastName'];
return $dataItens;
}, [
'total' => 0,
'sum_ages' => 0,
'employees' => []
]);
if($result['total'] > 0) {
$result['average_age'] = $result['sum_ages'] / $result['total'];
}
return $result;
}
}
Agora o Código Fica Assim
Com o Helper criado, Lucas pode fazer a mesma coisa em apenas 3 linhas:
// Obter funcionários formatados
$funcionarios = Helper::employees($dados, 'Desenvolvimento');
// Contar por departamento
$contagem = Helper::countByDepartament($dados, 'Desenvolvimento');
// Gerar resumo com estatísticas
$resumo = Helper::resumeDepartament($dados, 'Desenvolvimento');
Muito mais limpo, não é?
Entendendo as Funções Nativas
O Helper de Lucas usa três funções nativas poderosas do PHP. Vamos entender cada uma:
1. array_filter() - Filtrando Dados
A função array_filter() percorre um array e mantém apenas os elementos que atendem a uma condição:
$admins = array_filter($usuarios, function ($usuario) {
return $usuario['role'] === 'admin';
});
O que acontece aqui:
- Para cada usuário no array, a função callback é executada
- Se o callback retorna true, o usuário é mantido
- Se retorna false, o usuário é descartado
- O resultado é um novo array apenas com os admins
Analogia: É como peneirar areia. Você passa tudo por uma peneira, e apenas o que passa fica.
2. array_map() - Transformando Dados
A função array_map() transforma cada elemento de um array usando uma função callback:
$funcionariosFormatados = array_map(function ($usuario) {
return [
'name' => $usuario['firstName'] . ' ' . $usuario['lastName'],
'email' => $usuario['email']
];
}, $usuarios);
O que acontece aqui:
- Para cada usuário, a função cria um novo formato
- O array final tem o mesmo número de elementos
- Mas cada elemento foi transformado
Analogia: É como passar roupas por uma máquina de lavar. Você coloca 10 camisetas, sai 10 camisetas, mas todas limpas e transformadas.
3. array_reduce() - Agregando Dados
A função array_reduce() reduz um array a um único valor (ou estrutura) acumulando um resultado:
$resumo = array_reduce($usuarios, function($acumulador, $usuario) {
$acumulador['total']++;
$acumulador['sum_ages'] += $usuario['age'];
return $acumulador;
}, ['total' => 0, 'sum_ages' => 0]);
O que acontece aqui:
- Você começa com um valor inicial (neste caso, um array com total=0 e sum_ages=0)
- Para cada usuário, o acumulador é atualizado
- No final, você tem um único valor com o resultado agregado
- Analogia: É como contar moedas. Você começa com 0, pega cada moeda e soma, até ter o total.
A Apresentação para Marina
Quando Lucas terminou, ele foi até Marina e mostrou o código:
Lucas: "Marina, criei um Helper que encapsula as operações mais comuns com arrays. Agora posso reutilizar isso em qualquer lugar do projeto."
Marina: "Deixa eu ver... [analisando o código] ... Muito bom, Lucas! Você entendeu o conceito de DRY - Don't Repeat Yourself. Mas me explica: por que você usou métodos estáticos?"
Lucas: "Porque assim não preciso instanciar a classe. Posso chamar diretamente: Helper::filterRole(). Além disso, o Helper é mais uma coleção de funções utilitárias do que uma classe com estado."
Marina: "Perfeito! E você testou? Como você sabe que funciona?"
Lucas: "Testei com os dados do projeto. Veja: [mostrando os resultados] Funciona exatamente como esperado."
Marina: "Excelente! Vou revisar o código, mas já posso dizer que você entendeu bem o conceito. Vamos adicionar alguns testes unitários e depois mergeamos isso na main. Bom trabalho!"
Por Que Isso É Importante?
Lucas aprendeu várias lições valiosas nesse dia:
- Reutilização de Código - Em vez de copiar e colar o mesmo código várias vezes, ele criou uma solução reutilizável.
- Legibilidade - Código mais limpo é mais fácil de entender e manter. Comparar Helper::filterRole($data, 'admin') com um array_filter() aninhado é noite e dia.
- Manutenção - Se precisar mudar a lógica de filtro, ele muda em um único lugar, não em 10 lugares diferentes.
- Funções Nativas - Ele aprendeu a usar array_filter(), array_map() e array_reduce() de forma prática e efetiva.
- Pensamento Arquitetural - Um dev jr que consegue pensar em abstrações e reutilização está no caminho certo para sênior.
Como Você Pode Fazer o Mesmo
Se você é um dev jr como Lucas, aqui estão os passos:
- Identifique Padrões - Quando você vê o mesmo código repetindo, é hora de abstrair.
- Crie um Helper - Encapsule a lógica em uma classe com métodos estáticos.
- Use Funções Nativas - PHP tem muitas funções poderosas. Aprenda array_filter(), array_map(), array_reduce(), array_chunk(), etc.
- Documente - Adicione comentários explicando o que cada método faz e como usar.
- Teste - Certifique-se de que funciona antes de mostrar para o tech leader.
- Apresente com Confiança - Mostre que você entendeu o problema e a solução.
Conclusão
A história de Lucas é a história de muitos devs jr que descobrem que programação não é apenas escrever código que funciona, mas escrever código que é legível, reutilizável e fácil de manter.
O Helper que ele criou não é apenas uma coleção de funções. É um exemplo de pensamento crítico, compreensão de padrões e vontade de melhorar o código.
Se você está começando sua carreira como dev jr, lembre-se: o melhor código é aquele que você não precisa escrever duas vezes.
Link do código: https://github.com/yuri-spm/docker-php-stage/blob/main/src/Services/Helper.php
Dica Extra: Se você quer aprofundar em funções de array do PHP, estude também array_map(), array_chunk(), array_merge(), array_keys(), array_values() e usort(). Cada uma tem seu caso de uso específico, e conhecê-las bem é marca de um bom desenvolvedor PHP.
Comentários
Realize login para comentar neste post