Laravel Collections

Tempo de leitura: 4 minutos

Laravel Collections são uma abstração poderosa para manipular arrays de dados. Elas fornecem uma interface fluente (encadeada) e expressiva que simplifica operações complexas de manipulação de conjuntos de dados, como filtragem, mapeamento e redução. Essencialmente, uma Collection é um objeto que envolve um array PHP e o estende com dezenas de métodos úteis.

Dominar as Collections acabaca sendo fundamental para escrever código Laravel limpo, conciso e com alta performance.

1. 📝 Criando e Obtendo Collections

No Laravel, o helper global collect() é a maneira mais comum de instanciar uma Collection.

A. Fontes de Dados

Fonte	Método	Exemplo
Array Puro	Helper `collect()`	`$c = collect([1, 2, 3]);`
Consulta DB	`DB::table(...)->get()`	O Laravel retorna nativamente um objeto Collection.
Relacionamentos Eloquent	Propriedade de relacionamento.	`$user->posts` retorna uma Collection.

B. O Objeto Collection

Um objeto Collection sempre permite o acesso ao array PHP subjacente através do método ->all().

PHP

use Illuminate\Support\Collection;

$collection = collect(['apple', 'banana', 'cherry']);

// Obtém o array PHP
$array = $collection->all(); // ['apple', 'banana', 'cherry']

2. ✨ Métodos Essenciais de Manipulação

Os métodos de Collection geralmente retornam uma nova Collection, permitindo que você encadeie operações sem alterar a Collection original (o que é chamado de Imutabilidade).

A. Transformação

Método	Função	Exemplo
`map()`	Aplica um callback a cada item, retornando uma nova Collection dos resultados.	`$nomes = $users->map(fn($u) => $u->name);`
`pluck()`	Extrai os valores de uma chave específica de todos os itens.	`$ids = $users->pluck('id');`

B. Filtragem e Agrupamento

Método	Função	Exemplo
`filter()`	Retorna itens que satisfazem uma condição.	`$ativos = $users->filter(fn($u) => $u->status === 'active');`
`where()`	Filtragem simples com base em pares chave/valor.	`$ativos = $users->where('status', 'active');`
`groupBy()`	Agrupa a Collection por um valor de chave.	`$grouped = $posts->groupBy('category_id');`

C. Redução

Método	Função	Exemplo
`reduce()`	Reduz a Collection a um único valor.	`$somaSalarios = $users->reduce(fn($carry, $u) => $carry + $u->salary, 0);`
`sum()`	Soma todos os valores ou os valores de uma chave.	`$total = $orders->sum('amount');`

D. Ordenação e Busca

Método	Função	Exemplo
`sortBy()`	Ordena a Collection por uma chave.	`$sorted = $users->sortBy('name');`
`first()` / `last()`	Retorna o primeiro/último item que satisfaz a condição (opcional).	`$firstAdmin = $users->first(fn($u) => $u->isAdmin);`
`contains()`	Verifica se a Collection contém um valor ou satisfaz um callback.	`if ($users->contains('name', 'John Doe')) { /* ... */ }`

3. 😴 Lazy Collections (Processamento de Grandes Dados)

As Lazy Collections (Illuminate\Support\LazyCollection) são a solução do Laravel para lidar com grandes conjuntos de dados sem esgotar a memória da aplicação.

A. O Problema da Memória (Eager)

Uma Collection normal (collect()) é eager (ávida): ela carrega todos os dados do array na memória imediatamente.

B. A Solução Lazy (Deferred)

Uma Lazy Collection é diferida (ou deferred): ela só processa e carrega cada item à medida que ele é solicitado (iterado). A chave é que ela não carrega todos os 10.000 registros na memória de uma vez.

Você cria uma Lazy Collection a partir de um gerador (como o cursor() do Eloquent).

PHP

// 1. Usando o cursor() do Eloquent
// $users agora é uma Lazy Collection que buscará do DB um item por vez
$lazyUsers = App\Models\User::cursor(); 

// 2. Criando a partir de um array existente:
$lazyCollection = collect($usersArray)->lazy();

Exemplo de Uso Lazy

PHP

$sumOfActiveSalaries = $lazyUsers
    // Filtra o primeiro item, processa, vai para o próximo...
    ->filter(fn($user) => $user->is_active) 
    // Mapeia o primeiro item filtrado, processa, vai para o próximo...
    ->map(fn($user) => $user->salary) 
    // Apenas agora é que o valor final (a soma) é calculado.
    ->sum();

Nota: Se você chamar um método que requer a coleção inteira (como count() ou sortBy()), a natureza lazy será perdida, e todos os dados serão carregados na memória.

✅ Conclusão Laravel Collections

Laravel Collections: As Collections são a forma do Laravel para manipulação de dados, oferecendo uma API fluente e intuitiva que substitui a necessidade de estruturas de loop e array complexas. Para otimizar o consumo de memória em operações com grandes volumes de dados, o uso de Lazy Collections (via Model::cursor()) é a melhor prática para o desenvolvedor Laravel moderno.

Mas antes de dominar o Laravel, se for o seu caso, toda jornada tem um início. Vamos entender quais são os conhecimentos básicos necessários para aproveitar ao máximo este poderoso framework. Para iniciar seus estudos no Laravel, você precisará dominar as seguintes tecnologias: