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. })
  4. ->reject(function ($name) {
  5.     return empty($name);
  6. });

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]);

The results of Eloquent queries are always returned as Collection instances.

Available Methods

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

allaverageavgchunkcollapsecombinecontainscountdiffdiffKeyseacheveryexceptfilterfirstflatMapflattenflipforgetforPagegetgroupByhasimplodeintersectisEmptykeyBykeyslastmapmaxmedianmergeminmodeonlypipepluckpopprependpullpushputrandomreducerejectreversesearchshiftshuffleslicesortsortBysortByDescsplicesumtaketoArraytoJsontransformunionuniquevalueswherewhereLoosewhereInwhereInLoosezip

Method Listing

all()

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

  1. collect([1, 2, 3])->all();
  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([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->avg('foo');
  3. // 20
  5. $average = collect([1, 1, 2, 4])->avg();
  7. // 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]);
  3. $chunks = $collection->chunk(4);
  5. $chunks->toArray();
  7. // [[1, 2, 3, 4], [5, 6, 7]]

This method is especially useful in views when working with a grid system such as Bootstrap. 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

collapse()

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

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

combine()

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

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

contains()

The contains method determines whether the collection contains a given item:

  1. $collection = collect(['name' => 'Desk', 'price' => 100]);
  3. $collection->contains('Desk');
  5. // true
  7. $collection->contains('New York');
  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. ]);
  6. $collection->contains('product', 'Bookcase');
  8. // false

Finally, you may also pass a callback to the contains method to perform your own truth test:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $collection->contains(function ($key, $value) {
  4.     return $value > 5;
  5. });
  7. // 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.

count()

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

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

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]);
  3. $diff = $collection->diff([2, 4, 6, 8]);
  5. $diff->all();
  7. // [1, 3, 5]

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. ]);
  9. $diff = $collection->diffKeys([
  10.     'two' => 2,
  11.     'four' => 4,
  12.     'six' => 6,
  13.     'eight' => 8,
  14. ]);
  16. $diff->all();
  18. // ['one' => 10, 'three' => 30, 'five' => 50]

each()

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

  1. $collection = $collection->each(function ($item, $key) {
  2.     //
  3. });

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

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

every()

The every method creates a new collection consisting of every n-th element:

  1. $collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
  3. $collection->every(4);
  5. // ['a', 'e']

You may optionally pass an offset as the second argument:

  1. $collection->every(4, 1);
  3. // ['b', 'f']

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]);
  3. $filtered = $collection->except(['price', 'discount']);
  5. $filtered->all();
  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]);
  3. $filtered = $collection->filter(function ($value, $key) {
  4.     return $value > 2;
  5. });
  7. $filtered->all();
  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, []]);
  3. $collection->filter()->all();
  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:

  1. collect([1, 2, 3, 4])->first(function ($key, $value) {
  2.     return $value > 2;
  3. });
  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:

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

flatMap()

The flatMap 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. Then, the array is flattened by a level:

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

flatten()

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

  1. $collection = collect(['name' => 'taylor', 'languages' => ['php', 'javascript']]);
  3. $flattened = $collection->flatten();
  5. $flattened->all();
  7. // ['taylor', 'php', 'javascript'];

You may optionally pass the function a "depth" argument:

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

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 restrict the levels of nested arrays that will be flattened.

flip()

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

  1. $collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
  3. $flipped = $collection->flip();
  5. $flipped->all();
  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']);
  3. $collection->forget('name');
  5. $collection->all();
  7. // ['framework' => 'laravel']

Note: 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]);
  3. $chunk = $collection->forPage(2, 3);
  5. $chunk->all();
  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']);
  3. $value = $collection->get('name');
  5. // taylor

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

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

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

  1. $collection->get('email', function () {
  2.     return 'default-value';
  3. });
  5. // default-value

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. ]);
  7. $grouped = $collection->groupBy('account_id');
  9. $grouped->toArray();
  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. */

In addition to passing a string key, you may also 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. });
  5. $grouped->toArray();
  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. */

has()

The has method determines if a given key exists in the collection:

  1. $collection = collect(['account_id' => 1, 'product' => 'Desk']);
  3. $collection->has('product');
  5. // true

implode()

The implode method joins the 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. ]);
  6. $collection->implode('product', ', ');
  8. // Desk, Chair

If the collection contains simple strings or numeric values, simply pass the "glue" as the only argument to the method:

  1. collect([1, 2, 3, 4, 5])->implode('-');
  3. // '1-2-3-4-5'

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']);
  3. $intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
  5. $intersect->all();
  7. // [0 => 'Desk', 2 => 'Chair']

