Collections

• Introduction
  • Creating Collections
  • Extending Collections
• Available Methods
• Higher Order Messages
• Lazy Collections
  • Introduction
  • Creating Lazy Collections
  • The Enumerable Contract
  • Lazy Collection Methods

Introduction

The Illuminate\Support\Collection class provides a fluent, convenient wrapper for working with arrays of data. For example, check out the following code. We'll use the collect helper to create a new collection instance from the array, run the strtoupper function on each element, and then remove all empty elements:

1$collection = collect(['taylor', 'abigail', null])->map(function (?string $name) {
2    return strtoupper($name);
3})->reject(function (string $name) {
4    return empty($name);
5});
1$collection = collect(['taylor', 'abigail', null])->map(function (?string $name) {
2    return strtoupper($name);
3})->reject(function (string $name) {
4    return empty($name);
5});

As you can see, the Collection class allows you to chain its methods to perform fluent mapping and reducing of the underlying array. In general, collections are immutable, meaning every Collection method returns an entirely new Collection instance.

Creating Collections

As mentioned above, the collect helper returns a new Illuminate\Support\Collection instance for the given array. So, creating a collection is as simple as:

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

Extending Collections

Collections are "macroable", which allows you to add additional methods to the Collection class at run time. The Illuminate\Support\Collection class' macro method accepts a closure that will be executed when your macro is called. The macro closure may access the collection's other methods via $this, just as if it were a real method of the collection class. For example, the following code adds a toUpper method to the Collection class:

 1use Illuminate\Support\Collection;
 2use Illuminate\Support\Str;
 3 
 4Collection::macro('toUpper', function () {
 5    return $this->map(function (string $value) {
 6        return Str::upper($value);
 7    });
 8});
 9 
10$collection = collect(['first', 'second']);
11 
12$upper = $collection->toUpper();
13 
14// ['FIRST', 'SECOND']
 1use Illuminate\Support\Collection;
 2use Illuminate\Support\Str;
 3 
 4Collection::macro('toUpper', function () {
 5    return $this->map(function (string $value) {
 6        return Str::upper($value);
 7    });
 8});
 9 
10$collection = collect(['first', 'second']);
11 
12$upper = $collection->toUpper();
13 
14// ['FIRST', 'SECOND']

Typically, you should declare collection macros in the boot method of a service provider.

Macro Arguments

If necessary, you may define macros that accept additional arguments:

 1use Illuminate\Support\Collection;
 2use Illuminate\Support\Facades\Lang;
 3 
 4Collection::macro('toLocale', function (string $locale) {
 5    return $this->map(function (string $value) use ($locale) {
 6        return Lang::get($value, [], $locale);
 7    });
 8});
 9 
10$collection = collect(['first', 'second']);
11 
12$translated = $collection->toLocale('es');
 1use Illuminate\Support\Collection;
 2use Illuminate\Support\Facades\Lang;
 3 
 4Collection::macro('toLocale', function (string $locale) {
 5    return $this->map(function (string $value) use ($locale) {
 6        return Lang::get($value, [], $locale);
 7    });
 8});
 9 
10$collection = collect(['first', 'second']);
11 
12$translated = $collection->toLocale('es');

Available Methods

For the majority of the remaining collection documentation, we'll discuss each method available on the Collection class. Remember, all of these methods may be chained to fluently manipulate the underlying array. Furthermore, almost every method returns a new Collection instance, allowing you to preserve the original copy of the collection when necessary:

Method Listing

after()

The after method returns the item after the given item. null is returned if the given item is not found or is the last item:

1$collection = collect([1, 2, 3, 4, 5]);
2 
3$collection->after(3);
4 
5// 4
6 
7$collection->after(5);
8 
9// null
1$collection = collect([1, 2, 3, 4, 5]);
2 
3$collection->after(3);
4 
5// 4
6 
7$collection->after(5);
8 
9// null

This method searches for the given item using "loose" comparison, meaning a string containing an integer value will be considered equal to an integer of the same value. To use "strict" comparison, you may provide the strict argument to the method:

1collect([2, 4, 6, 8])->after('4', strict: true);
2 
3// null
1collect([2, 4, 6, 8])->after('4', strict: true);
2 
3// null

Alternatively, you may provide your own closure to search for the first item that passes a given truth test:

1collect([2, 4, 6, 8])->after(function (int $item, int $key) {
2    return $item > 5;
3});
4 
5// 8
1collect([2, 4, 6, 8])->after(function (int $item, int $key) {
2    return $item > 5;
3});
4 
5// 8

all()

The all method returns the underlying array represented by the collection:

1collect([1, 2, 3])->all();
2 
3// [1, 2, 3]
1collect([1, 2, 3])->all();
2 
3// [1, 2, 3]

average()

Alias for the avg method.

avg()

