CakePHP
  • Documentation
    • Book
    • API
    • Videos
    • Reporting Security Issues
    • Privacy Policy
    • Logos & Trademarks
  • Business Solutions
  • Swag
  • Road Trip
  • Team
  • Community
    • Community
    • Get Involved
    • Issues (Github)
    • Bakery
    • Featured Resources
    • Training
    • Meetups
    • My CakePHP
    • CakeFest
    • Newsletter
    • Linkedin
    • YouTube
    • Facebook
    • Twitter
    • Mastodon
    • Help & Support
    • Forum
    • Stack Overflow
    • IRC
    • Slack
    • Paid Support
CakePHP

C CakePHP 4.6 Strawberry API

  • Project:
    • CakePHP
      • CakePHP
      • Authentication
      • Authorization
      • Chronos
      • Elastic Search
      • Queue
  • Version:
    • 4.6
      • 5.2
      • 5.1
      • 5.0
      • 4.6
      • 4.5
      • 4.4
      • 4.3
      • 4.2
      • 4.1
      • 4.0
      • 3.10
      • 3.9
      • 3.8
      • 3.7
      • 3.6
      • 3.5
      • 3.4
      • 3.3
      • 3.2
      • 3.1
      • 3.0
      • 2.10
      • 2.9
      • 2.8
      • 2.7
      • 2.6
      • 2.5
      • 2.4
      • 2.3
      • 2.2
      • 2.1
      • 2.0
      • 1.3
      • 1.2

Namespaces

  • Global
  • Cake
    • Auth
    • Cache
    • Collection
      • Iterator
    • Command
    • Console
    • Controller
    • Core
    • Database
    • Datasource
    • Error
    • Event
    • Filesystem
    • Form
    • Http
    • I18n
    • Log
    • Mailer
    • Network
    • ORM
    • Routing
    • Shell
    • TestSuite
    • Utility
    • Validation
    • View

Class SortIterator

An iterator that will return the passed items in order. The order is given by the value returned in a callback function that maps each of the elements.

Example:

$items = [$user1, $user2, $user3];
$sorted = new SortIterator($items, function ($user) {
 return $user->age;
});

// output all user name order by their age in descending order
foreach ($sorted as $user) {
 echo $user->name;
}

This iterator does not preserve the keys passed in the original elements.

Namespace: Cake\Collection\Iterator