isEmpty()

The isEmpty method returns true if the collection is empty; otherwise, false is returned:

  1. collect([])->isEmpty();
  3. // true

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. ]);
  6. $keyed = $collection->keyBy('product_id');
  8. $keyed->all();
  10. /*
  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) {
  2.     return strtoupper($item['product_id']);
  3. });
  5. $keyed->all();
  7. /*
  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. ]);
  6. $keys = $collection->keys();
  8. $keys->all();
  10. // ['prod-100', 'prod-200']

last()

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

  1. collect([1, 2, 3, 4])->last(function ($key, $value) {
  2.     return $value < 3;
  3. });
  5. // 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:

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

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]);
  3. $multiplied = $collection->map(function ($item, $key) {
  4.     return $item * 2;
  5. });
  7. $multiplied->all();
  9. // [2, 4, 6, 8, 10]

Note: 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.

max()

The max method returns the maximum value of a given key:

  1. $max = collect([['foo' => 10], ['foo' => 20]])->max('foo');
  3. // 20
  5. $max = collect([1, 2, 3, 4, 5])->max();
  7. // 5

median()

The median method returns the median value of a given key:

  1. $median = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->median('foo');
  3. // 15
  5. $median = collect([1, 1, 2, 4])->median();
  7. // 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 items's value will overwrite the value in the original collection:

  1. $collection = collect(['product_id' => 1, 'price' => 100]);
  3. $merged = $collection->merge(['price' => 200, 'discount' => false]);
  5. $merged->all();
  7. // ['product_id' => 1, 'price' => 200, 'discount' => false]

If the given items's keys are numeric, the values will be appended to the end of the collection:

  1. $collection = collect(['Desk', 'Chair']);
  3. $merged = $collection->merge(['Bookcase', 'Door']);
  5. $merged->all();
  7. // ['Desk', 'Chair', 'Bookcase', 'Door']

min()

The min method returns the minimum value of a given key:

  1. $min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
  3. // 10
  5. $min = collect([1, 2, 3, 4, 5])->min();
  7. // 1

mode()

The mode method returns the mode value) of a given key:

  1. $mode = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->mode('foo');
  3. // [10]
  5. $mode = collect([1, 1, 2, 4])->mode();
  7. // [1]

only()

The only method returns the items in the collection with the specified keys:

  1. $collection = collect(['product_id' => 1, 'name' => 'Desk', 'price' => 100, 'discount' => false]);
  3. $filtered = $collection->only(['product_id', 'name']);
  5. $filtered->all();
  7. // ['product_id' => 1, 'name' => 'Desk']

For the inverse of only, see the except method.

pipe()

The pipe method passes the collection to the given callback and returns the result:

  1. $collection = collect([1, 2, 3]);
  3. $piped = $collection->pipe(function ($collection) {
  4.     return $collection->sum();
  5. });
  7. // 6

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. ]);
  6. $plucked = $collection->pluck('name');
  8. $plucked->all();
  10. // ['Desk', 'Chair']

You may also specify how you wish the resulting collection to be keyed:

  1. $plucked = $collection->pluck('name', 'product_id');
  3. $plucked->all();
  5. // ['prod-100' => 'Desk', 'prod-200' => 'Chair']

pop()

The pop method removes and returns the last item from the collection:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $collection->pop();
  5. // 5
  7. $collection->all();
  9. // [1, 2, 3, 4]

prepend()

The prepend method adds an item to the beginning of the collection:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $collection->prepend(0);
  5. $collection->all();
  7. // [0, 1, 2, 3, 4, 5]

You may also pass a second argument to set the key of the prepended item:

  1. $collection = collect(['one' => 1, 'two' => 2]);
  3. $collection->prepend(0, 'zero');
  5. $collection->all();
  7. // ['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']);
  3. $collection->pull('name');
  5. // 'Desk'
  7. $collection->all();
  9. // ['product_id' => 'prod-100']

push()

The push method appends an item to the end of the collection:

  1. $collection = collect([1, 2, 3, 4]);
  3. $collection->push(5);
  5. $collection->all();
  7. // [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']);
  3. $collection->put('price', 100);
  5. $collection->all();
  7. // ['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]);
  3. $collection->random();
  5. // 4 - (retrieved randomly)

You may optionally pass an integer to random to specify how many items you would like to randomly retrieve. If that integer is more than 1, a collection of items is returned:

  1. $random = $collection->random(3);
  3. $random->all();
  5. // [2, 4, 5] - (retrieved randomly)

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]);
  3. $total = $collection->reduce(function ($carry, $item) {
  4.     return $carry + $item;
  5. });
  7. // 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);
  5. // 10

reject()

The reject method filters the collection using the given callback. The callback should return true if the item should be removed from the resulting collection:

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

For the inverse of the reject method, see the filter method.

reverse()

The reverse method reverses the order of the collection's items:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $reversed = $collection->reverse();
  5. $reversed->all();
  7. // [5, 4, 3, 2, 1]

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]);
  3. $collection->search(4);
  5. // 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:

  1. $collection->search('4', true);
  3. // false

Alternatively, you may pass in your own callback to search for the first item that passes your truth test:

  1. $collection->search(function ($item, $key) {
  2.     return $item > 5;
  3. });
  5. // 2

shift()

The shift method removes and returns the first item from the collection:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $collection->shift();
  5. // 1
  7. $collection->all();
  9. // [2, 3, 4, 5]

shuffle()

The shuffle method randomly shuffles the items in the collection:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $shuffled = $collection->shuffle();
  5. $shuffled->all();
  7. // [3, 2, 5, 1, 4] - (generated randomly)

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]);
  3. $slice = $collection->slice(4);
  5. $slice->all();
  7. // [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);
  3. $slice->all();
  5. // [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.

sort()

The sort method sorts the collection. The sorted collection keeps the original array keys, so in this example we'll use the values method to reset the keys to consecutively numbered indexes:

  1. $collection = collect([5, 3, 1, 2, 4]);
  3. $sorted = $collection->sort();
  5. $sorted->values()->all();
  7. // [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 usort, which is what the collection's sort method calls under the hood.

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 this example we'll 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. ]);
  7. $sorted = $collection->sortBy('price');
  9. $sorted->values()->all();
  11. /*
  12.     [
  13.         ['name' => 'Chair', 'price' => 100],
  14.         ['name' => 'Bookcase', 'price' => 150],
  15.         ['name' => 'Desk', 'price' => 200],
  16.     ]
  17. */

