class Collection implements ArrayAccess, CanBeEscapedWhenCastToString, Enumerable (View source)

Traits

Properties

protected bool $escapeWhenCastingToString

Indicates that the object's string representation should be escaped when __toString is invoked.

from  EnumeratesValues
static protected array<int, string> $proxies

The methods that can be proxied.

from  EnumeratesValues
TValue, static> read-only $average from  EnumeratesValues
TValue, static> read-only $avg from  EnumeratesValues
TValue, static> read-only $contains from  EnumeratesValues
TValue, static> read-only $doesntContain from  EnumeratesValues
TValue, static> read-only $each from  EnumeratesValues
TValue, static> read-only $every from  EnumeratesValues
TValue, static> read-only $filter from  EnumeratesValues
TValue, static> read-only $first from  EnumeratesValues
TValue, static> read-only $flatMap from  EnumeratesValues
TValue, static> read-only $groupBy from  EnumeratesValues
TValue, static> read-only $hasMany from  EnumeratesValues
TValue, static> read-only $hasSole from  EnumeratesValues
TValue, static> read-only $keyBy from  EnumeratesValues
TValue, static> read-only $last from  EnumeratesValues
TValue, static> read-only $map from  EnumeratesValues
TValue, static> read-only $max from  EnumeratesValues
TValue, static> read-only $min from  EnumeratesValues
TValue, static> read-only $partition from  EnumeratesValues
TValue, static> read-only $percentage from  EnumeratesValues
TValue, static> read-only $reject from  EnumeratesValues
TValue, static> read-only $skipUntil from  EnumeratesValues
TValue, static> read-only $skipWhile from  EnumeratesValues
TValue, static> read-only $sole from  EnumeratesValues
TValue, static> read-only $some from  EnumeratesValues
TValue, static> read-only $sortBy from  EnumeratesValues
TValue, static> read-only $sortByDesc from  EnumeratesValues
TValue, static> read-only $sum from  EnumeratesValues
TValue, static> read-only $takeUntil from  EnumeratesValues
TValue, static> read-only $takeWhile from  EnumeratesValues
TValue, static> read-only $unique from  EnumeratesValues
TValue, static> read-only $unless from  EnumeratesValues
TValue, static> read-only $when from  EnumeratesValues
static protected array $macros

The registered string macros.

from  Macroable
protected TValue> $items

The items contained in the collection.

Methods

$this|TWhenReturnType
when(TWhenParameter|TWhenParameter|null $value = null, callable|null $callback = null, callable|null $default = null)

Apply the callback if the given "value" is (or resolves to) truthy.

$this|TUnlessReturnType
unless(TUnlessParameter|TUnlessParameter|null $value = null, callable|null $callback = null, callable|null $default = null)

Apply the callback if the given "value" is (or resolves to) falsy.

static TMakeValue>
make(TMakeValue>|TMakeValue>|null $items = [], ...$args)

Create a new collection instance if the value isn't one already.

static TWrapValue>
wrap(TWrapValue>|TWrapValue $value, ...$args)

Wrap the given value in a collection if applicable.

static TUnwrapValue>
unwrap(TUnwrapValue>|TUnwrapValue> $value)

Get the underlying items from the given collection if applicable.

empty(...$args)

Create a new instance with no items.

static TTimesValue>
times(int $number, callable|null $callback = null, ...$args)

Create a new collection by invoking the callback a given amount of times.

static TValue>
fromJson(string $json, int $depth = 512, int $flags = 0, ...$args)

Create a new collection by decoding a JSON string.

float|int|null
avg(TValue): float|int)|string|null $callback = null)

Get the average value of a given key.

float|int|null
average(TValue): float|int)|string|null $callback = null)

Alias for the "avg" method.

bool
some(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Alias for the "contains" method.

never
dd(mixed ...$args)

Dump the given arguments and terminate execution.

$this
dump(mixed ...$args)

Dump the items.

$this
each(callable $callback)

Execute a callback over each item.

eachSpread(callable $callback)

Execute a callback over each nested chunk of items.

bool
every(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Determine if all items pass the given truth test.

TValue|null
firstWhere(callable|string $key, mixed $operator = null, mixed $value = null)

Get the first item by the given key value pair.

bool
hasMany(TKey): bool|string|null $key = null, mixed $operator = null, mixed $value = null)

Determine if the collection contains multiple items, optionally matching the given criteria.

TValue|TValueDefault
value(string $key, TValueDefault|TValueDefault $default = null)

Get a single key's value from the first matching item in the collection.

TEnsureOfType>
ensure(TEnsureOfType>|TEnsureOfType>>|"string"|"int"|"float"|"bool"|"array"|"null" $type)

Ensure that every item in the collection is of the expected type.

bool
isNotEmpty()

Determine if the collection is not empty.

TMapSpreadValue>
mapSpread(callable $callback)

Run a map over each nested chunk of items.

TMapToGroupsValue>>
mapToGroups(callable $callback)

Run a grouping map over the items.

TFlatMapValue>
flatMap(callable $callback)

Map a collection and flatten the result by a single level.

TMapIntoValue>
mapInto(TMapIntoValue> $class)

Map the values into a new class.

TValue : mixed))
min(TMinResult|string|null $callback = null)

Get the min value of a given key.

TValue : mixed))
max(TMaxResult|string|null $callback = null)

Get the max value of a given key.

forPage(int $page, int $perPage)

"Paginate" the collection by slicing it into a smaller collection.

TValue>>
partition(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Partition the collection into two arrays using the given callback or key.

float|null
percentage(callable $callback, int $precision = 2)

Calculate the percentage of items that pass a given truth test.

TReturnType : mixed))
sum(TReturnType|string|null $callback = null)

Get the sum of the given values.

$this|TWhenEmptyReturnType
whenEmpty(callable $callback, callable|null $default = null)

Apply the callback if the collection is empty.

$this|TWhenNotEmptyReturnType
whenNotEmpty(callable $callback, callable|null $default = null)

Apply the callback if the collection is not empty.

$this|TUnlessEmptyReturnType
unlessEmpty(callable $callback, callable|null $default = null)

Apply the callback unless the collection is empty.

$this|TUnlessNotEmptyReturnType
unlessNotEmpty(callable $callback, callable|null $default = null)

Apply the callback unless the collection is not empty.

where(callable|string $key, mixed $operator = null, mixed $value = null)

Filter items by the given key value pair.

whereNull(string|null $key = null)

Filter items where the value for the given key is null.

whereNotNull(string|null $key = null)

Filter items where the value for the given key is not null.

whereStrict(string $key, mixed $value)

Filter items by the given key value pair using strict comparison.

whereIn(string $key, Arrayable|iterable $values, bool $strict = false)

Filter items by the given key value pair.

whereInStrict(string $key, Arrayable|iterable $values)

Filter items by the given key value pair using strict comparison.

whereBetween(string $key, Arrayable|iterable $values)

Filter items such that the value of the given key is between the given values.

whereNotBetween(string $key, Arrayable|iterable $values)

Filter items such that the value of the given key is not between the given values.

whereNotIn(string $key, Arrayable|iterable $values, bool $strict = false)

Filter items by the given key value pair.

whereNotInStrict(string $key, Arrayable|iterable $values)

Filter items by the given key value pair using strict comparison.