The avg method returns the average value of a given key:

 1$average = collect([
 2    ['foo' => 10],
 3    ['foo' => 10],
 4    ['foo' => 20],
 5    ['foo' => 40]
 6])->avg('foo');
 7 
 8// 20
 9 
10$average = collect([1, 1, 2, 4])->avg();
11 
12// 2
 1$average = collect([
 2    ['foo' => 10],
 3    ['foo' => 10],
 4    ['foo' => 20],
 5    ['foo' => 40]
 6])->avg('foo');
 7 
 8// 20
 9 
10$average = collect([1, 1, 2, 4])->avg();
11 
12// 2

before()

The before method is the opposite of the after method. It returns the item before the given item. null is returned if the given item is not found or is the first item:

 1$collection = collect([1, 2, 3, 4, 5]);
 2 
 3$collection->before(3);
 4 
 5// 2
 6 
 7$collection->before(1);
 8 
 9// null
10 
11collect([2, 4, 6, 8])->before('4', strict: true);
12 
13// null
14 
15collect([2, 4, 6, 8])->before(function (int $item, int $key) {
16    return $item > 5;
17});
18 
19// 4
 1$collection = collect([1, 2, 3, 4, 5]);
 2 
 3$collection->before(3);
 4 
 5// 2
 6 
 7$collection->before(1);
 8 
 9// null
10 
11collect([2, 4, 6, 8])->before('4', strict: true);
12 
13// null
14 
15collect([2, 4, 6, 8])->before(function (int $item, int $key) {
16    return $item > 5;
17});
18 
19// 4

chunk()

The chunk method breaks the collection into multiple, smaller collections of a given size:

1$collection = collect([1, 2, 3, 4, 5, 6, 7]);
2 
3$chunks = $collection->chunk(4);
4 
5$chunks->all();
6 
7// [[1, 2, 3, 4], [5, 6, 7]]
1$collection = collect([1, 2, 3, 4, 5, 6, 7]);
2 
3$chunks = $collection->chunk(4);
4 
5$chunks->all();
6 
7// [[1, 2, 3, 4], [5, 6, 7]]

This method is especially useful in views when working with a grid system such as Bootstrap. For example, imagine you have a collection of Eloquent models you want to display in a grid:

1@foreach ($products->chunk(3) as $chunk)
2    <div class="row">
3        @foreach ($chunk as $product)
4            <div class="col-xs-4">{{ $product->name }}</div>
5        @endforeach
6    </div>
7@endforeach
1@foreach ($products->chunk(3) as $chunk)
2    <div class="row">
3        @foreach ($chunk as $product)
4            <div class="col-xs-4">{{ $product->name }}</div>
5        @endforeach
6    </div>
7@endforeach

chunkWhile()

The chunkWhile method breaks the collection into multiple, smaller collections based on the evaluation of the given callback. The $chunk variable passed to the closure may be used to inspect the previous element:

1$collection = collect(str_split('AABBCCCD'));
2 
3$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) {
4    return $value === $chunk->last();
5});
6 
7$chunks->all();
8 
9// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]
1$collection = collect(str_split('AABBCCCD'));
2 
3$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) {
4    return $value === $chunk->last();
5});
6 
7$chunks->all();
8 
9// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]

collapse()

The collapse method collapses a collection of arrays into a single, flat collection:

 1$collection = collect([
 2    [1, 2, 3],
 3    [4, 5, 6],
 4    [7, 8, 9],
 5]);
 6 
 7$collapsed = $collection->collapse();
 8 
 9$collapsed->all();
10 
11// [1, 2, 3, 4, 5, 6, 7, 8, 9]
 1$collection = collect([
 2    [1, 2, 3],
 3    [4, 5, 6],
 4    [7, 8, 9],
 5]);
 6 
 7$collapsed = $collection->collapse();
 8 
 9$collapsed->all();
10 
11// [1, 2, 3, 4, 5, 6, 7, 8, 9]

collect()

The collect method returns a new Collection instance with the items currently in the collection:

1$collectionA = collect([1, 2, 3]);
2 
3$collectionB = $collectionA->collect();
4 
5$collectionB->all();
6 
7// [1, 2, 3]
1$collectionA = collect([1, 2, 3]);
2 
3$collectionB = $collectionA->collect();
4 
5$collectionB->all();
6 
7// [1, 2, 3]

The collect method is primarily useful for converting lazy collections into standard Collection instances:

 1$lazyCollection = LazyCollection::make(function () {
 2    yield 1;
 3    yield 2;
 4    yield 3;
 5});
 6 
 7$collection = $lazyCollection->collect();
 8 
 9$collection::class;
10 
11// 'Illuminate\Support\Collection'
12 
13$collection->all();
14 
15// [1, 2, 3]
 1$lazyCollection = LazyCollection::make(function () {
 2    yield 1;
 3    yield 2;
 4    yield 3;
 5});
 6 
 7$collection = $lazyCollection->collect();
 8 
 9$collection::class;
