Five Clever Ways to Use the chunk Method

Collections are a core feature of Laravel, providing a convenient way to work with arrays and objects. One of the handy methods available on collections is chunk(), which allows you to break a collection into smaller, equally-sized pieces. This article will demonstrate five ways to use the chunk() method to make your life easier when working with Laravel collections.

How does chunk() work?

The chunk() method is a powerful feature that allows you to break a collection into smaller, equally-sized chunks. In this article, we will take a deep dive into the chunk() method, analyzing how it works under the hood and exploring its implementation in the Laravel framework.

The chunk() method divides a collection into smaller pieces of a specified size. Here is the source code for the chunk() method:

/**
 * Chunk the collection into chunks of the given size.
 *
 * @param  int  $size
 * @return static<int, static>
 */
public function chunk($size)
{
    if ($size <= 0) {
        return new static;
    }

    $chunks = [];

    foreach (array_chunk($this->items, $size, true) as $chunk) {
        $chunks[] = new static($chunk);
    }

    return new static($chunks);
}

Let's break down this code to understand how it works step by step.

1. Checking the chunk size:

The first step is to check whether the given chunk size is valid. If the size is less than or equal to zero, the function returns an empty collection.

if ($size <= 0) {
    return new static;
}

2. Initializing the chunks array:

The method initializes an empty array named $chunks to store the resulting chunked collections.

$chunks = [];

3. Using array_chunk():

The core of the chunk() method relies on PHP's built-in array_chunk() function. This function splits the input array into chunks of the specified size, preserving the original keys if the third parameter is set to true. The array_chunk() function is applied to the collection's underlying array $this->items.

foreach (array_chunk($this->items, $size, true) as $chunk) {
    // ...
}

4. Creating new collections for each chunk:

Inside the foreach loop, the method creates a new Laravel Collection for each chunk, passing the chunk as an argument. This ensures that each chunk is an instance of the Collection class, maintaining consistency and convenience.

$chunks[] = new static($chunk);

5. Returning the chunked collections:

Finally, the method returns a new Collection instance containing the chunked collections. This allows you to continue chaining methods on the resulting collection.

return new static($chunks);

1. Paginating Large Data Sets

When dealing with large data sets, you may need to display it in smaller, more manageable chunks. You can use the chunk() method to paginate the data and make it easier for users to navigate through the content. For example, if you have a collection of 100 items and want to display 20 items per page, you can use the chunk() method as follows:

$collection = collect(range(1, 100));
$perPage = 20;
$page = 1;

$paginatedCollection = $collection->chunk($perPage)->get($page - 1);

In the given code, a Laravel collection is being paginated using the chunk() method. Let's break down each line to understand how this works:

1. $collection = collect(range(1, 100));

This line creates a new Laravel collection containing the numbers from 1 to 100 using the collect() function and the range() function. The range() function generates an array containing a range of numbers, and the collect() function converts this array into a Laravel collection.

2. $perPage = 20;

This line sets the number of items to be displayed per page. In this case, we want to show 20 items per page.

3. $page = 1;

This line sets the current page number. In this example, we want to retrieve the first page of the paginated collection.

4. $paginatedCollection = $collection->chunk($perPage)->get($page - 1);

This line is responsible for paginating the collection using the chunk() method. The chunk() method takes a single argument: the number of items per chunk. In this case, we pass $perPage, which is set to 20. The chunk() method returns a new collection, where each item is a chunk (a smaller collection) containing the specified number of items.

After chunking the collection, the get() method is used to retrieve the desired page. Since the index is zero-based, we subtract 1 from the $page variable to get the correct index. In this case, the index will be 0, which retrieves the first chunk (i.e., the first page) of the paginated collection.

The final result, $paginatedCollection, will be a Laravel collection containing the first 20 items of the original collection, which represents the first page of the paginated collection.

2. Processing Large Data Sets in Batches

When working with large data sets, it is often more efficient to process the data in smaller batches to reduce memory usage. The chunk() method allows you to break the data into smaller pieces, which can then be processed one at a time. This is especially helpful when importing or exporting large data sets:

$collection = collect(range(1, 1000));
$chunkSize = 100;

$collection->chunk($chunkSize)->each(function ($chunk) {
    // Memory intensive operation for chunk
    $chunk->each(function ($item) {
        // Perform your processing logic here
    });
});

Let's break down the code step by step to understand how it works:

1. $collection = collect(range(1, 1000));

This line creates a new Laravel collection containing 1000 items, with values ranging from 1 to 1000. The range() function generates an array with these values, and the collect() function turns the array into a Laravel collection.

2. $chunkSize = 100;

This line sets the chunk size to 100, meaning that the collection will be divided into smaller collections of 100 items each.

3. $collection->chunk($chunkSize)

The chunk() method is called on the original collection, splitting it into smaller chunks according to the specified chunk size. The result is a new collection containing the smaller chunks.

4. ->each(function ($chunk) {...});

The each() method is called on the new collection of chunks. This method iterates through the chunks and executes the provided callback function for each chunk.