TWhereInstanceOf>
whereInstanceOf(TWhereInstanceOf>|TWhereInstanceOf>> $type)

Filter the items, removing any items that don't match the given type(s).

TPipeReturnType
pipe(callable $callback)

Pass the collection to the given callback and return the result.

TPipeIntoValue
pipeInto(TPipeIntoValue> $class)

Pass the collection into a new class.

mixed
pipeThrough(callable[] $callbacks)

Pass the collection through a series of callable pipes and return the result.

TReduceInitial|TReduceReturnType
reduce(callable $callback, TReduceInitial $initial = null)

Reduce the collection to a single value.

TReduceIntoInitial
reduceInto(TReduceIntoInitial $initial, callable $callback)

Reduce the collection to a single value by mutating an initial value.

array
reduceSpread(callable $callback, mixed ...$initial)

Reduce the collection to multiple aggregate values.

TReduceWithKeysInitial|TReduceWithKeysReturnType
reduceWithKeys(callable $callback, TReduceWithKeysInitial $initial = null)

Reduce an associative collection to a single value.

reject(TKey): bool|bool|TValue $callback = true)

Create a collection of all elements that do not pass a given truth test.

TValue>>
chunkBy(TKey): mixed|string $key)

Chunk the collection into chunks by comparing adjacent values using the given key or callback.

$this
tap(callable $callback)

Pass the collection to the given callback and then return it.

unique(TKey): mixed|string|null $key = null, bool $strict = false)

Return only unique items from the collection array.

uniqueStrict(TKey): mixed|string|null $key = null)

Return only unique items from the collection array using strict comparison.

TValue>
collect()

Collect the values into a collection.

TKey, mixed>
toArray()

Get the collection of items as a plain array.

array
jsonSerialize()

Convert the object into something JSON serializable.

string
toJson(int $options = 0)

Get the collection of items as JSON.

string
toPrettyJson(int $options = 0)

Get the collection of items as pretty print formatted JSON.

getCachingIterator(int $flags = CachingIterator::CALL_TOSTRING)

Get a CachingIterator instance.

string
__toString()

Convert the collection to its string representation.

$this
escapeWhenCastingToString(bool $escape = true)

Indicate that the model's string representation should be escaped when __toString is invoked.

static void
proxy(string $method)

Add a method to the list of proxied methods.

mixed
__get(string $key)

Dynamically access collection proxies.

TValue>
getArrayableItems(mixed $items)

Results array of items from Collection or Arrayable.

operatorForWhere(callable|string $key, string|null $operator = null, mixed $value = null)

Get an operator checker callback.

bool
useAsCallable(mixed $value)

Determine if the given value is callable, but not a string.

callable
valueRetriever(callable|string|null $value)

Get a value retrieving callback.

Closure(mixed): bool
equality(mixed $value)

Make a function to check an item's equality.

negate(Closure $callback)

Make a function using another function, by negating its result.

TValue
identity()

Make a function that returns what's passed to it.

static void
macro(string $name, object|callable $macro)

Register a custom macro.

static void
mixin(object $mixin, bool $replace = true)

Mix another object into the class.

static bool
hasMacro(string $name)

Checks if macro is registered.

static void
flushMacros()

Flush the existing macros.

static mixed
__callStatic(string $method, array $parameters)

Dynamically handle calls to the class.

mixed
__call(string $method, array $parameters)

Dynamically handle calls to the class.

toResourceCollection(string|null $resourceClass = null)

Create a new resource collection instance for the given resource.

guessResourceCollection()

Guess the resource collection for the items.

string|null
resolveResourceFromAttribute(string $class)

Get the resource class from the class attribute.

string|null
resolveResourceCollectionFromAttribute(string $class)

Get the resource collection class from the class attribute.

__construct(TValue>|TValue>|null $items = [])

Create a new collection.

newInstance(TValue>|TValue>|null $items = [])

Create a new instance of the collection.

static static<int, int>
range(int $from, int $to, int $step = 1, ...$args)

Create a collection with the given range.

TValue>
all()

Get all of the items in the collection.

TValue>
lazy()

Get a lazy collection for the items in this collection.

float|int|null
median(string|array<array-key, string>|null $key = null)

Get the median of a given key.

array<int, float|int>|null
mode(string|array<array-key, string>|null $key = null)

Get the mode of a given key.

static<int, mixed>
collapse()

Collapse the collection of items into a single array.

static<mixed, mixed>
collapseWithKeys()

Collapse the collection of items into a single array while preserving its keys.

bool
contains(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Determine if an item exists in the collection.

bool
containsStrict(TValue): bool|TValue|(array-key) $key, TValue|null $value = null)

Determine if an item exists, using strict comparison.

bool
doesntContain(mixed $key, mixed $operator = null, mixed $value = null)

Determine if an item is not contained in the collection.

bool
doesntContainStrict(mixed $key, mixed $operator = null, mixed $value = null)

Determine if an item is not contained in the enumerable, using strict comparison.

TValue|TCrossJoinValue>>
crossJoin(TCrossJoinValue>|TCrossJoinValue> ...$lists)

Cross join with the given lists, returning all possible permutations.

diff(TValue>|TValue> $items)

Get the items in the collection that are not present in the given items.

diffUsing(TValue>|TValue> $items, callable $callback)

Get the items in the collection that are not present in the given items, using the callback.

diffAssoc(TValue>|TValue> $items)

Get the items in the collection whose keys and values are not present in the given items.

diffAssocUsing(TValue>|TValue> $items, callable $callback)

Get the items in the collection whose keys and values are not present in the given items, using the callback.

diffKeys(TKey, mixed>|TKey, mixed> $items)

Get the items in the collection whose keys are not present in the given items.

diffKeysUsing(TKey, mixed>|TKey, mixed> $items, callable $callback)

Get the items in the collection whose keys are not present in the given items, using the callback.

duplicates(TValue): bool|string|null $callback = null, bool $strict = false)

Retrieve duplicate items from the collection.

duplicatesStrict(TValue): bool|string|null $callback = null)

Retrieve duplicate items from the collection using strict comparison.

TValue): bool
duplicateComparator(bool $strict)

Get the comparison function to detect duplicates.

except(TKey>|TKey> $keys)

Get all items except for those with the specified keys.

filter(callable|null $callback = null)

Run a filter over each of the items.

TValue|TFirstDefault
first(callable|null $callback = null, TFirstDefault|TFirstDefault $default = null)

Get the first item from the collection passing the given truth test.

static<int, mixed>
flatten(int $depth = INF)

Get a flattened array of the items in the collection.

TKey>
flip()

Flip the items in the collection.

$this
forget(TValue>|TKey>|TKey $keys)

Remove an item from the collection by key.

TValue|TGetDefault
get(TKey $key, TGetDefault|TGetDefault $default = null)

Get an item from the collection by key.

TValue|TGetOrPutValue
getOrPut(mixed $key, TGetOrPutValue|TGetOrPutValue $value)

Get an item from the collection by key or add it to collection if it does not exist.

static<($groupBy is array|TValue)>>
groupBy(TGroupKey|array|string $groupBy, bool $preserveKeys = false)

Group an associative array by a field or using a callback.