10 
11// 'Illuminate\Support\Collection'
12 
13$collection->all();
14 
15// [1, 2, 3]

combine()

The combine method combines the values of the collection, as keys, with the values of another array or collection:

1$collection = collect(['name', 'age']);
2 
3$combined = $collection->combine(['George', 29]);
4 
5$combined->all();
6 
7// ['name' => 'George', 'age' => 29]
1$collection = collect(['name', 'age']);
2 
3$combined = $collection->combine(['George', 29]);
4 
5$combined->all();
6 
7// ['name' => 'George', 'age' => 29]

concat()

The concat method appends the given array or collection's values onto the end of another collection:

1$collection = collect(['John Doe']);
2 
3$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
4 
5$concatenated->all();
6 
7// ['John Doe', 'Jane Doe', 'Johnny Doe']
1$collection = collect(['John Doe']);
2 
3$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
4 
5$concatenated->all();
6 
7// ['John Doe', 'Jane Doe', 'Johnny Doe']

The concat method numerically reindexes keys for items concatenated onto the original collection. To maintain keys in associative collections, see the merge method.

contains()

The contains method determines whether the collection contains a given item. You may pass a closure to the contains method to determine if an element exists in the collection matching a given truth test:

1$collection = collect([1, 2, 3, 4, 5]);
2 
3$collection->contains(function (int $value, int $key) {
4    return $value > 5;
5});
6 
7// false
1$collection = collect([1, 2, 3, 4, 5]);
2 
3$collection->contains(function (int $value, int $key) {
4    return $value > 5;
5});
6 
7// false

Alternatively, you may pass a string to the contains method to determine whether the collection contains a given item value:

1$collection = collect(['name' => 'Desk', 'price' => 100]);
2 
3$collection->contains('Desk');
4 
5// true
6 
7$collection->contains('New York');
8 
9// false
1$collection = collect(['name' => 'Desk', 'price' => 100]);
2 
3$collection->contains('Desk');
4 
5// true
6 
7$collection->contains('New York');
8 
9// false

You may also pass a key / value pair to the contains method, which will determine if the given pair exists in the collection:

1$collection = collect([
2    ['product' => 'Desk', 'price' => 200],
3    ['product' => 'Chair', 'price' => 100],
4]);
5 
6$collection->contains('product', 'Bookcase');
7 
8// false
1$collection = collect([
2    ['product' => 'Desk', 'price' => 200],
3    ['product' => 'Chair', 'price' => 100],
4]);
5 
6$collection->contains('product', 'Bookcase');
7 
8// false

The contains method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value. Use the containsStrict method to filter using "strict" comparisons.

For the inverse of contains, see the doesntContain method.

containsOneItem()

The containsOneItem method determines whether the collection contains a single item:

 1collect([])->containsOneItem();
 2 
 3// false
 4 
 5collect(['1'])->containsOneItem();
 6 
 7// true
 8 
 9collect(['1', '2'])->containsOneItem();
10 
11// false
 1collect([])->containsOneItem();
 2 
 3// false
 4 
 5collect(['1'])->containsOneItem();
 6 
 7// true
 8 
 9collect(['1', '2'])->containsOneItem();
10 
11// false

containsStrict()

This method has the same signature as the contains method; however, all values are compared using "strict" comparisons.

count()

The count method returns the total number of items in the collection:

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

countBy()

The countBy method counts the occurrences of values in the collection. By default, the method counts the occurrences of every element, allowing you to count certain "types" of elements in the collection:

1$collection = collect([1, 2, 2, 2, 3]);
2 
3$counted = $collection->countBy();
4 
5$counted->all();
6 
7// [1 => 1, 2 => 3, 3 => 1]
1$collection = collect([1, 2, 2, 2, 3]);
2 
3$counted = $collection->countBy();
4 
5$counted->all();
6 
7// [1 => 1, 2 => 3, 3 => 1]

You pass a closure to the countBy method to count all items by a custom value:

1$collection = collect(['[email protected]', '[email protected]', '[email protected]']);
2 
3$counted = $collection->countBy(function (string $email) {
4    return substr(strrchr($email, "@"), 1);
5});
6 
7$counted->all();
8 
9// ['gmail.com' => 2, 'yahoo.com' => 1]
1$collection = collect(['[email protected]', '[email protected]', '[email protected]']);
2 
3$counted = $collection->countBy(function (string $email) {
4    return substr(strrchr($email, "@"), 1);
5});
6 
7$counted->all();
8 
9// ['gmail.com' => 2, 'yahoo.com' => 1]

crossJoin()