You can also pass your own callback to determine how to sort the collection values:

  1. $collection = collect([
  2.     ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
  3.     ['name' => 'Chair', 'colors' => ['Black']],
  4.     ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
  5. ]);
  7. $sorted = $collection->sortBy(function ($product, $key) {
  8.     return count($product['colors']);
  9. });
  11. $sorted->values()->all();
  13. /*
  14.     [
  15.         ['name' => 'Chair', 'colors' => ['Black']],
  16.         ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
  17.         ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
  18.     ]
  19. */

sortByDesc()

This method has the same signature as the sortBy method, but will sort the collection in the opposite order.

splice()

The splice method removes and returns a slice of items starting at the specified index:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $chunk = $collection->splice(2);
  5. $chunk->all();
  7. // [3, 4, 5]
  9. $collection->all();
  11. // [1, 2]

You may pass a second argument to limit the size of the resulting chunk:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $chunk = $collection->splice(2, 1);
  5. $chunk->all();
  7. // [3]
  9. $collection->all();
  11. // [1, 2, 4, 5]

In addition, you can pass a third argument containing the new items to replace the items removed from the collection:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $chunk = $collection->splice(2, 1, [10, 11]);
  5. $chunk->all();
  7. // [3]
  9. $collection->all();
  11. // [1, 2, 10, 11, 4, 5]

sum()

The sum method returns the sum of all items in the collection:

  1. collect([1, 2, 3, 4, 5])->sum();
  3. // 15

If the collection contains nested arrays or objects, you should pass a key to use for determining which values to sum:

  1. $collection = collect([
  2.     ['name' => 'JavaScript: The Good Parts', 'pages' => 176],
  3.     ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
  4. ]);
  6. $collection->sum('pages');
  8. // 1272

In addition, you may pass your own callback to determine which values of the collection to sum:

  1. $collection = collect([
  2.     ['name' => 'Chair', 'colors' => ['Black']],
  3.     ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
  4.     ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
  5. ]);
  7. $collection->sum(function ($product) {
  8.     return count($product['colors']);
  9. });
  11. // 6

take()

The take method returns a new collection with the specified number of items:

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

You may also pass a negative integer to take the specified amount of items from the end of the collection:

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

toArray()

The toArray method converts the collection into a plain PHP array. If the collection's values are Eloquent models, the models will also be converted to arrays:

  1. $collection = collect(['name' => 'Desk', 'price' => 200]);
  3. $collection->toArray();
  5. /*
  6.     [
  7.         ['name' => 'Desk', 'price' => 200],
  8.     ]
  9. */