static<($keyBy is array|TValue>
keyBy(TNewKey|array|string $keyBy)

Key an associative array by a field or using a callback.

bool
has(TKey|TKey> $key)

Determine if an item exists in the collection by key.

bool
hasAny(mixed $key)

Determine if any of the keys exist in the collection.

string
implode(TKey): mixed|string $value, string|null $glue = null)

Concatenate values of a given key as a string.

intersect(TValue>|TValue> $items)

Intersect the collection with the given items.

intersectUsing(TValue>|TValue> $items, callable $callback)

Intersect the collection with the given items, using the callback.

intersectAssoc(TValue>|TValue> $items)

Intersect the collection with the given items with additional index check.

intersectAssocUsing(TValue>|TValue> $items, callable $callback)

Intersect the collection with the given items with additional index check, using the callback.

intersectByKeys(TKey, mixed>|TKey, mixed> $items)

Intersect the collection with the given items by key.

bool
isEmpty()

Determine if the collection is empty or not.

bool
containsOneItem(callable|null $callback = null) deprecated

Determine if the collection contains exactly one item. If a callback is provided, determine if exactly one item matches the condition.

bool
containsManyItems(callable|null $callback = null) deprecated

Determine if the collection contains multiple items.

string
join(string $glue, string $finalGlue = '')

Join all items from the collection using a string. The final items can use a separate glue string.

TKey>
keys()

Get the keys of the collection items.

TValue|TLastDefault
last(callable|null $callback = null, TLastDefault|TLastDefault $default = null)

Get the last item from the collection.

static<array-key, mixed>
pluck(Closure|string|int|array<array-key, string>|null $value, Closure|string|null $key = null)

Get the values of a given key.

TMapValue>
map(callable $callback)

Run a map over each of the items.

TMapToDictionaryValue>>
mapToDictionary(callable $callback)

Run a dictionary map over the items.

TMapWithKeysValue>
mapWithKeys(callable $callback)

Run an associative map over each of the items.

TValue|TMergeValue>
merge(TMergeValue>|TMergeValue> $items)

Merge the collection with the given items.

TValue|TMergeRecursiveValue>
mergeRecursive(TMergeRecursiveValue>|TMergeRecursiveValue> $items)

Recursively merge the collection with the given items.

multiply(int $multiplier)

Multiply the items in the collection by the multiplier.

TCombineValue>
combine(TCombineValue>|TCombineValue> $values)

Create a collection by using this collection for keys and another for its values.

union(TValue>|TValue> $items)

Union the collection with the given items.

nth(int $step, int $offset = 0)

Create a new collection consisting of every n-th element.

only(TKey>|TKey>|string|null $keys)

Get the items with the specified keys.

select(Enumerable<int, string>|list<string>|string|null $keys)

Select specific values from the items within the collection.

TValue|TValue>)
pop(int $count = 1)

Get and remove the last N items from the collection.

$this
prepend(TValue $value, TKey|null $key = null)

Push an item onto the beginning of the collection.

$this
push(TValue ...$values)

Push one or more items onto the end of the collection.

$this
unshift(TValue ...$values)

Prepend one or more items to the beginning of the collection.

TKey|TValue|TConcatValue>
concat(TConcatValue> $source)

Push all of the given items onto the collection.

TValue|TPullDefault
pull(TKey $key, TPullDefault|TPullDefault $default = null)

Get and remove an item from the collection.

$this
put(TKey $key, TPutValue $value)

Put an item in the collection by key.

TValue>)
random(int|null $number = null, bool $preserveKeys = false)

Get one or a specified number of items randomly from the collection.

replace(TValue>|TValue> $items)

Replace the collection items with the given items.

replaceRecursive(TValue>|TValue> $items)

Recursively replace the collection items with the given items.

reverse()

Reverse items order.

TKey|false
search(TValue|TKey): bool $value, bool $strict = false)

Search the collection for a given value and return the corresponding key if successful.

TValue|null
before(TValue|TKey): bool $value, bool $strict = false)

Get the item before the given item.

TValue|null
after(TValue|TKey): bool $value, bool $strict = false)

Get the item after the given item.

TValue|TValue>)
shift(int<0, max> $count = 1)

Get and remove the first N items from the collection.

shuffle()

Shuffle the items in the collection.

static<int, static>
sliding(int $size = 2, int $step = 1)

Create chunks representing a "sliding window" view of the items in the collection.

skip(int $count)

Skip the first {$count} items.

skipUntil(TValue|TKey): bool $value)

Skip items in the collection until the given condition is met.

skipWhile(TValue|TKey): bool $value)

Skip items in the collection while the given condition is met.

slice(int $offset, int|null $length = null)

Slice the underlying collection array.

static<int, static>
split(int $numberOfGroups)

Split a collection into a certain number of groups.

static<int, static>
splitIn(int $numberOfGroups)

Split a collection into a certain number of groups, and fill the first groups completely.

TValue
sole(TKey): bool|string $key = null, mixed $operator = null, mixed $value = null)

Get the first item in the collection, but only if exactly one item exists. Otherwise, throw an exception.

bool
hasSole(TKey): bool|string|null $key = null, mixed $operator = null, mixed $value = null)

Determine if the collection contains a single item, optionally matching the given criteria.

TValue
firstOrFail(TKey): bool|string|null $key = null, mixed $operator = null, mixed $value = null)

Get the first item in the collection but throw an exception if no matching items exist.

static<int, static>
chunk(int $size, bool $preserveKeys = true)

Chunk the collection into chunks of the given size.

TValue>>
chunkWhile(callable $callback)

Chunk the collection into chunks with a callback.

sort(TValue): int|null|int $callback = null)

Sort through each item with a callback.

sortDesc(SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR)

Sort items in descending order.

sortBy(TValue): mixed|TKey): mixed|string|SortDirection|"asc"|"desc"}>|TKey): mixed|string|int $callback, SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR, bool $descending = false)

Sort the collection using the given callback.

sortByMany(array $comparisons = [], int $options = SORT_REGULAR)

Sort the collection using multiple comparisons.

sortByDesc(TValue): mixed|TKey): mixed|string|SortDirection|"asc"|"desc"}>|TKey): mixed|string|int $callback, SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR)

Sort the collection in descending order using the given callback.

sortKeys(SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR, bool $descending = false)

Sort the collection keys.

sortKeysDesc(SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR)

Sort the collection keys in descending order.

sortKeysUsing(callable $callback)

Sort the collection keys using a callback.

splice(int $offset, int|null $length = null, TValue> $replacement = [])

Splice a portion of the underlying collection array.

take(int $limit)

Take the first or last {$limit} items.

takeUntil(TValue|TKey): bool $value)

Take items in the collection until the given condition is met.

takeWhile(TValue|TKey): bool $value)

Take items in the collection while the given condition is met.

$this
transform(callable $callback)

Transform each item in the collection using a callback.

dot(int $depth = INF)

Flatten a multi-dimensional associative array with dots.

undot()

Convert a flatten "dot" notation array into an expanded array.

TValue>
values()

Reset the keys on the underlying array.

TValue|TZipValue>>
zip(TZipValue>|TZipValue> $items)

Zip the collection together with one or more arrays.

TValue|TPadValue>
pad(int $size, TPadValue $value)

Pad collection to the specified length with a value.

getIterator()

Get an iterator for the items.

int
count()

Count the number of items in the collection.