The crossJoin method cross joins the collection's values among the given arrays or collections, returning a Cartesian product with all possible permutations:

 1$collection = collect([1, 2]);
 2 
 3$matrix = $collection->crossJoin(['a', 'b']);
 4 
 5$matrix->all();
 6 
 7/*
 8    [
 9        [1, 'a'],
10        [1, 'b'],
11        [2, 'a'],
12        [2, 'b'],
13    ]
14*/
15 
16$collection = collect([1, 2]);
17 
18$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);
19 
20$matrix->all();
21 
22/*
23    [
24        [1, 'a', 'I'],
25        [1, 'a', 'II'],
26        [1, 'b', 'I'],
27        [1, 'b', 'II'],
28        [2, 'a', 'I'],
29        [2, 'a', 'II'],
30        [2, 'b', 'I'],
31        [2, 'b', 'II'],
32    ]
33*/
 1$collection = collect([1, 2]);
 2 
 3$matrix = $collection->crossJoin(['a', 'b']);
 4 
 5$matrix->all();
 6 
 7/*
 8    [
 9        [1, 'a'],
10        [1, 'b'],
11        [2, 'a'],
12        [2, 'b'],
13    ]
14*/
15 
16$collection = collect([1, 2]);
17 
18$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);
19 
20$matrix->all();
21 
22/*
23    [
24        [1, 'a', 'I'],
25        [1, 'a', 'II'],
26        [1, 'b', 'I'],
27        [1, 'b', 'II'],
28        [2, 'a', 'I'],
29        [2, 'a', 'II'],
30        [2, 'b', 'I'],
31        [2, 'b', 'II'],
32    ]
33*/

dd()

The dd method dumps the collection's items and ends execution of the script:

 1$collection = collect(['John Doe', 'Jane Doe']);
 2 
 3$collection->dd();
 4 
 5/*
 6    Collection {
 7        #items: array:2 [
 8            0 => "John Doe"
 9            1 => "Jane Doe"
10        ]
11    }
12*/
 1$collection = collect(['John Doe', 'Jane Doe']);
 2 
 3$collection->dd();
 4 
 5/*
 6    Collection {
 7        #items: array:2 [
 8            0 => "John Doe"
 9            1 => "Jane Doe"
10        ]
11    }
12*/

If you do not want to stop executing the script, use the dump method instead.

diff()

The diff method compares the collection against another collection or a plain PHP array based on its values. This method will return the values in the original collection that are not present in the given collection:

1$collection = collect([1, 2, 3, 4, 5]);
2 
3$diff = $collection->diff([2, 4, 6, 8]);
4 
5$diff->all();
6 
7// [1, 3, 5]
1$collection = collect([1, 2, 3, 4, 5]);
2 
3$diff = $collection->diff([2, 4, 6, 8]);
4 
5$diff->all();
6 
7// [1, 3, 5]

diffAssoc()

The diffAssoc method compares the collection against another collection or a plain PHP array based on its keys and values. This method will return the key / value pairs in the original collection that are not present in the given collection:

 1$collection = collect([
 2    'color' => 'orange',
 3    'type' => 'fruit',
 4    'remain' => 6,
 5]);
 6 
 7$diff = $collection->diffAssoc([
 8    'color' => 'yellow',
 9    'type' => 'fruit',
10    'remain' => 3,
11    'used' => 6,
12]);
13 
14$diff->all();
15 
16// ['color' => 'orange', 'remain' => 6]
 1$collection = collect([
 2    'color' => 'orange',
 3    'type' => 'fruit',
 4    'remain' => 6,
 5]);
 6 
 7$diff = $collection->diffAssoc([
 8    'color' => 'yellow',
 9    'type' => 'fruit',
10    'remain' => 3,
11    'used' => 6,
12]);
13 
14$diff->all();
15 
16// ['color' => 'orange', 'remain' => 6]

diffAssocUsing()

Unlike diffAssoc, diffAssocUsing accepts a user supplied callback function for the indices comparison:

 1$collection = collect([
 2    'color' => 'orange',
 3    'type' => 'fruit',
 4    'remain' => 6,
 5]);
 6 
 7$diff = $collection->diffAssocUsing([
 8    'Color' => 'yellow',
 9    'Type' => 'fruit',
10    'Remain' => 3,
11], 'strnatcasecmp');
12 
13$diff->all();
14 
15// ['color' => 'orange', 'remain' => 6]
 1$collection = collect([
 2    'color' => 'orange',
 3    'type' => 'fruit',
 4    'remain' => 6,
 5]);
 6 
 7$diff = $collection->diffAssocUsing([
 8    'Color' => 'yellow',
 9    'Type' => 'fruit',
10    'Remain' => 3,
11], 'strnatcasecmp');
12 
13$diff->all();
14 
15// ['color' => 'orange', 'remain' => 6]

The callback must be a comparison function that returns an integer less than, equal to, or greater than zero. For more information, refer to the PHP documentation on array_diff_uassoc, which is the PHP function that the diffAssocUsing method utilizes internally.

diffKeys()