5. $chunk->each(function ($item) {...});

Inside the callback function for each chunk, another each() method is called on the chunk itself. This method iterates through the items within the chunk and executes the provided callback function for each item.

3. Grouping Related Items Together

You can use the chunk() method to group related items together in a collection. For example, if you have a collection of dates and want to group them by week, you can use the chunk() method to create a new collection with each chunk representing one week:

$dates = collect([
    '2023-04-01', '2023-04-02', '2023-04-03', '2023-04-04',
    '2023-04-05', '2023-04-06', '2023-04-07', '2023-04-08',
    '2023-04-09', '2023-04-10', '2023-04-11', '2023-04-12',
]);

$datesPerWeek = 7;

$groupedDates = $dates->chunk($datesPerWeek);

Here's how the code works:

1. First, we create a collection named $dates with a list of dates.
2. Next, we define a variable $datesPerWeek and set its value to 7, which represents the number of days in a week.
3. Finally, we use the chunk() method on the $dates collection to create a new collection called $groupedDates, where each chunk contains $datesPerWeek (7) items.
4. After executing this code, the $groupedDates collection will contain two chunks. The first chunk will contain the dates from '2023-04-01' to '2023-04-07', and the second chunk will contain the dates from '2023-04-08' to '2023-04-12'.

The chunk() method is helpful in this scenario for grouping related items together based on a specific criterion. In this case, it's used to group dates into weeks, making it easier to work with the dates when organizing or displaying them in a weekly format.

4. Splitting a Collection into Columns

If you need to display a collection of items in a table with a fixed number of columns, you can use the chunk() method to split the collection into columns. This can be useful for creating responsive layouts:

$collection = collect(range(1, 12));
$columns = 3;

$columnizedCollection = $collection->chunk(ceil($collection->count() / $columns));

Let's break down the code to understand how it works:

1. $collection = collect(range(1, 12));

A new Laravel collection is created with the numbers 1 to 12 using the collect() function and the range() function. The range() function generates an array of integers from the first argument (1) to the second argument (12).

2. $columns = 3;

A variable $columns is defined, which represents the desired number of columns the collection should be split into.

3. $columnizedCollection = $collection->chunk(ceil($collection->count() / $columns));

The collection is then split into columns using the chunk() method. The size of each chunk is calculated by dividing the total count of items in the collection by the desired number of columns. The ceil() function is used to round up the result to the nearest integer, ensuring that each chunk has an equal or smaller size than the calculated value.

In this case, the total number of items in the collection is 12, and we want to split the collection into 3 columns. So, the chunk size is calculated as follows:

ceil(12 / 3) = ceil(4) = 4

The chunk() method then splits the collection into chunks of size 4:

Chunk 1: [1, 2, 3, 4]
Chunk 2: [5, 6, 7, 8]
Chunk 3: [9, 10, 11, 12]

These chunks represent the columns, and the result is assigned to the variable $columnizedCollection.

5. Distributing Items Evenly

In some cases, you may need to distribute a collection of items evenly across multiple containers, such as when creating a carousel or masonry grid. The chunk() method can help you achieve this:

$collection = collect(range(1, 12));
$containers = 3;

$evenlyDistributed = $collection->chunk(ceil($collection->count() / $containers));

Let's break it down step by step:

1. Create a collection with the numbers 1 through 12:

$collection = collect(range(1, 12));

collect() is a Laravel helper function that creates a new collection instance, and range(1, 12) generates an array with the numbers from 1 to 12.

2. Define the number of containers you want to distribute the items across:

$containers = 3;

In this example, we want to distribute the collection items across three containers.

3. Calculate the chunk size:

$chunkSize = ceil($collection->count() / $containers);

$collection->count() returns the number of items in the collection. We divide this count by the number of containers (3) and round up the result using the ceil() function to ensure that we're accounting for any remaining items that may not fit evenly in each container.

In this example, the chunk size will be ceil(12 / 3), which equals 4.

4. Use the chunk() method to create a new collection with the items evenly distributed across the specified number of containers:

$evenlyDistributed = $collection->chunk($chunkSize);

The chunk() method takes a single argument, the chunk size, and returns a new collection where the original collection is split into smaller collections (chunks) with the specified chunk size.

In this example, the $evenlyDistributed collection will have three chunks, each containing four items:

[
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

By using the chunk() method with a calculated chunk size, we can evenly distribute the items of a Laravel collection into a specified number of containers.

Wrapping Up

The chunk() method is a versatile tool when working with Laravel collections. Whether you're paginating large data sets, processing data in batches, grouping related items, splitting a collection into columns, or distributing items evenly, the chunk() method can simplify your code and make your life easier. By leveraging the power of Laravel collections and the chunk() method, you can build more efficient and user-friendly applications.

Remember that while the chunk() method is an excellent solution for many use cases, it may not always be the best fit for your specific situation. Be sure to explore other methods available on Laravel collections to find the one that best suits your needs. In any case, Laravel collections will undoubtedly prove to be a valuable tool in your web development toolkit. Happy coding!

Subscribe for exclusive content