static<array-key, int>
countBy(TKey): (array-key)|UnitEnum|string|null $countBy = null)

Count the number of items in the collection by a field or using a callback.

$this
add(TValue $item)

Add an item to the collection.

TValue>
toBase()

Get a base Support collection instance from this collection.

bool
offsetExists(TKey $offset)

Determine if an item exists at an offset.

mixed
offsetGet(TKey $offset)

Get an item at a given offset.

void
offsetSet(TKey|null $offset, TValue $value)

Set the item at a given offset.

void
offsetUnset(TKey $offset)

Unset the item at a given offset.

Details

$this|TWhenReturnType when(TWhenParameter|TWhenParameter|null $value = null, callable|null $callback = null, callable|null $default = null)

Apply the callback if the given "value" is (or resolves to) truthy.

Parameters

TWhenParameter|TWhenParameter|null $value
callable|null $callback
callable|null $default

Return Value

$this|TWhenReturnType

$this|TUnlessReturnType unless(TUnlessParameter|TUnlessParameter|null $value = null, callable|null $callback = null, callable|null $default = null)

Apply the callback if the given "value" is (or resolves to) falsy.

Parameters

TUnlessParameter|TUnlessParameter|null $value
callable|null $callback
callable|null $default

Return Value

$this|TUnlessReturnType

static TMakeValue> make(TMakeValue>|TMakeValue>|null $items = [], ...$args)

Create a new collection instance if the value isn't one already.

Parameters

TMakeValue>|TMakeValue>|null $items
...$args

Return Value

TMakeValue>

static TWrapValue> wrap(TWrapValue>|TWrapValue $value, ...$args)

Wrap the given value in a collection if applicable.

Parameters

TWrapValue>|TWrapValue $value
...$args

Return Value

TWrapValue>

static TUnwrapValue> unwrap(TUnwrapValue>|TUnwrapValue> $value)

Get the underlying items from the given collection if applicable.

Parameters

TUnwrapValue>|TUnwrapValue> $value

Return Value

TUnwrapValue>

static EnumeratesValues empty(...$args)

Create a new instance with no items.

Parameters

...$args

Return Value

EnumeratesValues

static TTimesValue> times(int $number, callable|null $callback = null, ...$args)

Create a new collection by invoking the callback a given amount of times.

Parameters

int $number
callable|null $callback
...$args

Return Value

TTimesValue>

static TValue> fromJson(string $json, int $depth = 512, int $flags = 0, ...$args)

Create a new collection by decoding a JSON string.

Parameters

string $json
int $depth
int $flags
...$args

Return Value

TValue>

float|int|null avg(TValue): float|int)|string|null $callback = null)

Get the average value of a given key.

Parameters

TValue): float|int)|string|null $callback

Return Value

float|int|null

float|int|null average(TValue): float|int)|string|null $callback = null)

Alias for the "avg" method.

Parameters

TValue): float|int)|string|null $callback

Return Value

float|int|null

bool some(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Alias for the "contains" method.

Parameters

TKey): bool|TValue|string $key
mixed $operator
mixed $value

Return Value

bool

never dd(mixed ...$args)

Dump the given arguments and terminate execution.

Parameters

mixed ...$args

Return Value

never

$this dump(mixed ...$args)

Dump the items.

Parameters

mixed ...$args

Return Value

$this

$this each(callable $callback)

Execute a callback over each item.

Parameters

callable $callback

Return Value

$this

eachSpread(callable $callback)

Execute a callback over each nested chunk of items.

Parameters

callable $callback

bool every(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Determine if all items pass the given truth test.

Parameters

TKey): bool|TValue|string $key
mixed $operator
mixed $value

Return Value

bool

TValue|null firstWhere(callable|string $key, mixed $operator = null, mixed $value = null)

Get the first item by the given key value pair.

Parameters

callable|string $key
mixed $operator
mixed $value

Return Value

TValue|null

bool hasMany(TKey): bool|string|null $key = null, mixed $operator = null, mixed $value = null)

Determine if the collection contains multiple items, optionally matching the given criteria.

Parameters

TKey): bool|string|null $key
mixed $operator
mixed $value

Return Value

bool

TValue|TValueDefault value(string $key, TValueDefault|TValueDefault $default = null)

Get a single key's value from the first matching item in the collection.

Parameters

string $key
TValueDefault|TValueDefault $default

Return Value

TValue|TValueDefault

TEnsureOfType> ensure(TEnsureOfType>|TEnsureOfType>>|"string"|"int"|"float"|"bool"|"array"|"null" $type)

Ensure that every item in the collection is of the expected type.

Parameters

TEnsureOfType>|TEnsureOfType>>|"string"|"int"|"float"|"bool"|"array"|"null" $type

Return Value

TEnsureOfType>

Exceptions

UnexpectedValueException

bool isNotEmpty()

Determine if the collection is not empty.

Return Value

bool

TMapSpreadValue> mapSpread(callable $callback)

Run a map over each nested chunk of items.

Parameters

callable $callback

Return Value

TMapSpreadValue>

TMapToGroupsValue>> mapToGroups(callable $callback)

Run a grouping map over the items.

The callback should return an associative array with a single key/value pair.

Parameters

callable $callback

Return Value

TMapToGroupsValue>>

TFlatMapValue> flatMap(callable $callback)

Map a collection and flatten the result by a single level.

Parameters

callable $callback

Return Value

TFlatMapValue>

TMapIntoValue> mapInto(TMapIntoValue> $class)

Map the values into a new class.

Parameters

TMapIntoValue> $class

Return Value

TMapIntoValue>

TValue : mixed)) min(TMinResult|string|null $callback = null)

Get the min value of a given key.

Parameters

TMinResult|string|null $callback

Return Value

TValue : mixed))

TValue : mixed)) max(TMaxResult|string|null $callback = null)

Get the max value of a given key.

Parameters

TMaxResult|string|null $callback

Return Value

TValue : mixed))

EnumeratesValues forPage(int $page, int $perPage)

"Paginate" the collection by slicing it into a smaller collection.

Parameters

int $page
int $perPage

Return Value

EnumeratesValues

TValue>> partition(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Partition the collection into two arrays using the given callback or key.

Parameters

TKey): bool|TValue|string $key
mixed $operator
mixed $value

Return Value

TValue>>

float|null percentage(callable $callback, int $precision = 2)

Calculate the percentage of items that pass a given truth test.

Parameters

callable $callback
int $precision

Return Value

float|null

TReturnType : mixed)) sum(TReturnType|string|null $callback = null)

Get the sum of the given values.

Parameters

TReturnType|string|null $callback

Return Value

TReturnType : mixed))

$this|TWhenEmptyReturnType whenEmpty(callable $callback, callable|null $default = null)

Apply the callback if the collection is empty.

Parameters

callable $callback
callable|null $default

Return Value

$this|TWhenEmptyReturnType

$this|TWhenNotEmptyReturnType whenNotEmpty(callable $callback, callable|null $default = null)

Apply the callback if the collection is not empty.

Parameters

callable $callback
callable|null $default

Return Value

$this|TWhenNotEmptyReturnType

$this|TUnlessEmptyReturnType unlessEmpty(callable $callback, callable|null $default = null)

Apply the callback unless the collection is empty.

Parameters

callable $callback
callable|null $default

Return Value