Method Summary

  • __construct() public

    Wraps this iterator around the passed items so when iterated they are returned in order.

  • __debugInfo() public

    Returns an array that can be used to describe the internal state of this object.

  • __serialize() public

    Returns an array for serializing this of this object.

  • __unserialize() public

    Rebuilds the Collection instance.

  • _createMatcherFilter() protected

    Returns a callable that receives a value and will return whether it matches certain condition.

  • _extract() protected

    Returns a column from $data that can be extracted by iterating over the column names contained in $path. It will return arrays for elements in represented with {*}

  • _propertyExtractor() protected

    Returns a callable that can be used to extract a property or column from an array or object based on a dot separated path.

  • _simpleExtract() protected

    Returns a column from $data that can be extracted by iterating over the column names contained in $path

  • append() public

    Returns a new collection as the result of concatenating the list of elements in this collection with the passed list of elements

  • appendItem() public

    Append a single item creating a new collection.

  • avg() public

    Returns the average of all the values extracted with $path or of this collection.

  • buffered() public

    Returns a new collection where the operations performed by this collection. No matter how many times the new collection is iterated, those operations will only be performed once.

  • cartesianProduct() public

    Create a new collection that is the cartesian product of the current collection

  • chunk() public

    Breaks the collection into smaller arrays of the given size.

  • chunkWithKeys() public

    Breaks the collection into smaller arrays of the given size.

  • combine() public

    Returns a new collection where the values extracted based on a value path and then indexed by a key path. Optionally this method can produce parent groups based on a group property path.

  • compile() public

    Iterates once all elements in this collection and executes all stacked operations of them, finally it returns a new collection with the result. This is useful for converting non-rewindable internal iterators into a collection that can be rewound and used multiple times.

  • contains() public

    Returns true if $value is present in this collection. Comparisons are made both by value and type.

  • count() public

    Returns the amount of elements in the collection.

  • countBy() public

    Sorts a list into groups and returns a count for the number of elements in each group. Similar to groupBy, but instead of returning a list of values, returns a count for the number of values in that group.

  • countKeys() public

    Returns the number of unique keys in this iterator. This is the same as the number of elements the collection will contain after calling toArray()

  • each() public

    Applies a callback to the elements in this collection.

  • every() public

    Returns true if all values in this collection pass the truth test provided in the callback.

  • extract() public

    Returns a new collection containing the column or property value found in each of the elements.

  • filter() public

    Looks through each value in the collection, and returns another collection with all the values that pass a truth test. Only the values for which the callback returns true will be present in the resulting collection.

  • first() public

    Returns the first result in this collection

  • firstMatch() public

    Returns the first result matching all the key-value pairs listed in conditions.

  • groupBy() public

    Splits a collection into sets, grouped by the result of running each value through the callback. If $callback is a string instead of a callable, groups by the property named by $callback on each of the values.

  • indexBy() public

    Given a list and a callback function that returns a key for each element in the list (or a property name), returns an object with an index of each item. Just like groupBy, but for when you know your keys are unique.

  • insert() public

    Returns a new collection containing each of the elements found in $values as a property inside the corresponding elements in this collection. The property where the values will be inserted is described by the $path parameter.

  • isEmpty() public

    Returns whether there are elements in this collection

  • jsonSerialize() public

    Returns the data that can be converted to JSON. This returns the same data as toArray() which contains only unique keys.

  • last() public

    Returns the last result in this collection

  • lazy() public

    Returns a new collection where any operations chained after it are guaranteed to be run lazily. That is, elements will be yielded one at a time.

  • listNested() public

    Returns a new collection with each of the elements of this collection after flattening the tree structure. The tree structure is defined by nesting elements under a key with a known name. It is possible to specify such name by using the '$nestingKey' parameter.

  • map() public

    Returns another collection after modifying each of the values in this one using the provided callable.

  • match() public

    Looks through each value in the list, returning a Collection of all the values that contain all of the key-value pairs listed in $conditions.

  • max() public

    Returns the top element in this collection after being sorted by a property. Check the sortBy method for information on the callback and $sort parameters

  • median() public

    Returns the median of all the values extracted with $path or of this collection.

  • min() public

    Returns the bottom element in this collection after being sorted by a property. Check the sortBy method for information on the callback and $sort parameters

  • nest() public

    Returns a new collection where the values are nested in a tree-like structure based on an id property path and a parent id property path.

  • newCollection() protected

    Returns a new collection.

  • optimizeUnwrap() protected

    Unwraps this iterator and returns the simplest traversable that can be used for getting the data out

  • prepend() public

    Prepend a set of items to a collection creating a new collection

  • prependItem() public

    Prepend a single item creating a new collection.

  • reduce() public

    Folds the values in this collection to a single value, as the result of applying the callback function to all elements. $zero is the initial state of the reduction, and each successive step of it should be returned by the callback function. If $zero is omitted the first value of the collection will be used in its place and reduction will start from the second item.

  • reject() public

    Looks through each value in the collection, and returns another collection with all the values that do not pass a truth test. This is the opposite of filter.

  • sample() public

    Returns a new collection with maximum $length random elements from this collection

  • serialize() public

    Returns a string representation of this object that can be used to reconstruct it

  • shuffle() public

    Returns a new collection with the elements placed in a random order, this function does not preserve the original keys in the collection.

  • skip() public

    Returns a new collection that will skip the specified amount of elements at the beginning of the iteration.

  • some() public

    Returns true if any of the values in this collection pass the truth test provided in the callback.

  • sortBy() public

    Returns a sorted iterator out of the elements in this collection, ranked based on the results of applying a callback function to each value. The parameter $path can also be a string representing the column or property name.

  • stopWhen() public

    Creates a new collection that when iterated will stop yielding results if the provided condition evaluates to true.

  • sumOf() public

    Returns the total sum of all the values extracted with $matcher or of this collection.

  • take() public

    Returns a new collection with maximum $length elements in the internal order this collection was created. If a second parameter is passed, it will determine from what position to start taking elements.

  • takeLast() public

    Returns the last N elements of a collection

  • through() public

    Passes this collection through a callable as its first argument. This is useful for decorating the full collection with another object.

  • toArray() public

    Returns an array representation of the results

  • toList() public

    Returns an numerically-indexed array representation of the results. This is equivalent to calling toArray(false)

  • transpose() public

    Transpose rows and columns into columns and rows

  • unfold() public

    Creates a new collection where the items are the concatenation of the lists of items generated by the transformer function applied to each item in the original collection.

  • unserialize() public

    Unserializes the passed string and rebuilds the Collection instance

  • unwrap() public

    Returns the closest nested iterator that can be safely traversed without losing any possible transformations. This is used mainly to remove empty IteratorIterator wrappers that can only slowdown the iteration process.

  • zip() public

    Combines the elements of this collection with each of the elements of the passed iterables, using their positional index as a reference.

  • zipWith() public

    Combines the elements of this collection with each of the elements of the passed iterables, using their positional index as a reference.

Method Detail

__construct() ¶ public

__construct(iterable $items, callable|string $callback, int $dir = \SORT_DESC, int $type = \SORT_NUMERIC)

Wraps this iterator around the passed items so when iterated they are returned in order.