The diffKeys method compares the collection against another collection or a plain PHP array based on its keys. This method will return the key / value pairs in the original collection that are not present in the given collection:

 1$collection = collect([
 2    'one' => 10,
 3    'two' => 20,
 4    'three' => 30,
 5    'four' => 40,
 6    'five' => 50,
 7]);
 8 
 9$diff = $collection->diffKeys([
10    'two' => 2,
11    'four' => 4,
12    'six' => 6,
13    'eight' => 8,
14]);
15 
16$diff->all();
17 
18// ['one' => 10, 'three' => 30, 'five' => 50]
 1$collection = collect([
 2    'one' => 10,
 3    'two' => 20,
 4    'three' => 30,
 5    'four' => 40,
 6    'five' => 50,
 7]);
 8 
 9$diff = $collection->diffKeys([
10    'two' => 2,
11    'four' => 4,
12    'six' => 6,
13    'eight' => 8,
14]);
15 
16$diff->all();
17 
18// ['one' => 10, 'three' => 30, 'five' => 50]

doesntContain()

The doesntContain method determines whether the collection does not contain a given item. You may pass a closure to the doesntContain method to determine if an element does not exist in the collection matching a given truth test:

1$collection = collect([1, 2, 3, 4, 5]);
2 
3$collection->doesntContain(function (int $value, int $key) {
4    return $value < 5;
5});
6 
7// false
1$collection = collect([1, 2, 3, 4, 5]);
2 
3$collection->doesntContain(function (int $value, int $key) {
4    return $value < 5;
5});
6 
7// false

Alternatively, you may pass a string to the doesntContain method to determine whether the collection does not contain a given item value:

1$collection = collect(['name' => 'Desk', 'price' => 100]);
2 
3$collection->doesntContain('Table');
4 
5// true
6 
7$collection->doesntContain('Desk');
8 
9// false
1$collection = collect(['name' => 'Desk', 'price' => 100]);
2 
3$collection->doesntContain('Table');
4 
5// true
6 
7$collection->doesntContain('Desk');
8 
9// false

You may also pass a key / value pair to the doesntContain method, which will determine if the given pair does not exist in the collection:

1$collection = collect([
2    ['product' => 'Desk', 'price' => 200],
3    ['product' => 'Chair', 'price' => 100],
4]);
5 
6$collection->doesntContain('product', 'Bookcase');
7 
8// true
1$collection = collect([
2    ['product' => 'Desk', 'price' => 200],
3    ['product' => 'Chair', 'price' => 100],
4]);
5 
6$collection->doesntContain('product', 'Bookcase');
7 
8// true

The doesntContain method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value.

dot()

The dot method flattens a multi-dimensional collection into a single level collection that uses "dot" notation to indicate depth:

1$collection = collect(['products' => ['desk' => ['price' => 100]]]);
2 
3$flattened = $collection->dot();
4 
5$flattened->all();
6 
7// ['products.desk.price' => 100]
1$collection = collect(['products' => ['desk' => ['price' => 100]]]);
2 
3$flattened = $collection->dot();
4 
5$flattened->all();
6 
7// ['products.desk.price' => 100]

dump()

The dump method dumps the collection's items:

 1$collection = collect(['John Doe', 'Jane Doe']);
 2 
 3$collection->dump();
 4 
 5/*
 6    Collection {
 7        #items: array:2 [
 8            0 => "John Doe"
 9            1 => "Jane Doe"
10        ]
11    }
12*/
 1$collection = collect(['John Doe', 'Jane Doe']);
 2 
 3$collection->dump();
 4 
 5/*
 6    Collection {
 7        #items: array:2 [
 8            0 => "John Doe"
 9            1 => "Jane Doe"
10        ]
11    }
12*/

If you want to stop executing the script after dumping the collection, use the dd method instead.

duplicates()

The duplicates method retrieves and returns duplicate values from the collection:

1$collection = collect(['a', 'b', 'a', 'c', 'b']);
2 
3$collection->duplicates();
4 
5// [2 => 'a', 4 => 'b']
1$collection = collect(['a', 'b', 'a', 'c', 'b']);
2 
3$collection->duplicates();
4 
5// [2 => 'a', 4 => 'b']

If the collection contains arrays or objects, you can pass the key of the attributes that you wish to check for duplicate values:

1$employees = collect([
2    ['email' => '[email protected]', 'position' => 'Developer'],
3    ['email' => '[email protected]', 'position' => 'Designer'],
4    ['email' => '[email protected]', 'position' => 'Developer'],
5]);
6 
7$employees->duplicates('position');
8 
9// [2 => 'Developer']
1$employees = collect([
2    ['email' => '[email protected]', 'position' => 'Developer'],
3    ['email' => '[email protected]', 'position' => 'Designer'],
4    ['email' => '[email protected]', 'position' => 'Developer'],
5]);
6 
7$employees->duplicates('position');
8 
9// [2 => 'Developer']

duplicatesStrict()

This method has the same signature as the duplicates method; however, all values are compared using "strict" comparisons.