$this|TUnlessEmptyReturnType

$this|TUnlessNotEmptyReturnType unlessNotEmpty(callable $callback, callable|null $default = null)

Apply the callback unless the collection is not empty.

Parameters

callable $callback
callable|null $default

Return Value

$this|TUnlessNotEmptyReturnType

EnumeratesValues where(callable|string $key, mixed $operator = null, mixed $value = null)

Filter items by the given key value pair.

Parameters

callable|string $key
mixed $operator
mixed $value

Return Value

EnumeratesValues

EnumeratesValues whereNull(string|null $key = null)

Filter items where the value for the given key is null.

Parameters

string|null $key

Return Value

EnumeratesValues

EnumeratesValues whereNotNull(string|null $key = null)

Filter items where the value for the given key is not null.

Parameters

string|null $key

Return Value

EnumeratesValues

EnumeratesValues whereStrict(string $key, mixed $value)

Filter items by the given key value pair using strict comparison.

Parameters

string $key
mixed $value

Return Value

EnumeratesValues

EnumeratesValues whereIn(string $key, Arrayable|iterable $values, bool $strict = false)

Filter items by the given key value pair.

Parameters

string $key
Arrayable|iterable $values
bool $strict

Return Value

EnumeratesValues

EnumeratesValues whereInStrict(string $key, Arrayable|iterable $values)

Filter items by the given key value pair using strict comparison.

Parameters

string $key
Arrayable|iterable $values

Return Value

EnumeratesValues

EnumeratesValues whereBetween(string $key, Arrayable|iterable $values)

Filter items such that the value of the given key is between the given values.

Parameters

string $key
Arrayable|iterable $values

Return Value

EnumeratesValues

EnumeratesValues whereNotBetween(string $key, Arrayable|iterable $values)

Filter items such that the value of the given key is not between the given values.

Parameters

string $key
Arrayable|iterable $values

Return Value

EnumeratesValues

EnumeratesValues whereNotIn(string $key, Arrayable|iterable $values, bool $strict = false)

Filter items by the given key value pair.

Parameters

string $key
Arrayable|iterable $values
bool $strict

Return Value

EnumeratesValues

EnumeratesValues whereNotInStrict(string $key, Arrayable|iterable $values)

Filter items by the given key value pair using strict comparison.

Parameters

string $key
Arrayable|iterable $values

Return Value

EnumeratesValues

TWhereInstanceOf> whereInstanceOf(TWhereInstanceOf>|TWhereInstanceOf>> $type)

Filter the items, removing any items that don't match the given type(s).

Parameters

TWhereInstanceOf>|TWhereInstanceOf>> $type

Return Value

TWhereInstanceOf>

TPipeReturnType pipe(callable $callback)

Pass the collection to the given callback and return the result.

Parameters

callable $callback

Return Value

TPipeReturnType

TPipeIntoValue pipeInto(TPipeIntoValue> $class)

Pass the collection into a new class.

Parameters

TPipeIntoValue> $class

Return Value

TPipeIntoValue

mixed pipeThrough(callable[] $callbacks)

Pass the collection through a series of callable pipes and return the result.

Parameters

callable[] $callbacks

Return Value

mixed

TReduceInitial|TReduceReturnType reduce(callable $callback, TReduceInitial $initial = null)

Reduce the collection to a single value.

Parameters

callable $callback
TReduceInitial $initial

Return Value

TReduceInitial|TReduceReturnType

TReduceIntoInitial reduceInto(TReduceIntoInitial $initial, callable $callback)

Reduce the collection to a single value by mutating an initial value.

Parameters

TReduceIntoInitial $initial
callable $callback

Return Value

TReduceIntoInitial

array reduceSpread(callable $callback, mixed ...$initial)

Reduce the collection to multiple aggregate values.

Parameters

callable $callback
mixed ...$initial

Return Value

array

Exceptions

UnexpectedValueException

TReduceWithKeysInitial|TReduceWithKeysReturnType reduceWithKeys(callable $callback, TReduceWithKeysInitial $initial = null)

Reduce an associative collection to a single value.

Parameters

callable $callback
TReduceWithKeysInitial $initial

Return Value

TReduceWithKeysInitial|TReduceWithKeysReturnType

EnumeratesValues reject(TKey): bool|bool|TValue $callback = true)

Create a collection of all elements that do not pass a given truth test.

Parameters

TKey): bool|bool|TValue $callback

Return Value

EnumeratesValues

TValue>> chunkBy(TKey): mixed|string $key)

Chunk the collection into chunks by comparing adjacent values using the given key or callback.

Parameters

TKey): mixed|string $key

Return Value

TValue>>

$this tap(callable $callback)

Pass the collection to the given callback and then return it.

Parameters

callable $callback

Return Value

$this

Enumerable unique(TKey): mixed|string|null $key = null, bool $strict = false)

Return only unique items from the collection array.

Parameters

TKey): mixed|string|null $key
bool $strict

Return Value

Enumerable

EnumeratesValues uniqueStrict(TKey): mixed|string|null $key = null)

Return only unique items from the collection array using strict comparison.

Parameters

TKey): mixed|string|null $key

Return Value

EnumeratesValues

TValue> collect()

Collect the values into a collection.

Return Value

TValue>

TKey, mixed> toArray()

Get the collection of items as a plain array.

Return Value

TKey, mixed>

array jsonSerialize()

Convert the object into something JSON serializable.

Return Value

array

string toJson(int $options = 0)

Get the collection of items as JSON.

Parameters

int $options

Return Value

string

string toPrettyJson(int $options = 0)

Get the collection of items as pretty print formatted JSON.

Parameters

int $options

Return Value

string

CachingIterator getCachingIterator(int $flags = CachingIterator::CALL_TOSTRING)

Get a CachingIterator instance.

Parameters

int $flags

Return Value

CachingIterator

string __toString()

Convert the collection to its string representation.

Return Value

string

$this escapeWhenCastingToString(bool $escape = true)

Indicate that the model's string representation should be escaped when __toString is invoked.

Parameters

bool $escape

Return Value

$this

static void proxy(string $method)

Add a method to the list of proxied methods.

Parameters

string $method

Return Value

void

mixed __get(string $key)

Dynamically access collection proxies.

Parameters

string $key

Return Value

mixed

Exceptions

Exception

protected TValue> getArrayableItems(mixed $items)

Results array of items from Collection or Arrayable.

Parameters

mixed $items

Return Value

TValue>

protected Closure operatorForWhere(callable|string $key, string|null $operator = null, mixed $value = null)

Get an operator checker callback.

Parameters

callable|string $key
string|null $operator
mixed $value

Return Value

Closure

protected bool useAsCallable(mixed $value)

Determine if the given value is callable, but not a string.

Parameters

mixed $value

Return Value

bool

protected callable valueRetriever(callable|string|null $value)

Get a value retrieving callback.

Parameters

callable|string|null $value

Return Value

callable

protected Closure(mixed): bool equality(mixed $value)

Make a function to check an item's equality.

Parameters

mixed $value

Return Value

Closure(mixed): bool

protected Closure negate(Closure $callback)

Make a function using another function, by negating its result.

Parameters

Closure $callback

Return Value

Closure

protected TValue identity()

Make a function that returns what's passed to it.

Return Value

TValue

