5 Powerful Ways to Use the all() method

Laravel offers a powerful and expressive feature called Collections. Collections are wrappers around arrays, providing an extensive list of methods to manipulate and interact with your data. One such method is the all() method, which retrieves the underlying array from the collection. In this article, we will explore five ways to effectively use the all() method on a Laravel collection.

How Does the all() Method work

In its simplest form, the all() method transforms the collection elements into a PHP array. This can be useful when needing to work with functions that only accept native arrays or if you prefer a simple array.

Let's explore what happens when a collection is created using the collect() helper function:

1. The first argument passed to the collect() function is passed to the Collection class constructor.
2. The argument is then converted to an array and assigned to the items property of the Collection class.
3. A new Collection class instance is returned.

Consider this example:

$collection = collect([1, 2, 3]);
$array = $collection->all(); // [1, 2, 3]

The array is passed to the collect() function. The collect() function passes the first argument to the Collection class.

function collect($value = [])
{
    return new Collection($value);
}

The constructor converts the items to an array and assigns it to the items property on the Collection class.

class Collection
{
    protected $items = [];

    public function __construct($items = [])
    {
        $this->items = $this->getArrayableItems($items);
    }

    public function all()
    {
        return $this->items;
    }
}

Calling the all() method simply returns the $items property on the Collection class.

What can be converted into a collection?

At the time of this writing, collections can support:

• arrays
• anything that can be typecast to an array in native PHP
• Enumerable: the ability to systematically traverse and process collections of data, such as arrays or objects by implementing the Iterator or IteratorAggregate interfaces, using built-in constructs like foreach loops and array functions.
• Arrayable: an object or data structure that can be easily converted into an array, typically by implementing a method like toArray() that returns an array representation of the object's data or properties.
• Traversable: an abstract base interface that enables objects to be iterable in a foreach loop by implementing either the Iterator or IteratorAggregate interfaces, allowing developers to traverse and manipulate data collections consistently.
• Jsonable: an object or data structure that can be easily converted to a JSON (JavaScript Object Notation) representation, usually by implementing a specific method or interface that handles JSON serialization.
• JsonSerializable: an interface that allows objects to customize their JSON representation by implementing the jsonSerialize() method. This method is called when using json_encode() to convert the object into a JSON string.
• UnitEnum: a PHP Enum or the built-in abstract class introduced in PHP 8.1, which allows developers to define a set of named, distinct enumeration values as a custom data type, improving type safety and code readability.

1. Converting a Collection to an Array

The most basic use of the all() method is to convert a collection back into an array. This can be useful when working with native PHP functions that do not support collections. It can also be useful when you want to revert your data to a simple array format. Here's an example:

$collection = collect([1, 2, 3, 4, 5]);
$array = $collection->all();

// The resulting array will be: [1, 2, 3, 4, 5]

Here's a breakdown of what's happening in the code:

• $collection = collect([1, 2, 3, 4, 5]);: The collect() function is a global helper function provided by Laravel to create a new Collection instance. In this case, a Collection object is created from an array containing the elements 1, 2, 3, 4, and 5. The new Collection object is stored in the variable $collection.
• $array = $collection->all();: The all() method is called on the $collection object. This method returns the underlying array from the Collection, which in this case is [1, 2, 3, 4, 5]. The result is assigned to the variable $array.

After the code is executed, $array will contain the same elements as the original array used to create the Collection: [1, 2, 3, 4, 5].

2. Retrieving Filtered Data

You can combine the all() method with other collection methods, such as filter(), to retrieve a specific subset of data. For instance, you might want to retrieve all even numbers from a collection:

$collection = collect([1, 2, 3, 4, 5]);

$evenNumbers = $collection->filter(function ($number) {
    return $number % 2 === 0;
})->all();

// The resulting array will be: [2, 4]

Here's a breakdown of what's happening in the code:

• $collection = collect([1, 2, 3, 4, 5]);: A new collection object is created by passing an array [1, 2, 3, 4, 5] to the collect() function. This collection object contains the original array.
• $evenNumbers = $collection->filter(function ($number): The filter() method is called on the $collection object. It takes a closure (an anonymous function) as an argument. The closure will be applied to each element in the collection.
• return $number % 2 === 0;: This line is inside the closure. It checks if the current element $number is even by using the modulo operator %. If the remainder of the division of $number by 2 is equal to 0, then the number is even, and the closure returns true. Otherwise, it returns false.
• ->all();: The filter() method iterates over each element in the $collection, applying the provided closure. If the closure returns true, the element is included in the resulting collection. In this case, it will include all even numbers. After filtering, the all() method is called, which returns the filtered collection's underlying array.

3. Transforming Collection Data

By chaining the all() method with the map() method, you can transform the data within a collection and retrieve the results as an array. Suppose you want to calculate the square of each number in a collection:

$collection = collect([1, 2, 3, 4, 5]);

$squares = $collection->map(function ($number) {
    return $number * $number;
})->all();

// The resulting array will be: [1, 4, 9, 16, 25]

Here's a breakdown of what's happening in the code:

• $collection = collect([1, 2, 3, 4, 5]);: This line creates a new Laravel Collection object with the given array [1, 2, 3, 4, 5]. The collect() function is a Laravel helper function that wraps the given array inside a Collection object, allowing you to perform various operations on the collection.
• $squares = $collection->map(function ($number): The map() method is called on the $collection object. It takes a callback function as an argument. The callback function accepts a single parameter $number which will be each element of the collection.
• return $number * $number;: Inside the callback function, the square of the input $number is calculated by multiplying it by itself, and then the result is returned.
• ->all();: The map() method returns a new Collection object with the transformed elements (the squares of the input numbers in this case). The all() method is then called on the resulting collection to convert it back to an array.

4. Sorting Collection Data

You can use the all() method in conjunction with the sortBy() or sortByDesc() methods to sort the collection data and retrieve the sorted data as an array. For example, sorting a collection of products by price in descending order:

$products = collect([
    ['name' => 'Product A', 'price' => 100],
    ['name' => 'Product B', 'price' => 150],
    ['name' => 'Product C', 'price' => 50],
]);

$sortedProducts = $products->sortByDesc('price')->all();

// The resulting array will be:
// [
//     ['name' => 'Product B', 'price' => 150],
//     ['name' => 'Product A', 'price' => 100],
//     ['name' => 'Product C', 'price' => 50],
// ]

Here's a breakdown of what's happening in the code:

• First, the '$products' variable is initialized with a collection of three associative arrays. Each associative array represents a product with a 'name' and a 'price'. The collect() function is a Laravel helper function to create a new collection instance.
• Then, the $sortedProducts variable is created by calling the sortByDesc() method on the $products collection. This method sorts the collection in descending order based on the given key, which in this case is 'price'. So, the products will be sorted from the most expensive to the least expensive.
• The all() method is called on the sorted collection to return the underlying array, which is then assigned to the $sortedProducts variable.
• The code includes a comment that shows the expected resulting array after the sorting is performed. The array will have the products sorted in descending order based on their prices.

5. Grouping Collection Data

You can also use the all() method with the groupBy() method to group collection data by a specific key and retrieve the groups as an array. For example, grouping users by their account type:

$users = collect([
    ['name' => 'Alice', 'account_type' => 'admin'],
    ['name' => 'Bob', 'account_type' => 'user'],
    ['name' => 'Charlie', 'account_type' => 'admin'],
]);

$groupedUsers = $users->groupBy('account_type')->all();

// The resulting array will be:
//[
//    'admin' => [
//        ['name' => 'Alice', 'account_type' => 'admin'],
//        ['name' => 'Charlie', 'account_type' => 'admin'],
//    ],
//    'user' => [
//        ['name' => 'Bob', 'account_type' => 'user'],
//    ],
//];

Here's a breakdown of what's happening in the code:

• The collect() function is called with an array of associative arrays as its argument. Each associative array represents a user, containing keys 'name' and 'account_type', and corresponding values. The collect() function creates a new instance of the Collection class, wrapping the provided array.
• The $users variable is assigned the newly created Collection instance.
• Next, the groupBy() method is called on the $users Collection instance. This method takes a single argument, which is the key by which the items in the collection should be grouped. In this case, the key is 'account_type'. The method returns a new Collection instance with the items grouped by the specified key.
• Finally, the all() method is called on the grouped Collection instance. This method returns the underlying array of the collection. The $groupedUsers variable is assigned the resulting array.

Wrapping up

The all() method in Laravel collections provides a flexible and powerful way to retrieve the underlying array from a collection. By combining the all() method with other collection methods, you can efficiently filter, transform, sort, and group your data to meet your specific requirements. As demonstrated in this article, the all() method is a valuable tool in your Laravel toolkit, simplifying your work with data manipulation and enabling you to build more robust and efficient applications.

Subscribe for exclusive content