each()

The each method iterates over the items in the collection and passes each item to a closure:

1$collection = collect([1, 2, 3, 4]);
2 
3$collection->each(function (int $item, int $key) {
4    // ...
5});
1$collection = collect([1, 2, 3, 4]);
2 
3$collection->each(function (int $item, int $key) {
4    // ...
5});

If you would like to stop iterating through the items, you may return false from your closure:

1$collection->each(function (int $item, int $key) {
2    if (/* condition */) {
3        return false;
4    }
5});
1$collection->each(function (int $item, int $key) {
2    if (/* condition */) {
3        return false;
4    }
5});

eachSpread()

The eachSpread method iterates over the collection's items, passing each nested item value into the given callback:

1$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
2 
3$collection->eachSpread(function (string $name, int $age) {
4    // ...
5});
1$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
2 
3$collection->eachSpread(function (string $name, int $age) {
4    // ...
5});

You may stop iterating through the items by returning false from the callback:

1$collection->eachSpread(function (string $name, int $age) {
2    return false;
3});
1$collection->eachSpread(function (string $name, int $age) {
2    return false;
3});

ensure()

The ensure method may be used to verify that all elements of a collection are of a given type or list of types. Otherwise, an UnexpectedValueException will be thrown:

1return $collection->ensure(User::class);
2 
3return $collection->ensure([User::class, Customer::class]);
1return $collection->ensure(User::class);
2 
3return $collection->ensure([User::class, Customer::class]);

Primitive types such as string, int, float, bool, and array may also be specified:

1return $collection->ensure('int');
1return $collection->ensure('int');

every()

The every method may be used to verify that all elements of a collection pass a given truth test:

1collect([1, 2, 3, 4])->every(function (int $value, int $key) {
2    return $value > 2;
3});
4 
5// false
1collect([1, 2, 3, 4])->every(function (int $value, int $key) {
2    return $value > 2;
3});
4 
5// false

If the collection is empty, the every method will return true:

1$collection = collect([]);
2 
3$collection->every(function (int $value, int $key) {
4    return $value > 2;
5});
6 
7// true
1$collection = collect([]);
2 
3$collection->every(function (int $value, int $key) {
4    return $value > 2;
5});
6 
7// true

except()

The except method returns all items in the collection except for those with the specified keys:

1$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
2 
3$filtered = $collection->except(['price', 'discount']);
4 
5$filtered->all();
6 
7// ['product_id' => 1]
1$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
2 
3$filtered = $collection->except(['price', 'discount']);
4 
5$filtered->all();
6 
7// ['product_id' => 1]

For the inverse of except, see the only method.

filter()

The filter method filters the collection using the given callback, keeping only those items that pass a given truth test:

1$collection = collect([1, 2, 3, 4]);
2 
3$filtered = $collection->filter(function (int $value, int $key) {
4    return $value > 2;
5});
6 
7$filtered->all();
8 
9// [3, 4]
1$collection = collect([1, 2, 3, 4]);
2 
3$filtered = $collection->filter(function (int $value, int $key) {
4    return $value > 2;
5});
6 
7$filtered->all();
8 
9// [3, 4]

If no callback is supplied, all entries of the collection that are equivalent to false will be removed:

1$collection = collect([1, 2, 3, null, false, '', 0, []]);
2 
3$collection->filter()->all();
4 
5// [1, 2, 3]
1$collection = collect([1, 2, 3, null, false, '', 0, []]);
2 
3$collection->filter()->all();
4 
5// [1, 2, 3]

For the inverse of filter, see the reject method.

first()

The first method returns the first element in the collection that passes a given truth test:

1collect([1, 2, 3, 4])->first(function (int $value, int $key) {
2    return $value > 2;
3});
4 
5// 3
1collect([1, 2, 3, 4])->first(function (int $value, int $key) {
2    return $value > 2;
3});
4 
5// 3

You may also call the first method with no arguments to get the first element in the collection. If the collection is empty, null is returned:

1collect([1, 2, 3, 4])->first();
2 
3// 1
1collect([1, 2, 3, 4])->first();
2 
3// 1

firstOrFail()

The firstOrFail method is identical to the first method; however, if no result is found, an Illuminate\Support\ItemNotFoundException exception will be thrown:

1collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) {
2    return $value > 5;
3});
4 
5// Throws ItemNotFoundException...
1collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) {
2    return $value > 5;
3});
4 
5// Throws ItemNotFoundException...

You may also call the firstOrFail method with no arguments to get the first element in the collection. If the collection is empty, an Illuminate\Support\ItemNotFoundException exception will be thrown:

1collect([])->firstOrFail();
2 
3// Throws ItemNotFoundException...
1collect([])->firstOrFail();
2 
3// Throws ItemNotFoundException...

firstWhere()