static void macro(string $name, object|callable $macro)

Register a custom macro.

Parameters

string $name
object|callable $macro

Return Value

void

static void mixin(object $mixin, bool $replace = true)

Mix another object into the class.

Parameters

object $mixin
bool $replace

Return Value

void

Exceptions

ReflectionException

static bool hasMacro(string $name)

Checks if macro is registered.

Parameters

string $name

Return Value

bool

static void flushMacros()

Flush the existing macros.

Return Value

void

static mixed __callStatic(string $method, array $parameters)

Dynamically handle calls to the class.

Parameters

string $method
array $parameters

Return Value

mixed

Exceptions

BadMethodCallException

mixed __call(string $method, array $parameters)

Dynamically handle calls to the class.

Parameters

string $method
array $parameters

Return Value

mixed

Exceptions

BadMethodCallException

ResourceCollection toResourceCollection(string|null $resourceClass = null)

Create a new resource collection instance for the given resource.

Parameters

string|null $resourceClass

Return Value

ResourceCollection

Exceptions

Throwable

protected ResourceCollection guessResourceCollection()

Guess the resource collection for the items.

Return Value

ResourceCollection

Exceptions

Throwable

protected string|null resolveResourceFromAttribute(string $class)

Get the resource class from the class attribute.

Parameters

string $class

Return Value

string|null

protected string|null resolveResourceCollectionFromAttribute(string $class)

Get the resource collection class from the class attribute.

Parameters

string $class

Return Value

string|null

__construct(TValue>|TValue>|null $items = [])

Create a new collection.

Parameters

TValue>|TValue>|null $items

protected Collection newInstance(TValue>|TValue>|null $items = [])

Create a new instance of the collection.

Parameters

TValue>|TValue>|null $items

Return Value

Collection

static static<int, int> range(int $from, int $to, int $step = 1, ...$args)

Create a collection with the given range.

Parameters

int $from
int $to
int $step
...$args

Return Value

static<int, int>

TValue> all()

Get all of the items in the collection.

Return Value

TValue>

TValue> lazy()

Get a lazy collection for the items in this collection.

Return Value

TValue>

float|int|null median(string|array<array-key, string>|null $key = null)

Get the median of a given key.

Parameters

string|array<array-key, string>|null $key

Return Value

float|int|null

array<int, float|int>|null mode(string|array<array-key, string>|null $key = null)

Get the mode of a given key.

Parameters

string|array<array-key, string>|null $key

Return Value

array<int, float|int>|null

static<int, mixed> collapse()

Collapse the collection of items into a single array.

Return Value

static<int, mixed>

static<mixed, mixed> collapseWithKeys()

Collapse the collection of items into a single array while preserving its keys.

Return Value

static<mixed, mixed>

bool contains(TKey): bool|TValue|string $key, mixed $operator = null, mixed $value = null)

Determine if an item exists in the collection.

Parameters

TKey): bool|TValue|string $key
mixed $operator
mixed $value

Return Value

bool

bool containsStrict(TValue): bool|TValue|(array-key) $key, TValue|null $value = null)

Determine if an item exists, using strict comparison.

Parameters

TValue): bool|TValue|(array-key) $key
TValue|null $value

Return Value

bool

bool doesntContain(mixed $key, mixed $operator = null, mixed $value = null)

Determine if an item is not contained in the collection.

Parameters

mixed $key
mixed $operator
mixed $value

Return Value

bool

bool doesntContainStrict(mixed $key, mixed $operator = null, mixed $value = null)

Determine if an item is not contained in the enumerable, using strict comparison.

Parameters

mixed $key
mixed $operator
mixed $value

Return Value

bool

TValue|TCrossJoinValue>> crossJoin(TCrossJoinValue>|TCrossJoinValue> ...$lists)

Cross join with the given lists, returning all possible permutations.

Parameters

TCrossJoinValue>|TCrossJoinValue> ...$lists

Return Value

TValue|TCrossJoinValue>>

Enumerable diff(TValue>|TValue> $items)

Get the items in the collection that are not present in the given items.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable diffUsing(TValue>|TValue> $items, callable $callback)

Get the items in the collection that are not present in the given items, using the callback.

Parameters

TValue>|TValue> $items
callable $callback

Return Value

Enumerable

Enumerable diffAssoc(TValue>|TValue> $items)

Get the items in the collection whose keys and values are not present in the given items.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable diffAssocUsing(TValue>|TValue> $items, callable $callback)

Get the items in the collection whose keys and values are not present in the given items, using the callback.

Parameters

TValue>|TValue> $items
callable $callback

Return Value

Enumerable

Enumerable diffKeys(TKey, mixed>|TKey, mixed> $items)

Get the items in the collection whose keys are not present in the given items.

Parameters

TKey, mixed>|TKey, mixed> $items

Return Value

Enumerable

Enumerable diffKeysUsing(TKey, mixed>|TKey, mixed> $items, callable $callback)

Get the items in the collection whose keys are not present in the given items, using the callback.

Parameters

TKey, mixed>|TKey, mixed> $items
callable $callback

Return Value

Enumerable

Enumerable duplicates(TValue): bool|string|null $callback = null, bool $strict = false)

Retrieve duplicate items from the collection.

Parameters

TValue): bool|string|null $callback
bool $strict

Return Value

Enumerable

Enumerable duplicatesStrict(TValue): bool|string|null $callback = null)

Retrieve duplicate items from the collection using strict comparison.

Parameters

TValue): bool|string|null $callback

Return Value

Enumerable

protected TValue): bool duplicateComparator(bool $strict)

Get the comparison function to detect duplicates.

Parameters

bool $strict

Return Value

TValue): bool

Enumerable except(TKey>|TKey> $keys)

Get all items except for those with the specified keys.

Parameters

TKey>|TKey> $keys

Return Value

Enumerable

Enumerable filter(callable|null $callback = null)

Run a filter over each of the items.

Parameters

callable|null $callback

Return Value

Enumerable

TValue|TFirstDefault first(callable|null $callback = null, TFirstDefault|TFirstDefault $default = null)

Get the first item from the collection passing the given truth test.

Parameters

callable|null $callback
TFirstDefault|TFirstDefault $default

Return Value

TValue|TFirstDefault

static<int, mixed> flatten(int $depth = INF)

Get a flattened array of the items in the collection.

Parameters

int $depth

Return Value

static<int, mixed>

TKey> flip()

Flip the items in the collection.

Return Value

TKey>

$this forget(TValue>|TKey>|TKey $keys)

Remove an item from the collection by key.

Parameters

TValue>|TKey>|TKey $keys

Return Value

$this

TValue|TGetDefault get(TKey $key, TGetDefault|TGetDefault $default = null)

Get an item from the collection by key.

Parameters

TKey $key
TGetDefault|TGetDefault $default

Return Value

TValue|TGetDefault

TValue|TGetOrPutValue getOrPut(mixed $key, TGetOrPutValue|TGetOrPutValue $value)

Get an item from the collection by key or add it to collection if it does not exist.

Parameters

mixed $key
TGetOrPutValue|TGetOrPutValue $value

Return Value

TValue|TGetOrPutValue

static<($groupBy is array|TValue)>> groupBy(TGroupKey|array|string $groupBy, bool $preserveKeys = false)

Group an associative array by a field or using a callback.

