Trait Illuminate\Support\Traits\EnumeratesValues


					
	public
					static

make<TMakeKey is array-key, TMakeValue>(
	Arrayable<TMakeKey, TMakeValue>|iterable<TMakeKey, TMakeValue>|null $items = [],
): static<TMakeKey, TMakeValue>

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

#


					
	public
					static

wrap<TWrapValue>(iterable<array-key, TWrapValue>|TWrapValue $value): static<array-key, TWrapValue>

Wrap the given value in a collection if applicable.

#


					
	public
					static

unwrap<TUnwrapKey is array-key, TUnwrapValue>(
	array<TUnwrapKey, TUnwrapValue>|static<TUnwrapKey, TUnwrapValue> $value,
): array<TUnwrapKey, TUnwrapValue>

Get the underlying items from the given collection if applicable.

#


					
	public
					static

empty(): static

Create a new instance with no items.

#


					
	public
					static

times<TTimesValue>(int $number, (callable(int): TTimesValue)|null $callback = null): static<int, TTimesValue>

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

#


					
	public

Get the average value of a given key.

#


					
	public

Alias for the "avg" method.

#


					
	public

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

Alias for the "contains" method.

#


					
	public

dd(mixed ...$args): never

Dump the given arguments and terminate execution.

#


					
	public

dump(mixed ...$args): $this

Dump the items.

#


					
	public

each(callable(TValue, TKey): mixed $callback): $this

Execute a callback over each item.

#


					
	public

eachSpread(callable $callback): static

Execute a callback over each nested chunk of items.

#


					
	public

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

Determine if all items pass the given truth test.

#


					
	public

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

Get the first item by the given key value pair.

#


					
	public

value<TValueDefault>(string $key, TValueDefault|(Closure(): TValueDefault) $default = null): TValue|TValueDefault

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

#


					
	public

ensure<TEnsureOfType>(
	class-string<TEnsureOfType>|array<array-key, class-string<TEnsureOfType>>|'string'|'int'|'float'|'bool'|'array'|'null' $type,
): static<TKey, TEnsureOfType>

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

Throws

UnexpectedValueException

#


					
	public

isNotEmpty(): bool

Determine if the collection is not empty.

#


					
	public

mapSpread<TMapSpreadValue>(callable(mixed...): TMapSpreadValue $callback): static<TKey, TMapSpreadValue>

Run a map over each nested chunk of items.

#


					
	public

mapToGroups<TMapToGroupsKey is array-key, TMapToGroupsValue>(
	callable(TValue, TKey): array<TMapToGroupsKey, TMapToGroupsValue> $callback,
): static<TMapToGroupsKey, static<int, TMapToGroupsValue>>

Run a grouping map over the items.

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

#


					
	public

flatMap<TFlatMapKey is array-key, TFlatMapValue>(
	callable(TValue, TKey): (Collection<TFlatMapKey, TFlatMapValue>|array<TFlatMapKey, TFlatMapValue>) $callback,
): static<TFlatMapKey, TFlatMapValue>

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

#


					
	public

mapInto<TMapIntoValue>(class-string<TMapIntoValue> $class): static<TKey, TMapIntoValue>

Map the values into a new class.

#


					
	public

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

Get the min value of a given key.

#


					
	public

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

Get the max value of a given key.

#


					
	public

forPage(int $page, int $perPage): static

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

#


					
	public

partition(
	(callable(TValue, TKey): bool)|TValue|string $key,
	TValue|string|null $operator = null,
	TValue|null $value = null,
): static<int<0, 1>, static<TKey, TValue>>

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

#


					
	public

percentage(callable(TValue, TKey): bool $callback, int $precision = 2): float|null

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

#


					
	public

sum<TReturnType>(
	(callable(TValue): TReturnType)|string|null $callback = null,
): ($callback is callable ? TReturnType : mixed)

Get the sum of the given values.

#


					
	public

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

Apply the callback if the collection is empty.

#


					
	public

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

Apply the callback if the collection is not empty.

#


					
	public

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

Apply the callback unless the collection is empty.

#


					
	public

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

Apply the callback unless the collection is not empty.

#


					
	public

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

Filter items by the given key value pair.

#


					
	public

whereNull(string|null $key = null): static

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

#


					
	public

whereNotNull(string|null $key = null): static

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

#


					
	public

whereStrict(string $key, mixed $value): static

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