The firstWhere method returns the first element in the collection with the given key / value pair:

 1$collection = collect([
 2    ['name' => 'Regena', 'age' => null],
 3    ['name' => 'Linda', 'age' => 14],
 4    ['name' => 'Diego', 'age' => 23],
 5    ['name' => 'Linda', 'age' => 84],
 6]);
 7 
 8$collection->firstWhere('name', 'Linda');
 9 
10// ['name' => 'Linda', 'age' => 14]
 1$collection = collect([
 2    ['name' => 'Regena', 'age' => null],
 3    ['name' => 'Linda', 'age' => 14],
 4    ['name' => 'Diego', 'age' => 23],
 5    ['name' => 'Linda', 'age' => 84],
 6]);
 7 
 8$collection->firstWhere('name', 'Linda');
 9 
10// ['name' => 'Linda', 'age' => 14]

You may also call the firstWhere method with a comparison operator:

1$collection->firstWhere('age', '>=', 18);
2 
3// ['name' => 'Diego', 'age' => 23]
1$collection->firstWhere('age', '>=', 18);
2 
3// ['name' => 'Diego', 'age' => 23]

Like the where method, you may pass one argument to the firstWhere method. In this scenario, the firstWhere method will return the first item where the given item key's value is "truthy":

1$collection->firstWhere('age');
2 
3// ['name' => 'Linda', 'age' => 14]
1$collection->firstWhere('age');
2 
3// ['name' => 'Linda', 'age' => 14]

flatMap()

The flatMap method iterates through the collection and passes each value to the given closure. The closure is free to modify the item and return it, thus forming a new collection of modified items. Then, the array is flattened by one level:

 1$collection = collect([
 2    ['name' => 'Sally'],
 3    ['school' => 'Arkansas'],
 4    ['age' => 28]
 5]);
 6 
 7$flattened = $collection->flatMap(function (array $values) {
 8    return array_map('strtoupper', $values);
 9});
10 
11$flattened->all();
12 
13// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];
 1$collection = collect([
 2    ['name' => 'Sally'],
 3    ['school' => 'Arkansas'],
 4    ['age' => 28]
 5]);
 6 
 7$flattened = $collection->flatMap(function (array $values) {
 8    return array_map('strtoupper', $values);
 9});
10 
11$flattened->all();
12 
13// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];

flatten()

The flatten method flattens a multi-dimensional collection into a single dimension:

 1$collection = collect([
 2    'name' => 'taylor',
 3    'languages' => [
 4        'php', 'javascript'
 5    ]
 6]);
 7 
 8$flattened = $collection->flatten();
 9 
10$flattened->all();
11 
12// ['taylor', 'php', 'javascript'];
 1$collection = collect([
 2    'name' => 'taylor',
 3    'languages' => [
 4        'php', 'javascript'
 5    ]
 6]);
 7 
 8$flattened = $collection->flatten();
 9 
10$flattened->all();
11 
12// ['taylor', 'php', 'javascript'];

If necessary, you may pass the flatten method a "depth" argument:

 1$collection = collect([
 2    'Apple' => [
 3        [
 4            'name' => 'iPhone 6S',
 5            'brand' => 'Apple'
 6        ],
 7    ],
 8    'Samsung' => [
 9        [
10            'name' => 'Galaxy S7',
11            'brand' => 'Samsung'
12        ],
13    ],
14]);
15 
16$products = $collection->flatten(1);
17 
18$products->values()->all();
19 
20/*
21    [
22        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
23        ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
24    ]
25*/
 1$collection = collect([
 2    'Apple' => [
 3        [
 4            'name' => 'iPhone 6S',
 5            'brand' => 'Apple'
 6        ],
 7    ],
 8    'Samsung' => [
 9        [
10            'name' => 'Galaxy S7',
11            'brand' => 'Samsung'
12        ],
13    ],
14]);
15 
16$products = $collection->flatten(1);
17 
18$products->values()->all();
19 
20/*
21    [
22        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
23        ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
24    ]
25*/

In this example, calling flatten without providing the depth would have also flattened the nested arrays, resulting in ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']. Providing a depth allows you to specify the number of levels nested arrays will be flattened.

flip()

The flip method swaps the collection's keys with their corresponding values:

1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
2 
3$flipped = $collection->flip();
4 
5$flipped->all();
6 
7// ['taylor' => 'name', 'laravel' => 'framework']
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
2 
3$flipped = $collection->flip();
4 
5$flipped->all();
6 
7// ['taylor' => 'name', 'laravel' => 'framework']

forget()

The forget method removes an item from the collection by its key:

 1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
 2 
 3// Forget a single key...
 4$collection->forget('name');
 5 
 6// ['framework' => 'laravel']
 7 
 8// Forget multiple keys...
 9$collection->forget(['name', 'framework']);
10 
11// []
 1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
 2 
 3// Forget a single key...
 4$collection->forget('name');
 5 
 6// ['framework' => 'laravel']
 7 
 8// Forget multiple keys...
 9$collection->forget(['name', 'framework']);
