By Harris Raftopoulos in laravel — Sep 3, 2024

Simplifying Data Manipulation with Laravel's High Order Collections

Laravel's collections are already a powerful tool for working with arrays of data, but high order collections take this to the next level. These methods allow you to perform common operations on collections in a more concise and expressive way, leading to cleaner and more readable code. Let's dive into how you can leverage high order collections in your Laravel projects.

Understanding High Order Collections

High order collection methods in Laravel allow you to call collection methods directly on the collection items, without the need for nested closures. This results in more compact and often more readable code.

Basic Usage

Here's a simple example comparing traditional collection methods with high order methods:

// Traditional approach
$activeUserNames = $users->filter(function ($user) {
    return $user->isActive();
})->map(function ($user) {
    return $user->name;
});

// Using high order collections
$activeUserNames = $users->filter->isActive()->map->name;

As you can see, the high order approach is much more concise.

Common High Order Methods

filter()

The filter() method becomes particularly elegant with high order collections:

$adults = $users->filter->isAdult();

This assumes your User model has an isAdult() method.

map()

map() is another method that benefits greatly from the high order approach:

$userEmails = $users->map->email;

This is equivalent to $users->map(function ($user) { return $user->email; }).

sort()

Sorting can also be simplified:

$sortedUsers = $users->sortBy->lastLoginAt;

Chaining Multiple High Order Methods

One of the strengths of high order collections is the ability to chain multiple operations:

$result = $users
    ->filter->isActive()
    ->map->name
    ->sort()
    ->take(5);

This code filters for active users, maps to their names, sorts the names, and takes the first 5.

Real-World Example: Processing Orders

Let's look at a more complex example involving order processing:

$highValueOrders = $orders
    ->filter->isPaid()
    ->filter->shipped()
    ->map->items
    ->collapse()
    ->groupBy->product_id
    ->map->sum('price')
    ->filter(function ($total) {
        return $total > 1000;
    })
    ->sortDesc()
    ->take(10);

This code does the following:

Filters for paid and shipped orders
Maps to the items in each order
Collapses the items into a single collection
Groups items by product ID
Sums the price for each product
Filters for products with total sales over $1000
Sorts in descending order
Takes the top 10

Combining with Regular Collection Methods

High order methods can be seamlessly combined with regular collection methods:

$result = $users
    ->filter->isActive()
    ->mapToGroups(function ($user) {
        return [$user->role => $user->name];
    })
    ->map->sort()
    ->map->take(3);

This groups active users by role, sorts names within each role, and takes the top 3 from each group.

Performance Considerations

While high order collections can make your code more readable, be aware that they might have a slight performance overhead compared to using closures directly. For most applications, this difference is negligible, but it's worth considering for performance-critical sections of your code.

If this guide was helpful to you, subscribe to my daily newsletter and give me a follow on X/Twitter. It helps a lot!