#


					
	public

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

Filter items by the given key value pair.

#


					
	public

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

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

#


					
	public

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

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

#


					
	public

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

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

#


					
	public

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

Filter items by the given key value pair.

#


					
	public

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

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

#


					
	public

whereInstanceOf<TWhereInstanceOf>(
	class-string<TWhereInstanceOf>|array<array-key, class-string<TWhereInstanceOf>> $type,
): static<TKey, TWhereInstanceOf>

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

#


					
	public

pipe<TPipeReturnType>(callable($this): TPipeReturnType $callback): TPipeReturnType

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

#


					
	public

pipeInto<TPipeIntoValue>(class-string<TPipeIntoValue> $class): TPipeIntoValue

Pass the collection into a new class.

#


					
	public

pipeThrough(array<callable> $callbacks): mixed

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

#


					
	public

reduce<TReduceInitial, TReduceReturnType>(
	callable(TReduceInitial|TReduceReturnType, TValue, TKey): TReduceReturnType $callback,
	TReduceInitial $initial = null,
): TReduceReturnType

Reduce the collection to a single value.

#


					
	public

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

Reduce the collection to multiple aggregate values.

Throws

UnexpectedValueException

#


					
	public

reduceWithKeys<TReduceWithKeysInitial, TReduceWithKeysReturnType>(
	callable(TReduceWithKeysInitial|TReduceWithKeysReturnType, TValue, TKey): TReduceWithKeysReturnType $callback,
	TReduceWithKeysInitial $initial = null,
): TReduceWithKeysReturnType

Reduce an associative collection to a single value.

#


					
	public

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

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

#


					
	public

tap(callable($this): mixed $callback): $this

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

#


					
	public

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

Return only unique items from the collection array.

#


					
	public

uniqueStrict((callable(TValue, TKey): mixed)|string|null $key = null): static

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

#


					
	public

collect(): Collection<TKey, TValue>

Collect the values into a collection.

#


					
	public

toArray(): array<TKey, mixed>

Get the collection of items as a plain array.

#


					
	public

jsonSerialize(): array<TKey, mixed>

Convert the object into something JSON serializable.

#


					
	public

toJson(int $options = 0): string

Get the collection of items as JSON.

#


					
	public

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

Get a CachingIterator instance.

#


					
	public

__toString(): string

Convert the collection to its string representation.

#


					
	public

escapeWhenCastingToString(bool $escape = true): $this

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

#


					
	public
					static

proxy(string $method): void

Add a method to the list of proxied methods.

#


					
	public

__get(string $key): mixed

Dynamically access collection proxies.

Throws

Exception

#


					
	protected

getArrayableItems(mixed $items): array<TKey, TValue>

Results array of items from Collection or Arrayable.

#


					
	protected

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

Get an operator checker callback.

#


					
	protected

useAsCallable(mixed $value): bool

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

#


					
	protected

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

Get a value retrieving callback.

#


					
	protected

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

Make a function to check an item's equality.

#


					
	protected

negate(Closure $callback): Closure

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

#


					
	protected

identity(): Closure(TValue): TValue

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

#

Properties
`protected`	`bool`	`$escapeWhenCastingToString = false`	#
`protected static`	`array<int, string>`	`$proxies = [ 'average', 'avg', 'contains', 'doesntContain', 'each', 'every', 'filter', 'first', 'flatMap', 'groupBy', 'keyBy', 'last', 'map', 'max', 'min', 'partition', 'percentage', 'reject', 'skipUntil', 'skipWhile', 'some', 'sortBy', 'sortByDesc', 'sum', 'takeUntil', 'takeWhile', 'unique', 'unless', 'until', 'when', ]`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$average`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$avg`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$contains`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$doesntContain`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$each`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$every`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$filter`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$first`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$flatMap`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$groupBy`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$keyBy`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$last`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$map`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$max`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$min`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$partition`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$percentage`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$reject`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$skipUntil`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$skipWhile`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$some`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$sortBy`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$sortByDesc`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$sum`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$takeUntil`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$takeWhile`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$unique`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$unless`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$until`	#
`public readonly`	`HigherOrderCollectionProxy<TKey, TValue>`	`$when`	#

Namespaces

Traits

Trait Illuminate\Support\Traits\EnumeratesValues

`<TKey is array-key, out TValue>`

Throws

Throws

Throws