10 
11// []

forPage()

The forPage method returns a new collection containing the items that would be present on a given page number. The method accepts the page number as its first argument and the number of items to show per page as its second argument:

1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
2 
3$chunk = $collection->forPage(2, 3);
4 
5$chunk->all();
6 
7// [4, 5, 6]
1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
2 
3$chunk = $collection->forPage(2, 3);
4 
5$chunk->all();
6 
7// [4, 5, 6]

get()

The get method returns the item at a given key. If the key does not exist, null is returned:

1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
2 
3$value = $collection->get('name');
4 
5// taylor
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
2 
3$value = $collection->get('name');
4 
5// taylor

You may optionally pass a default value as the second argument:

1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
2 
3$value = $collection->get('age', 34);
4 
5// 34
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
2 
3$value = $collection->get('age', 34);
4 
5// 34

You may even pass a callback as the method's default value. The result of the callback will be returned if the specified key does not exist:

1$collection->get('email', function () {
2    return '[email protected]';
3});
4 
5// [email protected]
1$collection->get('email', function () {
2    return '[email protected]';
3});
4 
5// [email protected]

groupBy()

The groupBy method groups the collection's items by a given key:

 1$collection = collect([
 2    ['account_id' => 'account-x10', 'product' => 'Chair'],
 3    ['account_id' => 'account-x10', 'product' => 'Bookcase'],
 4    ['account_id' => 'account-x11', 'product' => 'Desk'],
 5]);
 6 
 7$grouped = $collection->groupBy('account_id');
 8 
 9$grouped->all();
10 
11/*
12    [
13        'account-x10' => [
14            ['account_id' => 'account-x10', 'product' => 'Chair'],
15            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
16        ],
17        'account-x11' => [
18            ['account_id' => 'account-x11', 'product' => 'Desk'],
19        ],
20    ]
21*/
 1$collection = collect([
 2    ['account_id' => 'account-x10', 'product' => 'Chair'],
 3    ['account_id' => 'account-x10', 'product' => 'Bookcase'],
 4    ['account_id' => 'account-x11', 'product' => 'Desk'],
 5]);
 6 
 7$grouped = $collection->groupBy('account_id');
 8 
 9$grouped->all();
10 
11/*
12    [
13        'account-x10' => [
14            ['account_id' => 'account-x10', 'product' => 'Chair'],
15            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
16        ],
17        'account-x11' => [
18            ['account_id' => 'account-x11', 'product' => 'Desk'],
19        ],
20    ]
21*/

Instead of passing a string key, you may pass a callback. The callback should return the value you wish to key the group by:

 1$grouped = $collection->groupBy(function (array $item, int $key) {
 2    return substr($item['account_id'], -3);
 3});
 4 
 5$grouped->all();
 6 
 7/*
 8    [
 9        'x10' => [
10            ['account_id' => 'account-x10', 'product' => 'Chair'],
11            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
12        ],
13        'x11' => [
14            ['account_id' => 'account-x11', 'product' => 'Desk'],
15        ],
16    ]
17*/
 1$grouped = $collection->groupBy(function (array $item, int $key) {
 2    return substr($item['account_id'], -3);
 3});
 4 
 5$grouped->all();
 6 
 7/*
 8    [
 9        'x10' => [
10            ['account_id' => 'account-x10', 'product' => 'Chair'],
11            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
12        ],
13        'x11' => [
14            ['account_id' => 'account-x11', 'product' => 'Desk'],
15        ],
16    ]
17*/

Multiple grouping criteria may be passed as an array. Each array element will be applied to the corresponding level within a multi-dimensional array:

 1$data = new Collection([
 2    10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
 3    20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
 4    30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
 5    40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
 6]);
 7 
 8$result = $data->groupBy(['skill', function (array $item) {
 9    return $item['roles'];
10}], preserveKeys: true);
11 
12/*
13[
14    1 => [
15        'Role_1' => [
16            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
17            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
18        ],
19        'Role_2' => [
20            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
21        ],
22        'Role_3' => [
23            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
24        ],
25    ],
26    2 => [
27        'Role_1' => [
28            30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
29        ],
30        'Role_2' => [
31            40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
32        ],
33    ],
34];
35*/
 1$data = new Collection([
 2    10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
 3    20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
 4    30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
 5    40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
 6]);
 7 
 8$result = $data->groupBy(['skill', function (array $item) {
 9    return $item['roles'];
10}], preserveKeys: true);
11 
12/*
13[
14    1 => [
15        'Role_1' => [
16            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
17            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
18        ],
19        'Role_2' => [
20            20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
21        ],
22        'Role_3' => [
23            10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
24        ],
25    ],
26    2 => [
27        'Role_1' => [
28            30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
29        ],
30        'Role_2' => [
31            40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
32        ],
33    ],
34];
35*/