Parameters

TGroupKey|array|string $groupBy
bool $preserveKeys

Return Value

static<($groupBy is array|TValue)>>

static<($keyBy is array|TValue> keyBy(TNewKey|array|string $keyBy)

Key an associative array by a field or using a callback.

Parameters

TNewKey|array|string $keyBy

Return Value

static<($keyBy is array|TValue>

bool has(TKey|TKey> $key)

Determine if an item exists in the collection by key.

Parameters

TKey|TKey> $key

Return Value

bool

bool hasAny(mixed $key)

Determine if any of the keys exist in the collection.

Parameters

mixed $key

Return Value

bool

string implode(TKey): mixed|string $value, string|null $glue = null)

Concatenate values of a given key as a string.

Parameters

TKey): mixed|string $value
string|null $glue

Return Value

string

Enumerable intersect(TValue>|TValue> $items)

Intersect the collection with the given items.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable intersectUsing(TValue>|TValue> $items, callable $callback)

Intersect the collection with the given items, using the callback.

Parameters

TValue>|TValue> $items
callable $callback

Return Value

Enumerable

Enumerable intersectAssoc(TValue>|TValue> $items)

Intersect the collection with the given items with additional index check.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable intersectAssocUsing(TValue>|TValue> $items, callable $callback)

Intersect the collection with the given items with additional index check, using the callback.

Parameters

TValue>|TValue> $items
callable $callback

Return Value

Enumerable

Enumerable intersectByKeys(TKey, mixed>|TKey, mixed> $items)

Intersect the collection with the given items by key.

Parameters

TKey, mixed>|TKey, mixed> $items

Return Value

Enumerable

bool isEmpty()

Determine if the collection is empty or not.

Return Value

bool

bool containsOneItem(callable|null $callback = null) deprecated

deprecated 12.49.0 Use the `hasSole()` method instead.

Determine if the collection contains exactly one item. If a callback is provided, determine if exactly one item matches the condition.

Parameters

callable|null $callback

Return Value

bool

bool containsManyItems(callable|null $callback = null) deprecated

deprecated 12.50.0 Use the `hasMany()` method instead.

Determine if the collection contains multiple items.

Parameters

callable|null $callback

Return Value

bool

string join(string $glue, string $finalGlue = '')

Join all items from the collection using a string. The final items can use a separate glue string.

Parameters

string $glue
string $finalGlue

Return Value

string

TKey> keys()

Get the keys of the collection items.

Return Value

TKey>

TValue|TLastDefault last(callable|null $callback = null, TLastDefault|TLastDefault $default = null)

Get the last item from the collection.

Parameters

callable|null $callback
TLastDefault|TLastDefault $default

Return Value

TValue|TLastDefault

static<array-key, mixed> pluck(Closure|string|int|array<array-key, string>|null $value, Closure|string|null $key = null)

Get the values of a given key.

Parameters

Closure|string|int|array<array-key, string>|null $value
Closure|string|null $key

Return Value

static<array-key, mixed>

TMapValue> map(callable $callback)

Run a map over each of the items.

Parameters

callable $callback

Return Value

TMapValue>

TMapToDictionaryValue>> mapToDictionary(callable $callback)

Run a dictionary map over the items.

The callback should return an associative array with a single key/value pair.

Parameters

callable $callback

Return Value

TMapToDictionaryValue>>

TMapWithKeysValue> mapWithKeys(callable $callback)

Run an associative map over each of the items.

The callback should return an associative array with a single key/value pair.

Parameters

callable $callback

Return Value

TMapWithKeysValue>

TValue|TMergeValue> merge(TMergeValue>|TMergeValue> $items)

Merge the collection with the given items.

Parameters

TMergeValue>|TMergeValue> $items

Return Value

TValue|TMergeValue>

TValue|TMergeRecursiveValue> mergeRecursive(TMergeRecursiveValue>|TMergeRecursiveValue> $items)

Recursively merge the collection with the given items.

Parameters

TMergeRecursiveValue>|TMergeRecursiveValue> $items

Return Value

TValue|TMergeRecursiveValue>

Collection multiply(int $multiplier)

Multiply the items in the collection by the multiplier.

Parameters

int $multiplier

Return Value

Collection

TCombineValue> combine(TCombineValue>|TCombineValue> $values)

Create a collection by using this collection for keys and another for its values.

Parameters

TCombineValue>|TCombineValue> $values

Return Value

TCombineValue>

Enumerable union(TValue>|TValue> $items)

Union the collection with the given items.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable nth(int $step, int $offset = 0)

Create a new collection consisting of every n-th element.

Parameters

int $step
int $offset

Return Value

Enumerable

Exceptions

InvalidArgumentException

Enumerable only(TKey>|TKey>|string|null $keys)

Get the items with the specified keys.

Parameters

TKey>|TKey>|string|null $keys

Return Value

Enumerable

Collection select(Enumerable<int, string>|list<string>|string|null $keys)

Select specific values from the items within the collection.

Parameters

Enumerable<int, string>|list<string>|string|null $keys

Return Value

Collection

TValue|TValue>) pop(int $count = 1)

Get and remove the last N items from the collection.

Parameters

int $count

Return Value

TValue|TValue>)

$this prepend(TValue $value, TKey|null $key = null)

Push an item onto the beginning of the collection.

Parameters

TValue $value
TKey|null $key

Return Value

$this

$this push(TValue ...$values)

Push one or more items onto the end of the collection.

Parameters

TValue ...$values

Return Value

$this

$this unshift(TValue ...$values)

Prepend one or more items to the beginning of the collection.

Parameters

TValue ...$values

Return Value

$this

TKey|TValue|TConcatValue> concat(TConcatValue> $source)

Push all of the given items onto the collection.

Parameters

TConcatValue> $source

Return Value

TKey|TValue|TConcatValue>

TValue|TPullDefault pull(TKey $key, TPullDefault|TPullDefault $default = null)

Get and remove an item from the collection.

Parameters

TKey $key
TPullDefault|TPullDefault $default

Return Value

TValue|TPullDefault

$this put(TKey $key, TPutValue $value)

Put an item in the collection by key.

Parameters

TKey $key
TPutValue $value

Return Value

$this

TValue>) random(int|null $number = null, bool $preserveKeys = false)

Get one or a specified number of items randomly from the collection.

Parameters

int|null $number
bool $preserveKeys

Return Value

TValue>)

Exceptions

InvalidArgumentException

Enumerable replace(TValue>|TValue> $items)

Replace the collection items with the given items.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable replaceRecursive(TValue>|TValue> $items)

Recursively replace the collection items with the given items.

Parameters

TValue>|TValue> $items

Return Value

Enumerable

Enumerable reverse()

Reverse items order.

Return Value

Enumerable

Search the collection for a given value and return the corresponding key if successful.

Parameters

TValue|TKey): bool $value
bool $strict

Return Value

TKey|false

TValue|null before(TValue|TKey): bool $value, bool $strict = false)

Get the item before the given item.

Parameters

TValue|TKey): bool $value
bool $strict

Return Value

TValue|null

TValue|null after(TValue|TKey): bool $value, bool $strict = false)

Get the item after the given item.

Parameters

TValue|TKey): bool $value
bool $strict

Return Value

TValue|null

TValue|TValue>) shift(int<0, max> $count = 1)

