Collections
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 ($name) {2 return strtoupper($name);3})->reject(function ($name) {4 return empty($name);5});
1$collection = collect(['taylor', 'abigail', null])->map(function ($name) {2 return strtoupper($name);3})->reject(function ($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]);
The results of Eloquent queries are always returned as Collection
instances.
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;34Collection::macro('toUpper', function () {5 return $this->map(function ($value) {6 return Str::upper($value);7 });8});910$collection = collect(['first', 'second']);1112$upper = $collection->toUpper();1314// ['FIRST', 'SECOND']
1use Illuminate\Support\Collection;2use Illuminate\Support\Str;34Collection::macro('toUpper', function () {5 return $this->map(function ($value) {6 return Str::upper($value);7 });8});910$collection = collect(['first', 'second']);1112$upper = $collection->toUpper();1314// ['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;34Collection::macro('toLocale', function ($locale) {5 return $this->map(function ($value) use ($locale) {6 return Lang::get($value, [], $locale);7 });8});910$collection = collect(['first', 'second']);1112$translated = $collection->toLocale('es');
1use Illuminate\Support\Collection;2use Illuminate\Support\Facades\Lang;34Collection::macro('toLocale', function ($locale) {5 return $this->map(function ($value) use ($locale) {6 return Lang::get($value, [], $locale);7 });8});910$collection = collect(['first', 'second']);1112$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:
all average avg chunk chunkWhile collapse collect combine concat contains containsOneItem containsStrict count countBy crossJoin dd diff diffAssoc diffKeys doesntContain dump duplicates duplicatesStrict each eachSpread every except filter first firstOrFail firstWhere flatMap flatten flip forget forPage get groupBy has hasAny implode intersect intersectByKeys isEmpty isNotEmpty join keyBy keys last lazy macro make map mapInto mapSpread mapToGroups mapWithKeys max median merge mergeRecursive min mode nth only pad partition pipe pipeInto pipeThrough pluck pop prepend pull push put random range reduce reduceSpread reject replace replaceRecursive reverse search shift shuffle skip skipUntil skipWhile slice sliding sole some sort sortBy sortByDesc sortDesc sortKeys sortKeysDesc sortKeysUsing splice split splitIn sum take takeUntil takeWhile tap times toArray toJson transform undot union unique uniqueStrict unless unlessEmpty unlessNotEmpty unwrap value values when whenEmpty whenNotEmpty where whereStrict whereBetween whereIn whereInStrict whereInstanceOf whereNotBetween whereNotIn whereNotInStrict whereNotNull whereNull wrap zip
Method Listing
all()
The all
method returns the underlying array represented by the collection:
1collect([1, 2, 3])->all();23// [1, 2, 3]
1collect([1, 2, 3])->all();23// [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');78// 20910$average = collect([1, 1, 2, 4])->avg();1112// 2
1$average = collect([2 ['foo' => 10],3 ['foo' => 10],4 ['foo' => 20],5 ['foo' => 40]6])->avg('foo');78// 20910$average = collect([1, 1, 2, 4])->avg();1112// 2
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]);23$chunks = $collection->chunk(4);45$chunks->all();67// [[1, 2, 3, 4], [5, 6, 7]]
1$collection = collect([1, 2, 3, 4, 5, 6, 7]);23$chunks = $collection->chunk(4);45$chunks->all();67// [[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 @endforeach6 </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 @endforeach6 </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'));23$chunks = $collection->chunkWhile(function ($value, $key, $chunk) {4 return $value === $chunk->last();5});67$chunks->all();89// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]
1$collection = collect(str_split('AABBCCCD'));23$chunks = $collection->chunkWhile(function ($value, $key, $chunk) {4 return $value === $chunk->last();5});67$chunks->all();89// [['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]);67$collapsed = $collection->collapse();89$collapsed->all();1011// [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]);67$collapsed = $collection->collapse();89$collapsed->all();1011// [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]);23$collectionB = $collectionA->collect();45$collectionB->all();67// [1, 2, 3]
1$collectionA = collect([1, 2, 3]);23$collectionB = $collectionA->collect();45$collectionB->all();67// [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});67$collection = $lazyCollection->collect();89get_class($collection);1011// 'Illuminate\Support\Collection'1213$collection->all();1415// [1, 2, 3]
1$lazyCollection = LazyCollection::make(function () {2 yield 1;3 yield 2;4 yield 3;5});67$collection = $lazyCollection->collect();89get_class($collection);1011// 'Illuminate\Support\Collection'1213$collection->all();1415// [1, 2, 3]
The collect
method is especially useful when you have an instance of Enumerable
and need a non-lazy collection instance. Since collect()
is part of the Enumerable
contract, you can safely use it to get a Collection
instance.
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']);23$combined = $collection->combine(['George', 29]);45$combined->all();67// ['name' => 'George', 'age' => 29]
1$collection = collect(['name', 'age']);23$combined = $collection->combine(['George', 29]);45$combined->all();67// ['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']);23$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);45$concatenated->all();67// ['John Doe', 'Jane Doe', 'Johnny Doe']
1$collection = collect(['John Doe']);23$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);45$concatenated->all();67// ['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]);23$collection->contains(function ($value, $key) {4 return $value > 5;5});67// false
1$collection = collect([1, 2, 3, 4, 5]);23$collection->contains(function ($value, $key) {4 return $value > 5;5});67// 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]);23$collection->contains('Desk');45// true67$collection->contains('New York');89// false
1$collection = collect(['name' => 'Desk', 'price' => 100]);23$collection->contains('Desk');45// true67$collection->contains('New York');89// 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]);56$collection->contains('product', 'Bookcase');78// false
1$collection = collect([2 ['product' => 'Desk', 'price' => 200],3 ['product' => 'Chair', 'price' => 100],4]);56$collection->contains('product', 'Bookcase');78// 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();23// false45collect(['1'])->containsOneItem();67// true89collect(['1', '2'])->containsOneItem();1011// false
1collect([])->containsOneItem();23// false45collect(['1'])->containsOneItem();67// true89collect(['1', '2'])->containsOneItem();1011// false
containsStrict()
This method has the same signature as the contains
method; however, all values are compared using "strict" comparisons.
This method's behavior is modified when using Eloquent Collections.
count()
The count
method returns the total number of items in the collection:
1$collection = collect([1, 2, 3, 4]);23$collection->count();45// 4
1$collection = collect([1, 2, 3, 4]);23$collection->count();45// 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]);23$counted = $collection->countBy();45$counted->all();67// [1 => 1, 2 => 3, 3 => 1]
1$collection = collect([1, 2, 2, 2, 3]);23$counted = $collection->countBy();45$counted->all();67// [1 => 1, 2 => 3, 3 => 1]
You pass a closure to the countBy
method to count all items by a custom value:
23$counted = $collection->countBy(function ($email) {4 return substr(strrchr($email, "@"), 1);5});67$counted->all();89// ['gmail.com' => 2, 'yahoo.com' => 1]
23$counted = $collection->countBy(function ($email) {4 return substr(strrchr($email, "@"), 1);5});67$counted->all();89// ['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]);23$matrix = $collection->crossJoin(['a', 'b']);45$matrix->all();67/*8 [9 [1, 'a'],10 [1, 'b'],11 [2, 'a'],12 [2, 'b'],13 ]14*/1516$collection = collect([1, 2]);1718$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);1920$matrix->all();2122/*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]);23$matrix = $collection->crossJoin(['a', 'b']);45$matrix->all();67/*8 [9 [1, 'a'],10 [1, 'b'],11 [2, 'a'],12 [2, 'b'],13 ]14*/1516$collection = collect([1, 2]);1718$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);1920$matrix->all();2122/*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']);23$collection->dd();45/*6 Collection {7 #items: array:2 [8 0 => "John Doe"9 1 => "Jane Doe"10 ]11 }12*/
1$collection = collect(['John Doe', 'Jane Doe']);23$collection->dd();45/*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]);23$diff = $collection->diff([2, 4, 6, 8]);45$diff->all();67// [1, 3, 5]
1$collection = collect([1, 2, 3, 4, 5]);23$diff = $collection->diff([2, 4, 6, 8]);45$diff->all();67// [1, 3, 5]
This method's behavior is modified when using Eloquent Collections.
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]);67$diff = $collection->diffAssoc([8 'color' => 'yellow',9 'type' => 'fruit',10 'remain' => 3,11 'used' => 6,12]);1314$diff->all();1516// ['color' => 'orange', 'remain' => 6]
1$collection = collect([2 'color' => 'orange',3 'type' => 'fruit',4 'remain' => 6,5]);67$diff = $collection->diffAssoc([8 'color' => 'yellow',9 'type' => 'fruit',10 'remain' => 3,11 'used' => 6,12]);1314$diff->all();1516// ['color' => 'orange', 'remain' => 6]
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]);89$diff = $collection->diffKeys([10 'two' => 2,11 'four' => 4,12 'six' => 6,13 'eight' => 8,14]);1516$diff->all();1718// ['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]);89$diff = $collection->diffKeys([10 'two' => 2,11 'four' => 4,12 'six' => 6,13 'eight' => 8,14]);1516$diff->all();1718// ['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]);23$collection->doesntContain(function ($value, $key) {4 return $value < 5;5});67// false
1$collection = collect([1, 2, 3, 4, 5]);23$collection->doesntContain(function ($value, $key) {4 return $value < 5;5});67// 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]);23$collection->doesntContain('Table');45// true67$collection->doesntContain('Desk');89// false
1$collection = collect(['name' => 'Desk', 'price' => 100]);23$collection->doesntContain('Table');45// true67$collection->doesntContain('Desk');89// 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]);56$collection->doesntContain('product', 'Bookcase');78// true
1$collection = collect([2 ['product' => 'Desk', 'price' => 200],3 ['product' => 'Chair', 'price' => 100],4]);56$collection->doesntContain('product', 'Bookcase');78// 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.
dump()
The dump
method dumps the collection's items:
1$collection = collect(['John Doe', 'Jane Doe']);23$collection->dump();45/*6 Collection {7 #items: array:2 [8 0 => "John Doe"9 1 => "Jane Doe"10 ]11 }12*/
1$collection = collect(['John Doe', 'Jane Doe']);23$collection->dump();45/*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']);23$collection->duplicates();45// [2 => 'a', 4 => 'b']
1$collection = collect(['a', 'b', 'a', 'c', 'b']);23$collection->duplicates();45// [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([5]);67$employees->duplicates('position');89// [2 => 'Developer']
1$employees = collect([5]);67$employees->duplicates('position');89// [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->each(function ($item, $key) {2 //3});
1$collection->each(function ($item, $key) {2 //3});
If you would like to stop iterating through the items, you may return false
from your closure:
1$collection->each(function ($item, $key) {2 if (/* condition */) {3 return false;4 }5});
1$collection->each(function ($item, $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]]);23$collection->eachSpread(function ($name, $age) {4 //5});
1$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);23$collection->eachSpread(function ($name, $age) {4 //5});
You may stop iterating through the items by returning false
from the callback:
1$collection->eachSpread(function ($name, $age) {2 return false;3});
1$collection->eachSpread(function ($name, $age) {2 return false;3});
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 ($value, $key) {2 return $value > 2;3});45// false
1collect([1, 2, 3, 4])->every(function ($value, $key) {2 return $value > 2;3});45// false
If the collection is empty, the every
method will return true:
1$collection = collect([]);23$collection->every(function ($value, $key) {4 return $value > 2;5});67// true
1$collection = collect([]);23$collection->every(function ($value, $key) {4 return $value > 2;5});67// 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]);23$filtered = $collection->except(['price', 'discount']);45$filtered->all();67// ['product_id' => 1]
1$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);23$filtered = $collection->except(['price', 'discount']);45$filtered->all();67// ['product_id' => 1]
For the inverse of except
, see the only method.
This method's behavior is modified when using Eloquent Collections.
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]);23$filtered = $collection->filter(function ($value, $key) {4 return $value > 2;5});67$filtered->all();89// [3, 4]
1$collection = collect([1, 2, 3, 4]);23$filtered = $collection->filter(function ($value, $key) {4 return $value > 2;5});67$filtered->all();89// [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, []]);23$collection->filter()->all();45// [1, 2, 3]
1$collection = collect([1, 2, 3, null, false, '', 0, []]);23$collection->filter()->all();45// [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 ($value, $key) {2 return $value > 2;3});45// 3
1collect([1, 2, 3, 4])->first(function ($value, $key) {2 return $value > 2;3});45// 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();23// 1
1collect([1, 2, 3, 4])->first();23// 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 ($value, $key) {2 return $value > 5;3});45// Throws ItemNotFoundException...
1collect([1, 2, 3, 4])->firstOrFail(function ($value, $key) {2 return $value > 5;3});45// 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();23// Throws ItemNotFoundException...
1collect([])->firstOrFail();23// 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]);78$collection->firstWhere('name', 'Linda');910// ['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]);78$collection->firstWhere('name', 'Linda');910// ['name' => 'Linda', 'age' => 14]
You may also call the firstWhere
method with a comparison operator:
1$collection->firstWhere('age', '>=', 18);23// ['name' => 'Diego', 'age' => 23]
1$collection->firstWhere('age', '>=', 18);23// ['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');23// ['name' => 'Linda', 'age' => 14]
1$collection->firstWhere('age');23// ['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]);67$flattened = $collection->flatMap(function ($values) {8 return array_map('strtoupper', $values);9});1011$flattened->all();1213// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];
1$collection = collect([2 ['name' => 'Sally'],3 ['school' => 'Arkansas'],4 ['age' => 28]5]);67$flattened = $collection->flatMap(function ($values) {8 return array_map('strtoupper', $values);9});1011$flattened->all();1213// ['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]);78$flattened = $collection->flatten();910$flattened->all();1112// ['taylor', 'php', 'javascript'];
1$collection = collect([2 'name' => 'taylor',3 'languages' => [4 'php', 'javascript'5 ]6]);78$flattened = $collection->flatten();910$flattened->all();1112// ['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]);1516$products = $collection->flatten(1);1718$products->values()->all();1920/*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]);1516$products = $collection->flatten(1);1718$products->values()->all();1920/*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']);23$flipped = $collection->flip();45$flipped->all();67// ['taylor' => 'name', 'laravel' => 'framework']
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);23$flipped = $collection->flip();45$flipped->all();67// ['taylor' => 'name', 'laravel' => 'framework']
forget()
The forget
method removes an item from the collection by its key:
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);23$collection->forget('name');45$collection->all();67// ['framework' => 'laravel']
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);23$collection->forget('name');45$collection->all();67// ['framework' => 'laravel']
Unlike most other collection methods, forget
does not return a new modified collection; it modifies the collection it is called on.
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]);23$chunk = $collection->forPage(2, 3);45$chunk->all();67// [4, 5, 6]
1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);23$chunk = $collection->forPage(2, 3);45$chunk->all();67// [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']);23$value = $collection->get('name');45// taylor
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);23$value = $collection->get('name');45// taylor
You may optionally pass a default value as the second argument:
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);23$value = $collection->get('age', 34);45// 34
1$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);23$value = $collection->get('age', 34);45// 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 () {3});4
1$collection->get('email', function () {3});4
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]);67$grouped = $collection->groupBy('account_id');89$grouped->all();1011/*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]);67$grouped = $collection->groupBy('account_id');89$grouped->all();1011/*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 ($item, $key) {2 return substr($item['account_id'], -3);3});45$grouped->all();67/*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 ($item, $key) {2 return substr($item['account_id'], -3);3});45$grouped->all();67/*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]);78$result = $data->groupBy(['skill', function ($item) {9 return $item['roles'];10}], preserveKeys: true);1112/*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]);78$result = $data->groupBy(['skill', function ($item) {9 return $item['roles'];10}], preserveKeys: true);1112/*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*/
has()
The has
method determines if a given key exists in the collection:
1$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);23$collection->has('product');45// true67$collection->has(['product', 'amount']);89// true1011$collection->has(['amount', 'price']);1213// false
1$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);23$collection->has('product');45// true67$collection->has(['product', 'amount']);89// true1011$collection->has(['amount', 'price']);1213// false
hasAny()
The hasAny
method determines whether any of the given keys exist in the collection:
1$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);23$collection->hasAny(['product', 'price']);45// true67$collection->hasAny(['name', 'price']);89// false
1$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);23$collection->hasAny(['product', 'price']);45// true67$collection->hasAny(['name', 'price']);89// false
implode()
The implode
method joins items in a collection. Its arguments depend on the type of items in the collection. If the collection contains arrays or objects, you should pass the key of the attributes you wish to join, and the "glue" string you wish to place between the values:
1$collection = collect([2 ['account_id' => 1, 'product' => 'Desk'],3 ['account_id' => 2, 'product' => 'Chair'],4]);56$collection->implode('product', ', ');78// Desk, Chair
1$collection = collect([2 ['account_id' => 1, 'product' => 'Desk'],3 ['account_id' => 2, 'product' => 'Chair'],4]);56$collection->implode('product', ', ');78// Desk, Chair
If the collection contains simple strings or numeric values, you should pass the "glue" as the only argument to the method:
1collect([1, 2, 3, 4, 5])->implode('-');23// '1-2-3-4-5'
1collect([1, 2, 3, 4, 5])->implode('-');23// '1-2-3-4-5'
You may pass a closure to the implode
method if you would like to format the values being imploded:
1$collection->implode(function ($item, $key) {2 return strtoupper($item['product']);3}, ', ');45// DESK, CHAIR
1$collection->implode(function ($item, $key) {2 return strtoupper($item['product']);3}, ', ');45// DESK, CHAIR
intersect()
The intersect
method removes any values from the original collection that are not present in the given array
or collection. The resulting collection will preserve the original collection's keys:
1$collection = collect(['Desk', 'Sofa', 'Chair']);23$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);45$intersect->all();67// [0 => 'Desk', 2 => 'Chair']
1$collection = collect(['Desk', 'Sofa', 'Chair']);23$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);45$intersect->all();67// [0 => 'Desk', 2 => 'Chair']
This method's behavior is modified when using Eloquent Collections.
intersectByKeys()
The intersectByKeys
method removes any keys and their corresponding values from the original collection that are not present in the given array
or collection:
1$collection = collect([2 'serial' => 'UX301', 'type' => 'screen', 'year' => 2009,3]);45$intersect = $collection->intersectByKeys([6 'reference' => 'UX404', 'type' => 'tab', 'year' => 2011,7]);89$intersect->all();1011// ['type' => 'screen', 'year' => 2009]
1$collection = collect([2 'serial' => 'UX301', 'type' => 'screen', 'year' => 2009,3]);45$intersect = $collection->intersectByKeys([6 'reference' => 'UX404', 'type' => 'tab', 'year' => 2011,7]);89$intersect->all();1011// ['type' => 'screen', 'year' => 2009]
isEmpty()
The isEmpty
method returns true
if the collection is empty; otherwise, false
is returned:
1collect([])->isEmpty();23// true
1collect([])->isEmpty();23// true
isNotEmpty()
The isNotEmpty
method returns true
if the collection is not empty; otherwise, false
is returned:
1collect([])->isNotEmpty();23// false
1collect([])->isNotEmpty();23// false
join()
The join
method joins the collection's values with a string. Using this method's second argument, you may also specify how the final element should be appended to the string:
1collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'2collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'3collect(['a', 'b'])->join(', ', ' and '); // 'a and b'4collect(['a'])->join(', ', ' and '); // 'a'5collect([])->join(', ', ' and '); // ''
1collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'2collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'3collect(['a', 'b'])->join(', ', ' and '); // 'a and b'4collect(['a'])->join(', ', ' and '); // 'a'5collect([])->join(', ', ' and '); // ''
keyBy()
The keyBy
method keys the collection by the given key. If multiple items have the same key, only the last one will appear in the new collection:
1$collection = collect([2 ['product_id' => 'prod-100', 'name' => 'Desk'],3 ['product_id' => 'prod-200', 'name' => 'Chair'],4]);56$keyed = $collection->keyBy('product_id');78$keyed->all();910/*11 [12 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],13 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],14 ]15*/
1$collection = collect([2 ['product_id' => 'prod-100', 'name' => 'Desk'],3 ['product_id' => 'prod-200', 'name' => 'Chair'],4]);56$keyed = $collection->keyBy('product_id');78$keyed->all();910/*11 [12 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],13 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],14 ]15*/
You may also pass a callback to the method. The callback should return the value to key the collection by:
1$keyed = $collection->keyBy(function ($item, $key) {2 return strtoupper($item['product_id']);3});45$keyed->all();67/*8 [9 'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],10 'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],11 ]12*/
1$keyed = $collection->keyBy(function ($item, $key) {2 return strtoupper($item['product_id']);3});45$keyed->all();67/*8 [9 'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],10 'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],11 ]12*/
keys()
The keys
method returns all of the collection's keys:
1$collection = collect([2 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],3 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],4]);56$keys = $collection->keys();78$keys->all();910// ['prod-100', 'prod-200']
1$collection = collect([2 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],3 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],4]);56$keys = $collection->keys();78$keys->all();910// ['prod-100', 'prod-200']
last()
The last
method returns the last element in the collection that passes a given truth test:
1collect([1, 2, 3, 4])->last(function ($value, $key) {2 return $value < 3;3});45// 2
1collect([1, 2, 3, 4])->last(function ($value, $key) {2 return $value < 3;3});45// 2
You may also call the last
method with no arguments to get the last element in the collection. If the collection is empty, null
is returned:
1collect([1, 2, 3, 4])->last();23// 4
1collect([1, 2, 3, 4])->last();23// 4
lazy()
The lazy
method returns a new LazyCollection
instance from the underlying array of items:
1$lazyCollection = collect([1, 2, 3, 4])->lazy();23get_class($lazyCollection);45// Illuminate\Support\LazyCollection67$lazyCollection->all();89// [1, 2, 3, 4]
1$lazyCollection = collect([1, 2, 3, 4])->lazy();23get_class($lazyCollection);45// Illuminate\Support\LazyCollection67$lazyCollection->all();89// [1, 2, 3, 4]
This is especially useful when you need to perform transformations on a huge Collection
that contains many items:
1$count = $hugeCollection2 ->lazy()3 ->where('country', 'FR')4 ->where('balance', '>', '100')5 ->count();
1$count = $hugeCollection2 ->lazy()3 ->where('country', 'FR')4 ->where('balance', '>', '100')5 ->count();
By converting the collection to a LazyCollection
, we avoid having to allocate a ton of additional memory. Though the original collection still keeps its values in memory, the subsequent filters will not. Therefore, virtually no additional memory will be allocated when filtering the collection's results.
macro()
The static macro
method allows you to add methods to the Collection
class at run time. Refer to the documentation on extending collections for more information.
make()
The static make
method creates a new collection instance. See the Creating Collections section.
map()
The map
method iterates through the collection and passes each value to the given callback. The callback is free to modify the item and return it, thus forming a new collection of modified items:
1$collection = collect([1, 2, 3, 4, 5]);23$multiplied = $collection->map(function ($item, $key) {4 return $item * 2;5});67$multiplied->all();89// [2, 4, 6, 8, 10]
1$collection = collect([1, 2, 3, 4, 5]);23$multiplied = $collection->map(function ($item, $key) {4 return $item * 2;5});67$multiplied->all();89// [2, 4, 6, 8, 10]
Like most other collection methods, map
returns a new collection instance; it does not modify the collection it is called on. If you want to transform the original collection, use the transform
method.
mapInto()
The mapInto()
method iterates over the collection, creating a new instance of the given class by passing the value into the constructor:
1class Currency2{3 /**4 * Create a new currency instance.5 *6 * @param string $code7 * @return void8 */9 function __construct(string $code)10 {11 $this->code = $code;12 }13}1415$collection = collect(['USD', 'EUR', 'GBP']);1617$currencies = $collection->mapInto(Currency::class);1819$currencies->all();2021// [Currency('USD'), Currency('EUR'), Currency('GBP')]
1class Currency2{3 /**4 * Create a new currency instance.5 *6 * @param string $code7 * @return void8 */9 function __construct(string $code)10 {11 $this->code = $code;12 }13}1415$collection = collect(['USD', 'EUR', 'GBP']);1617$currencies = $collection->mapInto(Currency::class);1819$currencies->all();2021// [Currency('USD'), Currency('EUR'), Currency('GBP')]
mapSpread()
The mapSpread
method iterates over the collection's items, passing each nested item value into the given closure. The closure is free to modify the item and return it, thus forming a new collection of modified items:
1$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);23$chunks = $collection->chunk(2);45$sequence = $chunks->mapSpread(function ($even, $odd) {6 return $even + $odd;7});89$sequence->all();1011// [1, 5, 9, 13, 17]
1$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);23$chunks = $collection->chunk(2);45$sequence = $chunks->mapSpread(function ($even, $odd) {6 return $even + $odd;7});89$sequence->all();1011// [1, 5, 9, 13, 17]
mapToGroups()
The mapToGroups
method groups the collection's items by the given closure. The closure should return an associative array containing a single key / value pair, thus forming a new collection of grouped values:
1$collection = collect([2 [3 'name' => 'John Doe',4 'department' => 'Sales',5 ],6 [7 'name' => 'Jane Doe',8 'department' => 'Sales',9 ],10 [11 'name' => 'Johnny Doe',12 'department' => 'Marketing',13 ]14]);1516$grouped = $collection->mapToGroups(function ($item, $key) {17 return [$item['department'] => $item['name']];18});1920$grouped->all();2122/*23 [24 'Sales' => ['John Doe', 'Jane Doe'],25 'Marketing' => ['Johnny Doe'],26 ]27*/2829$grouped->get('Sales')->all();3031// ['John Doe', 'Jane Doe']
1$collection = collect([2 [3 'name' => 'John Doe',4 'department' => 'Sales',5 ],6 [7 'name' => 'Jane Doe',8 'department' => 'Sales',9 ],10 [11 'name' => 'Johnny Doe',12 'department' => 'Marketing',13 ]14]);1516$grouped = $collection->mapToGroups(function ($item, $key) {17 return [$item['department'] => $item['name']];18});1920$grouped->all();2122/*23 [24 'Sales' => ['John Doe', 'Jane Doe'],25 'Marketing' => ['Johnny Doe'],26 ]27*/2829$grouped->get('Sales')->all();3031// ['John Doe', 'Jane Doe']
mapWithKeys()
The mapWithKeys
method iterates through the collection and passes each value to the given callback. The callback should return an associative array containing a single key / value pair:
1$collection = collect([2 [3 'name' => 'John',4 'department' => 'Sales',6 ],7 [8 'name' => 'Jane',9 'department' => 'Marketing',11 ]12]);1314$keyed = $collection->mapWithKeys(function ($item, $key) {15 return [$item['email'] => $item['name']];16});1718$keyed->all();1920/*21 [22 '[email protected]' => 'John',23 '[email protected]' => 'Jane',24 ]25*/
1$collection = collect([2 [3 'name' => 'John',4 'department' => 'Sales',6 ],7 [8 'name' => 'Jane',9 'department' => 'Marketing',11 ]12]);1314$keyed = $collection->mapWithKeys(function ($item, $key) {15 return [$item['email'] => $item['name']];16});1718$keyed->all();1920/*21 [22 '[email protected]' => 'John',23 '[email protected]' => 'Jane',24 ]25*/
max()
The max
method returns the maximum value of a given key:
1$max = collect([2 ['foo' => 10],3 ['foo' => 20]4])->max('foo');56// 2078$max = collect([1, 2, 3, 4, 5])->max();910// 5
1$max = collect([2 ['foo' => 10],3 ['foo' => 20]4])->max('foo');56// 2078$max = collect([1, 2, 3, 4, 5])->max();910// 5
median()
The median
method returns the median value of a given key:
1$median = collect([2 ['foo' => 10],3 ['foo' => 10],4 ['foo' => 20],5 ['foo' => 40]6])->median('foo');78// 15910$median = collect([1, 1, 2, 4])->median();1112// 1.5
1$median = collect([2 ['foo' => 10],3 ['foo' => 10],4 ['foo' => 20],5 ['foo' => 40]6])->median('foo');78// 15910$median = collect([1, 1, 2, 4])->median();1112// 1.5
merge()
The merge
method merges the given array or collection with the original collection. If a string key in the given items matches a string key in the original collection, the given item's value will overwrite the value in the original collection:
1$collection = collect(['product_id' => 1, 'price' => 100]);23$merged = $collection->merge(['price' => 200, 'discount' => false]);45$merged->all();67// ['product_id' => 1, 'price' => 200, 'discount' => false]
1$collection = collect(['product_id' => 1, 'price' => 100]);23$merged = $collection->merge(['price' => 200, 'discount' => false]);45$merged->all();67// ['product_id' => 1, 'price' => 200, 'discount' => false]
If the given item's keys are numeric, the values will be appended to the end of the collection:
1$collection = collect(['Desk', 'Chair']);23$merged = $collection->merge(['Bookcase', 'Door']);45$merged->all();67// ['Desk', 'Chair', 'Bookcase', 'Door']
1$collection = collect(['Desk', 'Chair']);23$merged = $collection->merge(['Bookcase', 'Door']);45$merged->all();67// ['Desk', 'Chair', 'Bookcase', 'Door']
mergeRecursive()
The mergeRecursive
method merges the given array or collection recursively with the original collection. If a string key in the given items matches a string key in the original collection, then the values for these keys are merged together into an array, and this is done recursively:
1$collection = collect(['product_id' => 1, 'price' => 100]);23$merged = $collection->mergeRecursive([4 'product_id' => 2,5 'price' => 200,6 'discount' => false7]);89$merged->all();1011// ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]
1$collection = collect(['product_id' => 1, 'price' => 100]);23$merged = $collection->mergeRecursive([4 'product_id' => 2,5 'price' => 200,6 'discount' => false7]);89$merged->all();1011// ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]
min()
The min
method returns the minimum value of a given key:
1$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');23// 1045$min = collect([1, 2, 3, 4, 5])->min();67// 1
1$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');23// 1045$min = collect([1, 2, 3, 4, 5])->min();67// 1
mode()
The mode
method returns the mode value of a given key:
1$mode = collect([2 ['foo' => 10],3 ['foo' => 10],4 ['foo' => 20],5 ['foo' => 40]6])->mode('foo');78// [10]910$mode = collect([1, 1, 2, 4])->mode();1112// [1]1314$mode = collect([1, 1, 2, 2])->mode();1516// [1, 2]
1$mode = collect([2 ['foo' => 10],3 ['foo' => 10],4 ['foo' => 20],5 ['foo' => 40]6])->mode('foo');78// [10]910$mode = collect([1, 1, 2, 4])->mode();1112// [1]1314$mode = collect([1, 1, 2, 2])->mode();1516// [1, 2]
nth()
The nth
method creates a new collection consisting of every n-th element:
1$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);23$collection->nth(4);45// ['a', 'e']
1$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);23$collection->nth(4);45// ['a', 'e']
You may optionally pass a starting offset as the second argument:
1$collection->nth(4, 1);23// ['b', 'f']
1$collection->nth(4, 1);23// ['b', 'f']
only()
The only
method returns the items in the collection with the specified keys:
1$collection = collect([2 'product_id' => 1,3 'name' => 'Desk',4 'price' => 100,5 'discount' => false6]);78$filtered = $collection->only(['product_id', 'name']);910$filtered->all();1112// ['product_id' => 1, 'name' => 'Desk']
1$collection = collect([2 'product_id' => 1,3 'name' => 'Desk',4 'price' => 100,5 'discount' => false6]);78$filtered = $collection->only(['product_id', 'name']);910$filtered->all();1112// ['product_id' => 1, 'name' => 'Desk']
For the inverse of only
, see the except method.
This method's behavior is modified when using Eloquent Collections.
pad()
The pad
method will fill the array with the given value until the array reaches the specified size. This method behaves like the array_pad PHP function.
To pad to the left, you should specify a negative size. No padding will take place if the absolute value of the given size is less than or equal to the length of the array:
1$collection = collect(['A', 'B', 'C']);23$filtered = $collection->pad(5, 0);45$filtered->all();67// ['A', 'B', 'C', 0, 0]89$filtered = $collection->pad(-5, 0);1011$filtered->all();1213// [0, 0, 'A', 'B', 'C']
1$collection = collect(['A', 'B', 'C']);23$filtered = $collection->pad(5, 0);45$filtered->all();67// ['A', 'B', 'C', 0, 0]89$filtered = $collection->pad(-5, 0);1011$filtered->all();1213// [0, 0, 'A', 'B', 'C']
partition()
The partition
method may be combined with PHP array destructuring to separate elements that pass a given truth test from those that do not:
1$collection = collect([1, 2, 3, 4, 5, 6]);23[$underThree, $equalOrAboveThree] = $collection->partition(function ($i) {4 return $i < 3;5});67$underThree->all();89// [1, 2]1011$equalOrAboveThree->all();1213// [3, 4, 5, 6]
1$collection = collect([1, 2, 3, 4, 5, 6]);23[$underThree, $equalOrAboveThree] = $collection->partition(function ($i) {4 return $i < 3;5});67$underThree->all();89// [1, 2]1011$equalOrAboveThree->all();1213// [3, 4, 5, 6]
pipe()
The pipe
method passes the collection to the given closure and returns the result of the executed closure:
1$collection = collect([1, 2, 3]);23$piped = $collection->pipe(function ($collection) {4 return $collection->sum();5});67// 6
1$collection = collect([1, 2, 3]);23$piped = $collection->pipe(function ($collection) {4 return $collection->sum();5});67// 6
pipeInto()
The pipeInto
method creates a new instance of the given class and passes the collection into the constructor:
1class ResourceCollection2{3 /**4 * The Collection instance.5 */6 public $collection;78 /**9 * Create a new ResourceCollection instance.10 *11 * @param Collection $collection12 * @return void13 */14 public function __construct(Collection $collection)15 {16 $this->collection = $collection;17 }18}1920$collection = collect([1, 2, 3]);2122$resource = $collection->pipeInto(ResourceCollection::class);2324$resource->collection->all();2526// [1, 2, 3]
1class ResourceCollection2{3 /**4 * The Collection instance.5 */6 public $collection;78 /**9 * Create a new ResourceCollection instance.10 *11 * @param Collection $collection12 * @return void13 */14 public function __construct(Collection $collection)15 {16 $this->collection = $collection;17 }18}1920$collection = collect([1, 2, 3]);2122$resource = $collection->pipeInto(ResourceCollection::class);2324$resource->collection->all();2526// [1, 2, 3]
pipeThrough()
The pipeThrough
method passes the collection to the given array of closures and returns the result of the executed closures:
1$collection = collect([1, 2, 3]);23$result = $collection->pipeThrough([4 function ($collection) {5 return $collection->merge([4, 5]);6 },7 function ($collection) {8 return $collection->sum();9 },10]);1112// 15
1$collection = collect([1, 2, 3]);23$result = $collection->pipeThrough([4 function ($collection) {5 return $collection->merge([4, 5]);6 },7 function ($collection) {8 return $collection->sum();9 },10]);1112// 15
pluck()
The pluck
method retrieves all of the values for a given key:
1$collection = collect([2 ['product_id' => 'prod-100', 'name' => 'Desk'],3 ['product_id' => 'prod-200', 'name' => 'Chair'],4]);56$plucked = $collection->pluck('name');78$plucked->all();910// ['Desk', 'Chair']
1$collection = collect([2 ['product_id' => 'prod-100', 'name' => 'Desk'],3 ['product_id' => 'prod-200', 'name' => 'Chair'],4]);56$plucked = $collection->pluck('name');78$plucked->all();910// ['Desk', 'Chair']
You may also specify how you wish the resulting collection to be keyed:
1$plucked = $collection->pluck('name', 'product_id');23$plucked->all();45// ['prod-100' => 'Desk', 'prod-200' => 'Chair']
1$plucked = $collection->pluck('name', 'product_id');23$plucked->all();45// ['prod-100' => 'Desk', 'prod-200' => 'Chair']
The pluck
method also supports retrieving nested values using "dot" notation:
1$collection = collect([2 [3 'name' => 'Laracon',4 'speakers' => [5 'first_day' => ['Rosa', 'Judith'],6 ],7 ],8 [9 'name' => 'VueConf',10 'speakers' => [11 'first_day' => ['Abigail', 'Joey'],12 ],13 ],14]);1516$plucked = $collection->pluck('speakers.first_day');1718$plucked->all();1920// [['Rosa', 'Judith'], ['Abigail', 'Joey']]
1$collection = collect([2 [3 'name' => 'Laracon',4 'speakers' => [5 'first_day' => ['Rosa', 'Judith'],6 ],7 ],8 [9 'name' => 'VueConf',10 'speakers' => [11 'first_day' => ['Abigail', 'Joey'],12 ],13 ],14]);1516$plucked = $collection->pluck('speakers.first_day');1718$plucked->all();1920// [['Rosa', 'Judith'], ['Abigail', 'Joey']]
If duplicate keys exist, the last matching element will be inserted into the plucked collection:
1$collection = collect([2 ['brand' => 'Tesla', 'color' => 'red'],3 ['brand' => 'Pagani', 'color' => 'white'],4 ['brand' => 'Tesla', 'color' => 'black'],5 ['brand' => 'Pagani', 'color' => 'orange'],6]);78$plucked = $collection->pluck('color', 'brand');910$plucked->all();1112// ['Tesla' => 'black', 'Pagani' => 'orange']
1$collection = collect([2 ['brand' => 'Tesla', 'color' => 'red'],3 ['brand' => 'Pagani', 'color' => 'white'],4 ['brand' => 'Tesla', 'color' => 'black'],5 ['brand' => 'Pagani', 'color' => 'orange'],6]);78$plucked = $collection->pluck('color', 'brand');910$plucked->all();1112// ['Tesla' => 'black', 'Pagani' => 'orange']
pop()
The pop
method removes and returns the last item from the collection:
1$collection = collect([1, 2, 3, 4, 5]);23$collection->pop();45// 567$collection->all();89// [1, 2, 3, 4]
1$collection = collect([1, 2, 3, 4, 5]);23$collection->pop();45// 567$collection->all();89// [1, 2, 3, 4]
You may pass an integer to the pop
method to remove and return multiple items from the end of a collection:
1$collection = collect([1, 2, 3, 4, 5]);23$collection->pop(3);45// collect([5, 4, 3])67$collection->all();89// [1, 2]
1$collection = collect([1, 2, 3, 4, 5]);23$collection->pop(3);45// collect([5, 4, 3])67$collection->all();89// [1, 2]
prepend()
The prepend
method adds an item to the beginning of the collection:
1$collection = collect([1, 2, 3, 4, 5]);23$collection->prepend(0);45$collection->all();67// [0, 1, 2, 3, 4, 5]
1$collection = collect([1, 2, 3, 4, 5]);23$collection->prepend(0);45$collection->all();67// [0, 1, 2, 3, 4, 5]
You may also pass a second argument to specify the key of the prepended item:
1$collection = collect(['one' => 1, 'two' => 2]);23$collection->prepend(0, 'zero');45$collection->all();67// ['zero' => 0, 'one' => 1, 'two' => 2]
1$collection = collect(['one' => 1, 'two' => 2]);23$collection->prepend(0, 'zero');45$collection->all();67// ['zero' => 0, 'one' => 1, 'two' => 2]
pull()
The pull
method removes and returns an item from the collection by its key:
1$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);23$collection->pull('name');45// 'Desk'67$collection->all();89// ['product_id' => 'prod-100']
1$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);23$collection->pull('name');45// 'Desk'67$collection->all();89// ['product_id' => 'prod-100']
push()
The push
method appends an item to the end of the collection:
1$collection = collect([1, 2, 3, 4]);23$collection->push(5);45$collection->all();67// [1, 2, 3, 4, 5]
1$collection = collect([1, 2, 3, 4]);23$collection->push(5);45$collection->all();67// [1, 2, 3, 4, 5]
put()
The put
method sets the given key and value in the collection:
1$collection = collect(['product_id' => 1, 'name' => 'Desk']);23$collection->put('price', 100);45$collection->all();67// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]
1$collection = collect(['product_id' => 1, 'name' => 'Desk']);23$collection->put('price', 100);45$collection->all();67// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]
random()
The random
method returns a random item from the collection:
1$collection = collect([1, 2, 3, 4, 5]);23$collection->random();45// 4 - (retrieved randomly)
1$collection = collect([1, 2, 3, 4, 5]);23$collection->random();45// 4 - (retrieved randomly)
You may pass an integer to random
to specify how many items you would like to randomly retrieve. A collection of items is always returned when explicitly passing the number of items you wish to receive:
1$random = $collection->random(3);23$random->all();45// [2, 4, 5] - (retrieved randomly)
1$random = $collection->random(3);23$random->all();45// [2, 4, 5] - (retrieved randomly)
If the collection instance has fewer items than requested, the random
method will throw an InvalidArgumentException
.
The random
method also accepts a closure, which will receive the current collection instance:
1$random = $collection->random(fn ($items) => min(10, count($items)));23$random->all();45// [1, 2, 3, 4, 5] - (retrieved randomly)
1$random = $collection->random(fn ($items) => min(10, count($items)));23$random->all();45// [1, 2, 3, 4, 5] - (retrieved randomly)
range()
The range
method returns a collection containing integers between the specified range:
1$collection = collect()->range(3, 6);23$collection->all();45// [3, 4, 5, 6]
1$collection = collect()->range(3, 6);23$collection->all();45// [3, 4, 5, 6]
reduce()
The reduce
method reduces the collection to a single value, passing the result of each iteration into the subsequent iteration:
1$collection = collect([1, 2, 3]);23$total = $collection->reduce(function ($carry, $item) {4 return $carry + $item;5});67// 6
1$collection = collect([1, 2, 3]);23$total = $collection->reduce(function ($carry, $item) {4 return $carry + $item;5});67// 6
The value for $carry
on the first iteration is null
; however, you may specify its initial value by passing a second argument to reduce
:
1$collection->reduce(function ($carry, $item) {2 return $carry + $item;3}, 4);45// 10
1$collection->reduce(function ($carry, $item) {2 return $carry + $item;3}, 4);45// 10
The reduce
method also passes array keys in associative collections to the given callback:
1$collection = collect([2 'usd' => 1400,3 'gbp' => 1200,4 'eur' => 1000,5]);67$ratio = [8 'usd' => 1,9 'gbp' => 1.37,10 'eur' => 1.22,11];1213$collection->reduce(function ($carry, $value, $key) use ($ratio) {14 return $carry + ($value * $ratio[$key]);15});1617// 4264
1$collection = collect([2 'usd' => 1400,3 'gbp' => 1200,4 'eur' => 1000,5]);67$ratio = [8 'usd' => 1,9 'gbp' => 1.37,10 'eur' => 1.22,11];1213$collection->reduce(function ($carry, $value, $key) use ($ratio) {14 return $carry + ($value * $ratio[$key]);15});1617// 4264
reduceSpread()
The reduceSpread
method reduces the collection to an array of values, passing the results of each iteration into the subsequent iteration. This method is similar to the reduce
method; however, it can accept multiple initial values:
1[$creditsRemaining, $batch] = Image::where('status', 'unprocessed')2 ->get()3 ->reduceSpread(function ($creditsRemaining, $batch, $image) {4 if ($creditsRemaining >= $image->creditsRequired()) {5 $batch->push($image);67 $creditsRemaining -= $image->creditsRequired();8 }910 return [$creditsRemaining, $batch];11 }, $creditsAvailable, collect());
1[$creditsRemaining, $batch] = Image::where('status', 'unprocessed')2 ->get()3 ->reduceSpread(function ($creditsRemaining, $batch, $image) {4 if ($creditsRemaining >= $image->creditsRequired()) {5 $batch->push($image);67 $creditsRemaining -= $image->creditsRequired();8 }910 return [$creditsRemaining, $batch];11 }, $creditsAvailable, collect());
reject()
The reject
method filters the collection using the given closure. The closure should return true
if the item should be removed from the resulting collection:
1$collection = collect([1, 2, 3, 4]);23$filtered = $collection->reject(function ($value, $key) {4 return $value > 2;5});67$filtered->all();89// [1, 2]
1$collection = collect([1, 2, 3, 4]);23$filtered = $collection->reject(function ($value, $key) {4 return $value > 2;5});67$filtered->all();89// [1, 2]
For the inverse of the reject
method, see the filter
method.
replace()
The replace
method behaves similarly to merge
; however, in addition to overwriting matching items that have string keys, the replace
method will also overwrite items in the collection that have matching numeric keys:
1$collection = collect(['Taylor', 'Abigail', 'James']);23$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);45$replaced->all();67// ['Taylor', 'Victoria', 'James', 'Finn']
1$collection = collect(['Taylor', 'Abigail', 'James']);23$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);45$replaced->all();67// ['Taylor', 'Victoria', 'James', 'Finn']
replaceRecursive()
This method works like replace
, but it will recur into arrays and apply the same replacement process to the inner values:
1$collection = collect([2 'Taylor',3 'Abigail',4 [5 'James',6 'Victoria',7 'Finn'8 ]9]);1011$replaced = $collection->replaceRecursive([12 'Charlie',13 2 => [1 => 'King']14]);1516$replaced->all();1718// ['Charlie', 'Abigail', ['James', 'King', 'Finn']]
1$collection = collect([2 'Taylor',3 'Abigail',4 [5 'James',6 'Victoria',7 'Finn'8 ]9]);1011$replaced = $collection->replaceRecursive([12 'Charlie',13 2 => [1 => 'King']14]);1516$replaced->all();1718// ['Charlie', 'Abigail', ['James', 'King', 'Finn']]
reverse()
The reverse
method reverses the order of the collection's items, preserving the original keys:
1$collection = collect(['a', 'b', 'c', 'd', 'e']);23$reversed = $collection->reverse();45$reversed->all();67/*8 [9 4 => 'e',10 3 => 'd',11 2 => 'c',12 1 => 'b',13 0 => 'a',14 ]15*/
1$collection = collect(['a', 'b', 'c', 'd', 'e']);23$reversed = $collection->reverse();45$reversed->all();67/*8 [9 4 => 'e',10 3 => 'd',11 2 => 'c',12 1 => 'b',13 0 => 'a',14 ]15*/
search()
The search
method searches the collection for the given value and returns its key if found. If the item is not found, false
is returned:
1$collection = collect([2, 4, 6, 8]);23$collection->search(4);45// 1
1$collection = collect([2, 4, 6, 8]);23$collection->search(4);45// 1
The search is done using a "loose" comparison, meaning a string with an integer value will be considered equal to an integer of the same value. To use "strict" comparison, pass true
as the second argument to the method:
1collect([2, 4, 6, 8])->search('4', $strict = true);23// false
1collect([2, 4, 6, 8])->search('4', $strict = true);23// false
Alternatively, you may provide your own closure to search for the first item that passes a given truth test:
1collect([2, 4, 6, 8])->search(function ($item, $key) {2 return $item > 5;3});45// 2
1collect([2, 4, 6, 8])->search(function ($item, $key) {2 return $item > 5;3});45// 2
shift()
The shift
method removes and returns the first item from the collection:
1$collection = collect([1, 2, 3, 4, 5]);23$collection->shift();45// 167$collection->all();89// [2, 3, 4, 5]
1$collection = collect([1, 2, 3, 4, 5]);23$collection->shift();45// 167$collection->all();89// [2, 3, 4, 5]
You may pass an integer to the shift
method to remove and return multiple items from the beginning of a collection:
1$collection = collect([1, 2, 3, 4, 5]);23$collection->shift(3);45// collect([1, 2, 3])67$collection->all();89// [4, 5]
1$collection = collect([1, 2, 3, 4, 5]);23$collection->shift(3);45// collect([1, 2, 3])67$collection->all();89// [4, 5]
shuffle()
The shuffle
method randomly shuffles the items in the collection:
1$collection = collect([1, 2, 3, 4, 5]);23$shuffled = $collection->shuffle();45$shuffled->all();67// [3, 2, 5, 1, 4] - (generated randomly)
1$collection = collect([1, 2, 3, 4, 5]);23$shuffled = $collection->shuffle();45$shuffled->all();67// [3, 2, 5, 1, 4] - (generated randomly)
skip()
The skip
method returns a new collection, with the given number of elements removed from the beginning of the collection:
1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);23$collection = $collection->skip(4);45$collection->all();67// [5, 6, 7, 8, 9, 10]
1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);23$collection = $collection->skip(4);45$collection->all();67// [5, 6, 7, 8, 9, 10]
skipUntil()
The skipUntil
method skips over items from the collection until the given callback returns true
and then returns the remaining items in the collection as a new collection instance:
1$collection = collect([1, 2, 3, 4]);23$subset = $collection->skipUntil(function ($item) {4 return $item >= 3;5});67$subset->all();89// [3, 4]
1$collection = collect([1, 2, 3, 4]);23$subset = $collection->skipUntil(function ($item) {4 return $item >= 3;5});67$subset->all();89// [3, 4]
You may also pass a simple value to the skipUntil
method to skip all items until the given value is found:
1$collection = collect([1, 2, 3, 4]);23$subset = $collection->skipUntil(3);45$subset->all();67// [3, 4]
1$collection = collect([1, 2, 3, 4]);23$subset = $collection->skipUntil(3);45$subset->all();67// [3, 4]
If the given value is not found or the callback never returns true
, the skipUntil
method will return an empty collection.
skipWhile()
The skipWhile
method skips over items from the collection while the given callback returns true
and then returns the remaining items in the collection as a new collection:
1$collection = collect([1, 2, 3, 4]);23$subset = $collection->skipWhile(function ($item) {4 return $item <= 3;5});67$subset->all();89// [4]
1$collection = collect([1, 2, 3, 4]);23$subset = $collection->skipWhile(function ($item) {4 return $item <= 3;5});67$subset->all();89// [4]
If the callback never returns false
, the skipWhile
method will return an empty collection.
slice()
The slice
method returns a slice of the collection starting at the given index:
1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);23$slice = $collection->slice(4);45$slice->all();67// [5, 6, 7, 8, 9, 10]
1$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);23$slice = $collection->slice(4);45$slice->all();67// [5, 6, 7, 8, 9, 10]
If you would like to limit the size of the returned slice, pass the desired size as the second argument to the method:
1$slice = $collection->slice(4, 2);23$slice->all();45// [5, 6]
1$slice = $collection->slice(4, 2);23$slice->all();45// [5, 6]
The returned slice will preserve keys by default. If you do not wish to preserve the original keys, you can use the values
method to reindex them.
sliding()
The sliding
method returns a new collection of chunks representing a "sliding window" view of the items in the collection:
1$collection = collect([1, 2, 3, 4, 5]);23$chunks = $collection->sliding(2);45$chunks->toArray();67// [[1, 2], [2, 3], [3, 4], [4, 5]]
1$collection = collect([1, 2, 3, 4, 5]);23$chunks = $collection->sliding(2);45$chunks->toArray();67// [[1, 2], [2, 3], [3, 4], [4, 5]]
This is especially useful in conjunction with the eachSpread
method:
1$transactions->sliding(2)->eachSpread(function ($previous, $current) {2 $current->total = $previous->total + $current->amount;3});
1$transactions->sliding(2)->eachSpread(function ($previous, $current) {2 $current->total = $previous->total + $current->amount;3});
You may optionally pass a second "step" value, which determines the distance between the first item of every chunk:
1$collection = collect([1, 2, 3, 4, 5]);23$chunks = $collection->sliding(3, step: 2);45$chunks->toArray();67// [[1, 2, 3], [3, 4, 5]]
1$collection = collect([1, 2, 3, 4, 5]);23$chunks = $collection->sliding(3, step: 2);45$chunks->toArray();67// [[1, 2, 3], [3, 4, 5]]
sole()
The sole
method returns the first element in the collection that passes a given truth test, but only if the truth test matches exactly one element:
1collect([1, 2, 3, 4])->sole(function ($value, $key) {2 return $value === 2;3});45// 2
1collect([1, 2, 3, 4])->sole(function ($value, $key) {2 return $value === 2;3});45// 2
You may also pass a key / value pair to the sole
method, which will return the first element in the collection that matches the given pair, but only if it exactly one element matches:
1$collection = collect([2 ['product' => 'Desk', 'price' => 200],3 ['product' => 'Chair', 'price' => 100],4]);56$collection->sole('product', 'Chair');78// ['product' => 'Chair', 'price' => 100]
1$collection = collect([2 ['product' => 'Desk', 'price' => 200],3 ['product' => 'Chair', 'price' => 100],4]);56$collection->sole('product', 'Chair');78// ['product' => 'Chair', 'price' => 100]
Alternatively, you may also call the sole
method with no argument to get the first element in the collection if there is only one element:
1$collection = collect([2 ['product' => 'Desk', 'price' => 200],3]);45$collection->sole();67// ['product' => 'Desk', 'price' => 200]
1$collection = collect([2 ['product' => 'Desk', 'price' => 200],3]);45$collection->sole();67// ['product' => 'Desk', 'price' => 200]
If there are no elements in the collection that should be returned by the sole
method, an \Illuminate\Collections\ItemNotFoundException
exception will be thrown. If there is more than one element that should be returned, an \Illuminate\Collections\MultipleItemsFoundException
will be thrown.
some()
Alias for the contains
method.
sort()
The sort
method sorts the collection. The sorted collection keeps the original array keys, so in the following example we will use the values
method to reset the keys to consecutively numbered indexes:
1$collection = collect([5, 3, 1, 2, 4]);23$sorted = $collection->sort();45$sorted->values()->all();67// [1, 2, 3, 4, 5]
1$collection = collect([5, 3, 1, 2, 4]);23$sorted = $collection->sort();45$sorted->values()->all();67// [1, 2, 3, 4, 5]
If your sorting needs are more advanced, you may pass a callback to sort
with your own algorithm. Refer to the PHP documentation on uasort
, which is what the collection's sort
method calls utilizes internally.
If you need to sort a collection of nested arrays or objects, see the sortBy
and sortByDesc
methods.
sortBy()
The sortBy
method sorts the collection by the given key. The sorted collection keeps the original array keys, so in the following example we will use the values
method to reset the keys to consecutively numbered indexes:
1$collection = collect([2 ['name' => 'Desk', 'price' => 200],3 ['name' => 'Chair', 'price' => 100],4 ['name' => 'Bookcase', 'price' => 150],5]);67$sorted = $collection->sortBy('price');89$sorted->values()->all();1011/*12 [13 ['name' => 'Chair', 'price' => 100],14 ['name' => 'Bookcase', 'price' => 150],15 ['name' => 'Desk', 'price' => 200],16 ]17*/
1$collection = collect([2 ['name' => 'Desk', 'price' => 200],3 ['name' => 'Chair', 'price' => 100],4 ['name' => 'Bookcase', 'price' => 150],5]);67$sorted = $collection->sortBy('price');89$sorted->values()->all();1011/*12 [13 ['name' => 'Chair', 'price' => 100],14 ['name' => 'Bookcase', 'price' => 150],15 ['name' => 'Desk', 'price' => 200],16 ]17*/
The sortBy
method accepts sort flags as its second argument:
1$collection = collect([2 ['title' => 'Item 1'],3 ['title' => 'Item 12'],4 ['title' => 'Item 3'],5]);67$sorted = $collection->sortBy('title', SORT_NATURAL);89$sorted->values()->all();1011/*12 [13 ['title' => 'Item 1'],14 ['title' => 'Item 3'],15 ['title' => 'Item 12'],16 ]17*/
1$collection = collect([2 ['title' => 'Item 1'],3 ['title' => 'Item 12'],4 ['title' => 'Item 3'],5]);67$sorted = $collection->sortBy('title', SORT_NATURAL);89$sorted->values()->all();1011/*12 [13 ['title' => 'Item 1'],14 ['title' => 'Item 3'],15 ['title' => 'Item 12'],16 ]17*/
Alternatively, you may pass your own closure to determine how to sort the collection's values:
1$collection = collect([2 ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],3 ['name' => 'Chair', 'colors' => ['Black']],4 ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],5]);67$sorted = $collection->sortBy(function ($product, $key) {8 return count($product['colors']);9});1011$sorted->values()->all();1213/*14 [15 ['name' => 'Chair', 'colors' => ['Black']],16 ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],17 ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],18 ]19*/
1$collection = collect([2 ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],3 ['name' => 'Chair', 'colors' => ['Black']],4 ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],5]);67$sorted = $collection->sortBy(function ($product, $key) {8 return count($product['colors']);9});1011$sorted->values()->all();1213/*14 [15 ['name' => 'Chair', 'colors' => ['Black']],16 ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],17 ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],18 ]19*/
If you would like to sort your collection by multiple attributes, you may pass an array of sort operations to the sortBy
method. Each sort operation should be an array consisting of the attribute that you wish to sort by and the direction of the desired sort:
1$collection = collect([2 ['name' => 'Taylor Otwell', 'age' => 34],3 ['name' => 'Abigail Otwell', 'age' => 30],4 ['name' => 'Taylor Otwell', 'age' => 36],5 ['name' => 'Abigail Otwell', 'age' => 32],6]);78$sorted = $collection->sortBy([9 ['name', 'asc'],10 ['age', 'desc'],11]);1213$sorted->values()->all();1415/*16 [17 ['name' => 'Abigail Otwell', 'age' => 32],18 ['name' => 'Abigail Otwell', 'age' => 30],19 ['name' => 'Taylor Otwell', 'age' => 36],20 ['name' => 'Taylor Otwell', 'age' => 34],21 ]22*/
1$collection = collect([2 ['name' => 'Taylor Otwell', 'age' => 34],3 ['name' => 'Abigail Otwell', 'age' => 30],4 ['name' => 'Taylor Otwell', 'age' => 36],5 ['name' => 'Abigail Otwell', 'age' => 32],6]);78$sorted = $collection->sortBy([9 ['name', 'asc'],10 ['age', 'desc'],11]);1213$sorted->values()->all();1415/*16 [17 ['name' => 'Abigail Otwell', 'age' => 32],18 ['name' => 'Abigail Otwell', 'age' => 30],19 ['name' => 'Taylor Otwell', 'age' => 36],20 ['name' => 'Taylor Otwell', 'age' => 34],21 ]22*/
When sorting a collection by multiple attributes, you may also provide closures that define each sort operation:
1$collection = collect([2 ['name' => 'Taylor Otwell', 'age' => 34],3 ['name' => 'Abigail Otwell', 'age' => 30],4 ['name' => 'Taylor Otwell', 'age' => 36],5 ['name' => 'Abigail Otwell', 'age' => 32],6]);78$sorted = $collection->sortBy([9 fn ($a, $b) => $a['name'] <=> $b['name'],10 fn ($a, $b) => $b['age'] <=> $a['age'],11]);1213$sorted->values()->all();1415/*16 [17 ['name' => 'Abigail Otwell', 'age' => 32],18 ['name' => 'Abigail Otwell', 'age' => 30],19 ['name' => 'Taylor Otwell', 'age' => 36],20 ['name' => 'Taylor Otwell', 'age' => 34],21 ]22*/
1$collection = collect([2 ['name' => 'Taylor Otwell', 'age' => 34],3 ['name' => 'Abigail Otwell', 'age' => 30],4 ['name' => 'Taylor Otwell', 'age' => 36],5 ['name' => 'Abigail Otwell', 'age' => 32],6]);78$sorted = $collection->sortBy([9 fn ($a, $b) => $a['name'] <=> $b['name'],10 fn ($a, $b) => $b['age'] <=> $a['age'],11]);1213$sorted->values()->all();1415/*16 [17 ['name' => 'Abigail Otwell', 'age' => 32],18 ['name' => 'Abigail Otwell', 'age' => 30],19 ['name' => 'Taylor Otwell', 'age' => 36],20 ['name' => 'Taylor Otwell', 'age' => 34],21 ]22*/
sortByDesc()
This method has the same signature as the sortBy
method, but will sort the collection in the opposite order.
sortDesc()
This method will sort the collection in the opposite order as the sort
method:
1$collection = collect([5, 3, 1, 2, 4]);23$sorted = $collection->sortDesc();45$sorted->values()->all();67// [5, 4, 3, 2, 1]
1$collection = collect([5, 3, 1, 2, 4]);23$sorted = $collection->sortDesc();45$sorted->values()->all();67// [5, 4, 3, 2, 1]
Unlike sort
, you may not pass a closure to sortDesc
. Instead, you should use the sort
method and invert your comparison.
sortKeys()
The sortKeys
method sorts the collection by the keys of the underlying associative array:
1$collection = collect([2 'id' => 22345,3 'first' => 'John',4 'last' => 'Doe',5]);67$sorted = $collection->sortKeys();89$sorted->all();1011/*12 [13 'first' => 'John',14 'id' => 22345,15 'last' => 'Doe',16 ]17*/
1$collection = collect([2 'id' => 22345,3 'first' => 'John',4 'last' => 'Doe',5]);67$sorted = $collection->sortKeys();89$sorted->all();1011/*12 [13 'first' => 'John',14 'id' => 22345,15 'last' => 'Doe',16 ]17*/
sortKeysDesc()
This method has the same signature as the sortKeys
method, but will sort the collection in the opposite order.
sortKeysUsing()
The sortKeysUsing
method sorts the collection by the keys of the underlying associative array using a callback:
1$collection = collect([2 'ID' => 22345,3 'first' => 'John',4 'last' => 'Doe',5]);67$sorted = $collection->sortKeysUsing('strnatcasecmp');89$sorted->all();1011/*12 [13 'first' => 'John',14 'ID' => 22345,15 'last' => 'Doe',16 ]17*/
1$collection = collect([2 'ID' => 22345,3 'first' => 'John',4 'last' => 'Doe',5]);67$sorted = $collection->sortKeysUsing('strnatcasecmp');89$sorted->all();1011/*12 [13 'first' => 'John',14 'ID' => 22345,15 'last' => 'Doe',16 ]17*/
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 uksort
, which is the PHP function that sortKeysUsing
method utilizes internally.
splice()
The splice
method removes and returns a slice of items starting at the specified index:
1$collection = collect([1, 2, 3, 4, 5]);23$chunk = $collection->splice(2);45$chunk->all();67// [3, 4, 5]89$collection->all();1011// [1, 2]
1$collection = collect([1, 2, 3, 4, 5]);23$chunk = $collection->splice(2);45$chunk->all();67// [3, 4, 5]89$collection->all();1011// [1, 2]
You may pass a second argument to limit the size of the resulting collection:
1$collection = collect([1, 2, 3, 4, 5]);23$chunk = $collection->splice(2, 1);45$chunk->all();67// [3]89$collection->all();1011// [1, 2, 4, 5]
1$collection = collect([1, 2, 3, 4, 5]);23$chunk = $collection->splice(2, 1);45$chunk->all();67// [3]89$collection->all();