Collections are a powerful, fluent wrapper around arrays, providing dozens of chainable methods for working with data elegantly (map, filter, reduce, groupBy, etc.). Eloquent query results are returned as Collections, so you use them constantly.
$collection = collect([1, 2, 3, 4, 5]);
$result = $collection
->filter(fn($n) => $n % 2 === 0) // [2, 4]
->map(fn($n) => $n * 10) // [20, 40]
->values(); // re-index
$collection->sum(); // 15
$collection->avg(); // 3
$collection->max(); // 5
A Collection wraps an array and offers a fluent, chainable API — far more expressive than manual array functions, and chainable for clean data pipelines.
$users = User::all(); // returns a Collection of User models
$users->where('active', true) // filter
->sortBy('name')
->map(fn($u) => $u->name)
->take(10);
$users->pluck('email'); // extract one field → a collection of emails
$users->groupBy('role'); // group by a field → role => [users]
$users->keyBy('id'); // index by id
Because Eloquent returns Collections, you can elegantly transform query results in PHP — though for large datasets, prefer database queries over fetching everything and filtering in PHP.
map, filter, reduce, each transform/iterate
pluck, keyBy, groupBy, partition restructure
sum, avg, min, max, count aggregate
sort, sortBy, reverse, unique order/dedup
first, last, take, skip, chunk slice
contains, every, some, where query
implode, flatten, collapse, merge combine
Collections are an important, pervasive Laravel feature — they make working with arrays and data elegant and expressive, and since Eloquent query results are Collections, you use them constantly when handling database data, making them everyday, essential knowledge.
The core value is the fluent, chainable API: instead of verbose, imperative array manipulation, Collections let you express data transformations (filtering, mapping, grouping, aggregating, sorting) as readable, composable method chains — a major productivity and readability benefit that embodies Laravel's elegant style.
Understanding the rich method set (map/filter/reduce for transformation, pluck/groupBy/keyBy for restructuring, aggregation and sorting methods) lets you process data cleanly and is necessary for working effectively with Eloquent results (which return Collections you then transform).
Knowing Collections — their fluent API, the breadth of available methods, and that Eloquent uses them — is fundamental for productive Laravel development, since data manipulation is constant and Collections are how Laravel makes it elegant. (One important practical caveat: for filtering/sorting large datasets, prefer doing the work in the database query rather than fetching all records into a Collection and processing in PHP — Collections are for in-memory data manipulation, not a replacement for efficient queries.) Fluency with Collections is a hallmark of idiomatic, productive Laravel code.