Get and remove the first N items from the collection.

Parameters

int<0, max> $count

Return Value

TValue|TValue>)

Exceptions

InvalidArgumentException

Enumerable shuffle()

Shuffle the items in the collection.

Return Value

Enumerable

static<int, static> sliding(int $size = 2, int $step = 1)

Create chunks representing a "sliding window" view of the items in the collection.

Parameters

int $size
int $step

Return Value

static<int, static>

Exceptions

InvalidArgumentException

Enumerable skip(int $count)

Skip the first {$count} items.

Parameters

int $count

Return Value

Enumerable

Enumerable skipUntil(TValue|TKey): bool $value)

Skip items in the collection until the given condition is met.

Parameters

TValue|TKey): bool $value

Return Value

Enumerable

Enumerable skipWhile(TValue|TKey): bool $value)

Skip items in the collection while the given condition is met.

Parameters

TValue|TKey): bool $value

Return Value

Enumerable

Enumerable slice(int $offset, int|null $length = null)

Slice the underlying collection array.

Parameters

int $offset
int|null $length

Return Value

Enumerable

static<int, static> split(int $numberOfGroups)

Split a collection into a certain number of groups.

Parameters

int $numberOfGroups

Return Value

static<int, static>

Exceptions

InvalidArgumentException

static<int, static> splitIn(int $numberOfGroups)

Split a collection into a certain number of groups, and fill the first groups completely.

Parameters

int $numberOfGroups

Return Value

static<int, static>

Exceptions

InvalidArgumentException

TValue sole(TKey): bool|string $key = null, mixed $operator = null, mixed $value = null)

Get the first item in the collection, but only if exactly one item exists. Otherwise, throw an exception.

Parameters

TKey): bool|string $key
mixed $operator
mixed $value

Return Value

TValue

Exceptions

ItemNotFoundException
MultipleItemsFoundException

bool hasSole(TKey): bool|string|null $key = null, mixed $operator = null, mixed $value = null)

Determine if the collection contains a single item, optionally matching the given criteria.

Parameters

TKey): bool|string|null $key
mixed $operator
mixed $value

Return Value

bool

TValue firstOrFail(TKey): bool|string|null $key = null, mixed $operator = null, mixed $value = null)

Get the first item in the collection but throw an exception if no matching items exist.

Parameters

TKey): bool|string|null $key
mixed $operator
mixed $value

Return Value

TValue

Exceptions

ItemNotFoundException

static<int, static> chunk(int $size, bool $preserveKeys = true)

Chunk the collection into chunks of the given size.

Parameters

int $size
bool $preserveKeys

Return Value

static<int, static>

TValue>> chunkWhile(callable $callback)

Chunk the collection into chunks with a callback.

Parameters

callable $callback

Return Value

TValue>>

Enumerable sort(TValue): int|null|int $callback = null)

Sort through each item with a callback.

Parameters

TValue): int|null|int $callback

Return Value

Enumerable

Enumerable sortDesc(SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR)

Sort items in descending order.

Parameters

SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options

Return Value

Enumerable

Enumerable sortBy(TValue): mixed|TKey): mixed|string|SortDirection|"asc"|"desc"}>|TKey): mixed|string|int $callback, SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR, bool $descending = false)

Sort the collection using the given callback.

Parameters

TValue): mixed|TKey): mixed|string|SortDirection|"asc"|"desc"}>|TKey): mixed|string|int $callback
SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options
bool $descending

Return Value

Enumerable

protected Collection sortByMany(array $comparisons = [], int $options = SORT_REGULAR)

Sort the collection using multiple comparisons.

Parameters

array $comparisons
int $options

Return Value

Collection

Enumerable sortByDesc(TValue): mixed|TKey): mixed|string|SortDirection|"asc"|"desc"}>|TKey): mixed|string|int $callback, SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR)

Sort the collection in descending order using the given callback.

Parameters

TValue): mixed|TKey): mixed|string|SortDirection|"asc"|"desc"}>|TKey): mixed|string|int $callback
SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options

Return Value

Enumerable

Enumerable sortKeys(SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR, bool $descending = false)

Sort the collection keys.

Parameters

SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options
bool $descending

Return Value

Enumerable

Enumerable sortKeysDesc(SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options = SORT_REGULAR)

Sort the collection keys in descending order.

Parameters

SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_LOCALE_STRING|SORT_NATURAL|SORT_FLAG_CASE> $options

Return Value

Enumerable

Enumerable sortKeysUsing(callable $callback)

Sort the collection keys using a callback.

Parameters

callable $callback

Return Value

Enumerable

Collection splice(int $offset, int|null $length = null, TValue> $replacement = [])

Splice a portion of the underlying collection array.

Parameters

int $offset
int|null $length
TValue> $replacement

Return Value

Collection

Enumerable take(int $limit)

Take the first or last {$limit} items.

Parameters

int $limit

Return Value

Enumerable

Enumerable takeUntil(TValue|TKey): bool $value)

Take items in the collection until the given condition is met.

Parameters

TValue|TKey): bool $value

Return Value

Enumerable

Enumerable takeWhile(TValue|TKey): bool $value)

Take items in the collection while the given condition is met.

Parameters

TValue|TKey): bool $value

Return Value

Enumerable

$this transform(callable $callback)

Transform each item in the collection using a callback.

Parameters

callable $callback

Return Value

$this

Collection dot(int $depth = INF)

Flatten a multi-dimensional associative array with dots.

Parameters

int $depth

Return Value

Collection

Enumerable undot()

Convert a flatten "dot" notation array into an expanded array.

Return Value

Enumerable

TValue> values()

Reset the keys on the underlying array.

Return Value

TValue>

TValue|TZipValue>> zip(TZipValue>|TZipValue> $items)

Zip the collection together with one or more arrays.

e.g. new Collection([1, 2, 3])->zip([4, 5, 6]); => [[1, 4], [2, 5], [3, 6]]

Parameters

TZipValue>|TZipValue> $items

Return Value

TValue|TZipValue>>

TValue|TPadValue> pad(int $size, TPadValue $value)

Pad collection to the specified length with a value.

Parameters

int $size
TPadValue $value

Return Value

TValue|TPadValue>

Traversable getIterator()

Get an iterator for the items.

Return Value

Traversable

int count()

Count the number of items in the collection.

Return Value

int

static<array-key, int> countBy(TKey): (array-key)|UnitEnum|string|null $countBy = null)

Count the number of items in the collection by a field or using a callback.

Parameters

TKey): (array-key)|UnitEnum|string|null $countBy

Return Value

static<array-key, int>

$this add(TValue $item)

Add an item to the collection.

Parameters

TValue $item

Return Value

$this

TValue> toBase()

Get a base Support collection instance from this collection.

Return Value

TValue>

bool offsetExists(TKey $offset)

Determine if an item exists at an offset.

Parameters

TKey $offset

Return Value

bool

mixed offsetGet(TKey $offset)

Get an item at a given offset.

Parameters

TKey $offset

Return Value

mixed

void offsetSet(TKey|null $offset, TValue $value)

Set the item at a given offset.

Parameters

TKey|null $offset
TValue $value

Return Value

void

void offsetUnset(TKey $offset)

Unset the item at a given offset.

Parameters

TKey $offset

Return Value

void