Note: toArray also converts all of the collection's nested objects to an array. If you want to get the raw underlying array, use the all method instead.

toJson()

The toJson method converts the collection into a JSON serialized string:

  1. $collection = collect(['name' => 'Desk', 'price' => 200]);
  3. $collection->toJson();
  5. // '{"name":"Desk", "price":200}'

transform()

The transform method iterates over the collection and calls the given callback with each item in the collection. The items in the collection will be replaced by the values returned by the callback:

  1. $collection = collect([1, 2, 3, 4, 5]);
  3. $collection->transform(function ($item, $key) {
  4.     return $item * 2;
  5. });
  7. $collection->all();
  9. // [2, 4, 6, 8, 10]

Note: Unlike most other collection methods, transform modifies the collection itself. If you wish to create a new collection instead, use the map method.

union()

The union method adds the given array to the collection. If the given array contains keys that are already in the original collection, the original collection's values will be preferred:

  1. $collection = collect([1 => ['a'], 2 => ['b']]);
  3. $union = $collection->union([3 => ['c'], 1 => ['b']]);
  5. $union->all();
  7. // [1 => ['a'], 2 => ['b'], 3 => ['c']]

unique()

The unique method returns all of the unique items in the collection. The returned collection keeps the original array keys, so in this example we'll use the values method to reset the keys to consecutively numbered indexes:

  1. $collection = collect([1, 1, 2, 2, 3, 4, 2]);
  3. $unique = $collection->unique();
  5. $unique->values()->all();
  7. // [1, 2, 3, 4]

When dealing with nested arrays or objects, you may specify the key used to determine uniqueness:

  1. $collection = collect([
  2.     ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
  3.     ['name' => 'iPhone 5', 'brand' => 'Apple', 'type' => 'phone'],
  4.     ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
  5.     ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
  6.     ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
  7. ]);
  9. $unique = $collection->unique('brand');
  11. $unique->values()->all();
  13. /*
  14.     [
  15.         ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
  16.         ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
  17.     ]
  18. */

You may also pass your own callback to determine item uniqueness:

  1. $unique = $collection->unique(function ($item) {
  2.     return $item['brand'].$item['type'];
  3. });
  5. $unique->values()->all();
  7. /*
  8.     [
  9.         ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
  10.         ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
  11.         ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
  12.         ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
  13.     ]
  14. */

The unique 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.

values()

The values method returns a new collection with the keys reset to consecutive integers:

  1. $collection = collect([
  2.     10 => ['product' => 'Desk', 'price' => 200],
  3.     11 => ['product' => 'Desk', 'price' => 200]
  4. ]);
  6. $values = $collection->values();
  8. $values->all();
  10. /*
  11.     [
  12.         0 => ['product' => 'Desk', 'price' => 200],
  13.         1 => ['product' => 'Desk', 'price' => 200],
  14.     ]
  15. */

where()

The where method filters the collection by a given key / value pair:

  1. $collection = collect([
  2.     ['product' => 'Desk', 'price' => 200],
  3.     ['product' => 'Chair', 'price' => 100],
  4.     ['product' => 'Bookcase', 'price' => 150],
  5.     ['product' => 'Door', 'price' => 100],
  6. ]);
  8. $filtered = $collection->where('price', 100);
  10. $filtered->all();
  12. /*
  13.     [
  14.         ['product' => 'Chair', 'price' => 100],
  15.         ['product' => 'Door', 'price' => 100],
  16.     ]
  17. */

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

whereLoose()

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

whereIn()

The whereIn method filters the collection by a given key / value contained within the given array:

  1. $collection = collect([
  2.     ['product' => 'Desk', 'price' => 200],
  3.     ['product' => 'Chair', 'price' => 100],
  4.     ['product' => 'Bookcase', 'price' => 150],
  5.     ['product' => 'Door', 'price' => 100],
  6. ]);
  8. $filtered = $collection->whereIn('price', [150, 200]);
  10. $filtered->all();
  12. /*
  13.     [
  14.         ['product' => 'Bookcase', 'price' => 150],
  15.         ['product' => 'Desk', 'price' => 200],
  16.     ]
  17. */

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

whereInLoose()

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

zip()

The zip method merges together the values of the given array with the values of the original collection at the corresponding index:

  1. $collection = collect(['Chair', 'Desk']);
  3. $zipped = $collection->zip([100, 200]);
  5. $zipped->all();
  7. // [['Chair', 100], ['Desk', 200]]