The callback will receive as first argument each of the elements in $items, the value returned in the callback will be used as the value for sorting such element. Please note that the callback function could be called more than once per element.

Parameters
iterable $items

The values to sort

callable|string $callback

A function used to return the actual value to be compared. It can also be a string representing the path to use to fetch a column or property in each element

int $dir optional

either SORT_DESC or SORT_ASC

int $type optional

the type of comparison to perform, either SORT_STRING SORT_NUMERIC or SORT_NATURAL

__debugInfo() ¶ public

__debugInfo(): array<string, mixed>

Returns an array that can be used to describe the internal state of this object.

Returns
array<string, mixed>

__serialize() ¶ public

__serialize(): array

Returns an array for serializing this of this object.

Returns
array

__unserialize() ¶ public

__unserialize(array $data): void

Rebuilds the Collection instance.

Parameters
array $data

Data array.

Returns
void

_createMatcherFilter() ¶ protected

_createMatcherFilter(array $conditions): Closure

Returns a callable that receives a value and will return whether it matches certain condition.

Parameters
array $conditions

A key-value list of conditions to match where the key is the property path to get from the current item and the value is the value to be compared the item with.

Returns
Closure

_extract() ¶ protected

_extract(ArrayAccess|array $data, array<string> $parts): mixed

Returns a column from $data that can be extracted by iterating over the column names contained in $path. It will return arrays for elements in represented with {*}

Parameters
ArrayAccess|array $data

Data.

array<string> $parts

Path to extract from.

Returns
mixed

_propertyExtractor() ¶ protected

_propertyExtractor(callable|string $path): callable

Returns a callable that can be used to extract a property or column from an array or object based on a dot separated path.

Parameters
callable|string $path

A dot separated path of column to follow so that the final one can be returned or a callable that will take care of doing that.

Returns
callable

_simpleExtract() ¶ protected

_simpleExtract(ArrayAccess|array $data, array<string> $parts): mixed

Returns a column from $data that can be extracted by iterating over the column names contained in $path

Parameters
ArrayAccess|array $data

Data.

array<string> $parts

Path to extract from.

Returns
mixed

append() ¶ public

append(iterable $items): self

Returns a new collection as the result of concatenating the list of elements in this collection with the passed list of elements

Parameters
iterable $items
Returns
self

appendItem() ¶ public

appendItem(mixed $item, mixed $key = null): self

Append a single item creating a new collection.

Parameters
mixed $item
mixed $key optional
Returns
self

avg() ¶ public

avg(callable|string|null $path = null): float|int|null

Returns the average of all the values extracted with $path or of this collection.

Example:

$items = [
 ['invoice' => ['total' => 100]],
 ['invoice' => ['total' => 200]]
];

$total = (new Collection($items))->avg('invoice.total');

// Total: 150

$total = (new Collection([1, 2, 3]))->avg();
// Total: 2

The average of an empty set or 0 rows is null. Collections with null values are not considered empty.

Parameters
callable|string|null $path optional
Returns
float|int|null

buffered() ¶ public

buffered(): self

Returns a new collection where the operations performed by this collection. No matter how many times the new collection is iterated, those operations will only be performed once.

This can also be used to make any non-rewindable iterator rewindable.

Returns
self

cartesianProduct() ¶ public

cartesianProduct(callable|null $operation = null, callable|null $filter = null): Cake\Collection\CollectionInterface

Create a new collection that is the cartesian product of the current collection

In order to create a cartesian product a collection must contain a single dimension of data.

Example

$collection = new Collection([['A', 'B', 'C'], [1, 2, 3]]);
$result = $collection->cartesianProduct()->toArray();
$expected = [
    ['A', 1],
    ['A', 2],
    ['A', 3],
    ['B', 1],
    ['B', 2],
    ['B', 3],
    ['C', 1],
    ['C', 2],
    ['C', 3],
];
Parameters
callable|null $operation optional

A callable that allows you to customize the product result.

callable|null $filter optional

A filtering callback that must return true for a result to be part of the final results.

Returns
Cake\Collection\CollectionInterface
Throws
LogicException

chunk() ¶ public

chunk(int $chunkSize): self

Breaks the collection into smaller arrays of the given size.

Example:

$items [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
$chunked = (new Collection($items))->chunk(3)->toList();
// Returns [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]]
Parameters
int $chunkSize
Returns
self

chunkWithKeys() ¶ public

chunkWithKeys(int $chunkSize, bool $keepKeys = true): self

Breaks the collection into smaller arrays of the given size.

Example:

$items ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' => 6];
$chunked = (new Collection($items))->chunkWithKeys(3)->toList();
// Returns [['a' => 1, 'b' => 2, 'c' => 3], ['d' => 4, 'e' => 5, 'f' => 6]]
Parameters
int $chunkSize
bool $keepKeys optional
Returns
self

combine() ¶ public

combine(callable|string $keyPath, callable|string $valuePath, callable|string|null $groupPath = null): self

Returns a new collection where the values extracted based on a value path and then indexed by a key path. Optionally this method can produce parent groups based on a group property path.

Examples:

$items = [
 ['id' => 1, 'name' => 'foo', 'parent' => 'a'],
 ['id' => 2, 'name' => 'bar', 'parent' => 'b'],
 ['id' => 3, 'name' => 'baz', 'parent' => 'a'],
];

$combined = (new Collection($items))->combine('id', 'name');

// Result will look like this when converted to array
[
 1 => 'foo',
 2 => 'bar',
 3 => 'baz',
];

$combined = (new Collection($items))->combine('id', 'name', 'parent');

// Result will look like this when converted to array
[
 'a' => [1 => 'foo', 3 => 'baz'],
 'b' => [2 => 'bar'],
];
Parameters
callable|string $keyPath
callable|string $valuePath
callable|string|null $groupPath optional
Returns
self

compile() ¶ public

compile(bool $keepKeys = true): self

Iterates once all elements in this collection and executes all stacked operations of them, finally it returns a new collection with the result. This is useful for converting non-rewindable internal iterators into a collection that can be rewound and used multiple times.

A common use case is to re-use the same variable for calculating different data. In those cases it may be helpful and more performant to first compile a collection and then apply more operations to it.

Example:

$collection->map($mapper)->sortBy('age')->extract('name');
$compiled = $collection->compile();
$isJohnHere = $compiled->some($johnMatcher);
$allButJohn = $compiled->filter($johnMatcher);

In the above example, had the collection not been compiled before, the iterations for map, sortBy and extract would've been executed twice: once for getting $isJohnHere and once for $allButJohn

You can think of this method as a way to create save points for complex calculations in a collection.

Parameters
bool $keepKeys optional
Returns
self

contains() ¶ public

contains(mixed $value): bool

Returns true if $value is present in this collection. Comparisons are made both by value and type.

Parameters
mixed $value
Returns
bool

count() ¶ public

count(): int

Returns the amount of elements in the collection.

WARNINGS:

Will change the current position of the iterator:

Calling this method at the same time that you are iterating this collections, for example in a foreach, will result in undefined behavior. Avoid doing this.

Consumes all elements for NoRewindIterator collections:

On certain type of collections, calling this method may render unusable afterwards. That is, you may not be able to get elements out of it, or to iterate on it anymore.

Specifically any collection wrapping a Generator (a function with a yield statement) or a unbuffered database cursor will not accept any other function calls after calling count() on it.

Create a new collection with buffered() method to overcome this problem.

Can report more elements than unique keys:

Any collection constructed by appending collections together, or by having internal iterators returning duplicate keys, will report a larger amount of elements using this functions than the final amount of elements when converting the collections to a keyed array. This is because duplicate keys will be collapsed into a single one in the final array, whereas this count method is only concerned by the amount of elements after converting it to a plain list.

If you need the count of elements after taking the keys in consideration (the count of unique keys), you can call countKeys()

Returns
int

countBy() ¶ public

countBy(callable|string $path): self

Sorts a list into groups and returns a count for the number of elements in each group. Similar to groupBy, but instead of returning a list of values, returns a count for the number of values in that group.

When $callback is a string it should be a property name to extract or a dot separated path of properties that should be followed to get the last one in the path.

Example:

$items = [
 ['id' => 1, 'name' => 'foo', 'parent_id' => 10],
 ['id' => 2, 'name' => 'bar', 'parent_id' => 11],
 ['id' => 3, 'name' => 'baz', 'parent_id' => 10],
];

$group = (new Collection($items))->countBy('parent_id');

// Or
$group = (new Collection($items))->countBy(function ($e) {
 return $e['parent_id'];
});

// Result will look like this when converted to array
[
 10 => 2,
 11 => 1
];
Parameters
callable|string $path
Returns
self

countKeys() ¶ public

countKeys(): int

Returns the number of unique keys in this iterator. This is the same as the number of elements the collection will contain after calling toArray()

This method comes with a number of caveats. Please refer to CollectionInterface::count() for details.

Returns
int

each() ¶ public

each(callable $callback): $this

Applies a callback to the elements in this collection.

Example:

$collection = (new Collection($items))->each(function ($value, $key) {
 echo "Element $key: $value";
});
Parameters
callable $callback
Returns
$this

every() ¶ public

every(callable $callback): bool

Returns true if all values in this collection pass the truth test provided in the callback.

The callback is passed the value and key of the element being tested and should return true if the test passed.

Example:

$overTwentyOne = (new Collection([24, 45, 60, 15]))->every(function ($value, $key) {
 return $value > 21;
});

Empty collections always return true.

Parameters
callable $callback
Returns
bool

extract() ¶ public

extract(callable|string $path): self

Returns a new collection containing the column or property value found in each of the elements.

The matcher can be a string with a property name to extract or a dot separated path of properties that should be followed to get the last one in the path.

If a column or property could not be found for a particular element in the collection, that position is filled with null.

Example:

Extract the user name for all comments in the array:

$items = [
 ['comment' => ['body' => 'cool', 'user' => ['name' => 'Mark']],
 ['comment' => ['body' => 'very cool', 'user' => ['name' => 'Renan']]
];
$extracted = (new Collection($items))->extract('comment.user.name');

// Result will look like this when converted to array
['Mark', 'Renan']

It is also possible to extract a flattened collection out of nested properties

 $items = [
     ['comment' => ['votes' => [['value' => 1], ['value' => 2], ['value' => 3]]],
     ['comment' => ['votes' => [['value' => 4]]
];
$extracted = (new Collection($items))->extract('comment.votes.{*}.value');

// Result will contain
[1, 2, 3, 4]
Parameters
callable|string $path
Returns
self

filter() ¶ public

filter(callable|null $callback = null): self

Looks through each value in the collection, and returns another collection with all the values that pass a truth test. Only the values for which the callback returns true will be present in the resulting collection.

Each time the callback is executed it will receive the value of the element in the current iteration, the key of the element and this collection as arguments, in that order.

Example:

Filtering odd numbers in an array, at the end only the value 2 will be present in the resulting collection:

$collection = (new Collection([1, 2, 3]))->filter(function ($value, $key) {
 return $value % 2 === 0;
});
Parameters
callable|null $callback optional
Returns
self

first() ¶ public

first(): mixed

Returns the first result in this collection

Returns
mixed

firstMatch() ¶ public

firstMatch(array $conditions): mixed

Returns the first result matching all the key-value pairs listed in conditions.

Parameters
array $conditions
Returns
mixed

groupBy() ¶ public

groupBy(callable|string $path): self

Splits a collection into sets, grouped by the result of running each value through the callback. If $callback is a string instead of a callable, groups by the property named by $callback on each of the values.

When $callback is a string it should be a property name to extract or a dot separated path of properties that should be followed to get the last one in the path.

Example:

$items = [
 ['id' => 1, 'name' => 'foo', 'parent_id' => 10],
 ['id' => 2, 'name' => 'bar', 'parent_id' => 11],
 ['id' => 3, 'name' => 'baz', 'parent_id' => 10],
];

$group = (new Collection($items))->groupBy('parent_id');

// Or
$group = (new Collection($items))->groupBy(function ($e) {
 return $e['parent_id'];
});

// Result will look like this when converted to array
[
 10 => [
     ['id' => 1, 'name' => 'foo', 'parent_id' => 10],
     ['id' => 3, 'name' => 'baz', 'parent_id' => 10],
 ],
 11 => [
     ['id' => 2, 'name' => 'bar', 'parent_id' => 11],
 ]
];
Parameters
callable|string $path
Returns
self

indexBy() ¶ public

indexBy(callable|string $path): self

Given a list and a callback function that returns a key for each element in the list (or a property name), returns an object with an index of each item. Just like groupBy, but for when you know your keys are unique.

When $callback is a string it should be a property name to extract or a dot separated path of properties that should be followed to get the last one in the path.

Example:

$items = [
 ['id' => 1, 'name' => 'foo'],
 ['id' => 2, 'name' => 'bar'],
 ['id' => 3, 'name' => 'baz'],
];

$indexed = (new Collection($items))->indexBy('id');

// Or
$indexed = (new Collection($items))->indexBy(function ($e) {
 return $e['id'];
});

// Result will look like this when converted to array
[
 1 => ['id' => 1, 'name' => 'foo'],
 3 => ['id' => 3, 'name' => 'baz'],
 2 => ['id' => 2, 'name' => 'bar'],
];
Parameters
callable|string $path
Returns
self

insert() ¶ public

insert(string $path, mixed $values): self

Returns a new collection containing each of the elements found in $values as a property inside the corresponding elements in this collection. The property where the values will be inserted is described by the $path parameter.

The $path can be a string with a property name or a dot separated path of properties that should be followed to get the last one in the path.

If a column or property could not be found for a particular element in the collection as part of the path, the element will be kept unchanged.

Example:

Insert ages into a collection containing users:

$items = [
 ['comment' => ['body' => 'cool', 'user' => ['name' => 'Mark']],
 ['comment' => ['body' => 'awesome', 'user' => ['name' => 'Renan']]
];
$ages = [25, 28];
$inserted = (new Collection($items))->insert('comment.user.age', $ages);

// Result will look like this when converted to array
[
 ['comment' => ['body' => 'cool', 'user' => ['name' => 'Mark', 'age' => 25]],
 ['comment' => ['body' => 'awesome', 'user' => ['name' => 'Renan', 'age' => 28]]
];
Parameters
string $path
mixed $values
Returns
self

isEmpty() ¶ public

isEmpty(): bool

Returns whether there are elements in this collection

Example:

$items [1, 2, 3];
(new Collection($items))->isEmpty(); // false
(new Collection([]))->isEmpty(); // true
Returns
bool

jsonSerialize() ¶ public

jsonSerialize(): array

Returns the data that can be converted to JSON. This returns the same data as toArray() which contains only unique keys.

Part of JsonSerializable interface.

Returns
array

last() ¶ public

last(): mixed

Returns the last result in this collection

Returns
mixed

lazy() ¶ public

lazy(): self

Returns a new collection where any operations chained after it are guaranteed to be run lazily. That is, elements will be yielded one at a time.

A lazy collection can only be iterated once. A second attempt results in an error.

Returns
self

listNested() ¶ public

listNested(string|int $order = 'desc', callable|string $nestingKey = 'children'): self

Returns a new collection with each of the elements of this collection after flattening the tree structure. The tree structure is defined by nesting elements under a key with a known name. It is possible to specify such name by using the '$nestingKey' parameter.

By default all elements in the tree following a Depth First Search will be returned, that is, elements from the top parent to the leaves for each branch.

It is possible to return all elements from bottom to top using a Breadth First Search approach by passing the '$dir' parameter with 'asc'. That is, it will return all elements for the same tree depth first and from bottom to top.

Finally, you can specify to only get a collection with the leaf nodes in the tree structure. You do so by passing 'leaves' in the first argument.

The possible values for the first argument are aliases for the following constants and it is valid to pass those instead of the alias:

  • desc: RecursiveIteratorIterator::SELF_FIRST
  • asc: RecursiveIteratorIterator::CHILD_FIRST
  • leaves: RecursiveIteratorIterator::LEAVES_ONLY

Example:

$collection = new Collection([
 ['id' => 1, 'children' => [['id' => 2, 'children' => [['id' => 3]]]]],
 ['id' => 4, 'children' => [['id' => 5]]]
]);
$flattenedIds = $collection->listNested()->extract('id'); // Yields [1, 2, 3, 4, 5]
Parameters
string|int $order optional
callable|string $nestingKey optional
Returns
self

map() ¶ public

map(callable $callback): self

Returns another collection after modifying each of the values in this one using the provided callable.

Each time the callback is executed it will receive the value of the element in the current iteration, the key of the element and this collection as arguments, in that order.

Example:

Getting a collection of booleans where true indicates if a person is female:

$collection = (new Collection($people))->map(function ($person, $key) {
 return $person->gender === 'female';
});
Parameters
callable $callback
Returns
self

match() ¶ public

match(array $conditions): self

Looks through each value in the list, returning a Collection of all the values that contain all of the key-value pairs listed in $conditions.

Example:

$items = [
 ['comment' => ['body' => 'cool', 'user' => ['name' => 'Mark']],
 ['comment' => ['body' => 'very cool', 'user' => ['name' => 'Renan']],
];

$extracted = (new Collection($items))->match(['user.name' => 'Renan']);

// Result will look like this when converted to array
[
 ['comment' => ['body' => 'very cool', 'user' => ['name' => 'Renan']]]
]
Parameters
array $conditions
Returns
self

max() ¶ public

max(callable|string $path, int $sort = \SORT_NUMERIC): mixed

Returns the top element in this collection after being sorted by a property. Check the sortBy method for information on the callback and $sort parameters

Examples:

// For a collection of employees
$max = $collection->max('age');
$max = $collection->max('user.salary');
$max = $collection->max(function ($e) {
 return $e->get('user')->get('salary');
});

// Display employee name
echo $max->name;
Parameters
callable|string $path
int $sort optional
Returns
mixed

median() ¶ public

median(callable|string|null $path = null): float|int|null

Returns the median of all the values extracted with $path or of this collection.

Example:

$items = [
 ['invoice' => ['total' => 400]],
 ['invoice' => ['total' => 500]]
 ['invoice' => ['total' => 100]]
 ['invoice' => ['total' => 333]]
 ['invoice' => ['total' => 200]]
];

$total = (new Collection($items))->median('invoice.total');

// Total: 333

$total = (new Collection([1, 2, 3, 4]))->median();
// Total: 2.5

The median of an empty set or 0 rows is null. Collections with null values are not considered empty.

Parameters
callable|string|null $path optional
Returns
float|int|null

min() ¶ public

min(callable|string $path, int $sort = \SORT_NUMERIC): mixed

Returns the bottom element in this collection after being sorted by a property. Check the sortBy method for information on the callback and $sort parameters

Examples:

// For a collection of employees
$min = $collection->min('age');
$min = $collection->min('user.salary');
$min = $collection->min(function ($e) {
 return $e->get('user')->get('salary');
});

// Display employee name
echo $min->name;
Parameters
callable|string $path
int $sort optional
Returns
mixed

nest() ¶ public

nest(callable|string $idPath, callable|string $parentPath, string $nestingKey = 'children'): self

Returns a new collection where the values are nested in a tree-like structure based on an id property path and a parent id property path.

Parameters
callable|string $idPath
callable|string $parentPath
string $nestingKey optional
Returns
self

newCollection() ¶ protected

newCollection(mixed ...$args): Cake\Collection\CollectionInterface

Returns a new collection.

Allows classes which use this trait to determine their own type of returned collection interface

Parameters
mixed ...$args

Constructor arguments.

Returns
Cake\Collection\CollectionInterface

optimizeUnwrap() ¶ protected

optimizeUnwrap(): iterable

Unwraps this iterator and returns the simplest traversable that can be used for getting the data out

Returns
iterable

prepend() ¶ public

prepend(mixed $items): self

Prepend a set of items to a collection creating a new collection

Parameters
mixed $items
Returns
self

prependItem() ¶ public

prependItem(mixed $item, mixed $key = null): self

Prepend a single item creating a new collection.

Parameters
mixed $item
mixed $key optional
Returns
self

reduce() ¶ public

reduce(callable $callback, mixed $initial = null): mixed

Folds the values in this collection to a single value, as the result of applying the callback function to all elements. $zero is the initial state of the reduction, and each successive step of it should be returned by the callback function. If $zero is omitted the first value of the collection will be used in its place and reduction will start from the second item.

Parameters
callable $callback
mixed $initial optional
Returns
mixed

reject() ¶ public

reject(callable $callback): self

Looks through each value in the collection, and returns another collection with all the values that do not pass a truth test. This is the opposite of filter.

Each time the callback is executed it will receive the value of the element in the current iteration, the key of the element and this collection as arguments, in that order.

Example:

Filtering even numbers in an array, at the end only values 1 and 3 will be present in the resulting collection:

$collection = (new Collection([1, 2, 3]))->reject(function ($value, $key) {
 return $value % 2 === 0;
});
Parameters
callable $callback
Returns
self

sample() ¶ public

sample(int $length = 10): self

Returns a new collection with maximum $length random elements from this collection

Parameters
int $length optional
Returns
self

serialize() ¶ public

serialize(): string

Returns a string representation of this object that can be used to reconstruct it

Returns
string

shuffle() ¶ public

shuffle(): self

Returns a new collection with the elements placed in a random order, this function does not preserve the original keys in the collection.

Returns
self

skip() ¶ public

skip(int $length): self

Returns a new collection that will skip the specified amount of elements at the beginning of the iteration.

Parameters
int $length
Returns
self

some() ¶ public

some(callable $callback): bool

Returns true if any of the values in this collection pass the truth test provided in the callback.

The callback is passed the value and key of the element being tested and should return true if the test passed.

Example:

$hasYoungPeople = (new Collection([24, 45, 15]))->some(function ($value, $key) {
 return $value < 21;
});
Parameters
callable $callback
Returns
bool

sortBy() ¶ public

sortBy(callable|string $path, int $order = \SORT_DESC, int $sort = \SORT_NUMERIC): self

Returns a sorted iterator out of the elements in this collection, ranked based on the results of applying a callback function to each value. The parameter $path can also be a string representing the column or property name.

The callback will receive as its first argument each of the elements in $items, the value returned by the callback will be used as the value for sorting such element. Please note that the callback function could be called more than once per element.

Example:

$items = $collection->sortBy(function ($user) {
 return $user->age;
});

// alternatively
$items = $collection->sortBy('age');

// or use a property path
$items = $collection->sortBy('department.name');

// output all user name order by their age in descending order
foreach ($items as $user) {
 echo $user->name;
}
Parameters
callable|string $path
int $order optional
int $sort optional
Returns
self

stopWhen() ¶ public

stopWhen(callable|array $condition): self

Creates a new collection that when iterated will stop yielding results if the provided condition evaluates to true.

This is handy for dealing with infinite iterators or any generator that could start returning invalid elements at a certain point. For example, when reading lines from a file stream you may want to stop the iteration after a certain value is reached.

Example:

Get an array of lines in a CSV file until the timestamp column is less than a date

$lines = (new Collection($fileLines))->stopWhen(function ($value, $key) {
 return (new DateTime($value))->format('Y') < 2012;
})
->toArray();

Get elements until the first unapproved message is found:

$comments = (new Collection($comments))->stopWhen(['is_approved' => false]);
Parameters
callable|array $condition
Returns
self

sumOf() ¶ public

sumOf(callable|string|null $path = null): float|int

Returns the total sum of all the values extracted with $matcher or of this collection.

Example:

$items = [
 ['invoice' => ['total' => 100]],
 ['invoice' => ['total' => 200]],
];

$total = (new Collection($items))->sumOf('invoice.total');

// Total: 300

$total = (new Collection([1, 2, 3]))->sumOf();
// Total: 6
Parameters
callable|string|null $path optional
Returns
float|int

take() ¶ public

take(int $length = 1, int $offset = 0): self

Returns a new collection with maximum $length elements in the internal order this collection was created. If a second parameter is passed, it will determine from what position to start taking elements.

Parameters
int $length optional
int $offset optional
Returns
self

takeLast() ¶ public

takeLast(int $length): self

Returns the last N elements of a collection

Example:

$items = [1, 2, 3, 4, 5];

$last = (new Collection($items))->takeLast(3);

// Result will look like this when converted to array
[3, 4, 5];
Parameters
int $length
Returns
self

through() ¶ public

through(callable $callback): self

Passes this collection through a callable as its first argument. This is useful for decorating the full collection with another object.

Example:

$items = [1, 2, 3];
$decorated = (new Collection($items))->through(function ($collection) {
     return new MyCustomCollection($collection);
});
Parameters
callable $callback
Returns
self

toArray() ¶ public

toArray(bool $keepKeys = true): array

Returns an array representation of the results

Parameters
bool $keepKeys optional
Returns
array

toList() ¶ public

toList(): array

Returns an numerically-indexed array representation of the results. This is equivalent to calling toArray(false)

Returns
array

transpose() ¶ public

transpose(): Cake\Collection\CollectionInterface

Transpose rows and columns into columns and rows

Example:

$items = [
      ['Products', '2012', '2013', '2014'],
      ['Product A', '200', '100', '50'],
      ['Product B', '300', '200', '100'],
      ['Product C', '400', '300', '200'],
]

$transpose = (new Collection($items))->transpose()->toList();

// Returns
// [
//     ['Products', 'Product A', 'Product B', 'Product C'],
//     ['2012', '200', '300', '400'],
//     ['2013', '100', '200', '300'],
//     ['2014', '50', '100', '200'],
// ]
Returns
Cake\Collection\CollectionInterface
Throws
LogicException

unfold() ¶ public

unfold(callable|null $callback = null): self

Creates a new collection where the items are the concatenation of the lists of items generated by the transformer function applied to each item in the original collection.

The transformer function will receive the value and the key for each of the items in the collection, in that order, and it must return an array or a Traversable object that can be concatenated to the final result.

If no transformer function is passed, an "identity" function will be used. This is useful when each of the elements in the source collection are lists of items to be appended one after another.

Example:

$items [[1, 2, 3], [4, 5]];
$unfold = (new Collection($items))->unfold(); // Returns [1, 2, 3, 4, 5]

Using a transformer

$items [1, 2, 3];
$allItems = (new Collection($items))->unfold(function ($page) {
 return $service->fetchPage($page)->toArray();
});
Parameters
callable|null $callback optional
Returns
self

unserialize() ¶ public

unserialize(string $collection): void

Unserializes the passed string and rebuilds the Collection instance

Parameters
string $collection

The serialized collection

Returns
void

unwrap() ¶ public

unwrap(): Traversable

Returns the closest nested iterator that can be safely traversed without losing any possible transformations. This is used mainly to remove empty IteratorIterator wrappers that can only slowdown the iteration process.

Returns
Traversable

zip() ¶ public

zip(iterable $items): self

Combines the elements of this collection with each of the elements of the passed iterables, using their positional index as a reference.

Example:

$collection = new Collection([1, 2]);
$collection->zip([3, 4], [5, 6])->toList(); // returns [[1, 3, 5], [2, 4, 6]]
Parameters
iterable $items
Returns
self

zipWith() ¶ public

zipWith(iterable $items, callable $callback): self

Combines the elements of this collection with each of the elements of the passed iterables, using their positional index as a reference.

The resulting element will be the return value of the $callable function.

Example:

$collection = new Collection([1, 2]);
$zipped = $collection->zipWith([3, 4], [5, 6], function (...$args) {
  return array_sum($args);
});
$zipped->toList(); // returns [9, 12]; [(1 + 3 + 5), (2 + 4 + 6)]
Parameters
iterable $items
callable $callback
Returns
self
OpenHub
Pingping
Linode
  • Business Solutions
  • Showcase
  • Documentation
  • Book
  • API
  • Videos
  • Reporting Security Issues
  • Privacy Policy
  • Logos & Trademarks
  • Community
  • Get Involved
  • Issues (Github)
  • Bakery
  • Featured Resources
  • Training
  • Meetups
  • My CakePHP
  • CakeFest
  • Newsletter
  • Linkedin
  • YouTube
  • Facebook
  • Twitter
  • Mastodon
  • Help & Support
  • Forum
  • Stack Overflow
  • IRC
  • Slack
  • Paid Support

Generated using CakePHP API Docs