Class Hash
Library of array functions for manipulating and extracting data from arrays or 'sets' of data.
Hash provides an improved interface, more consistent and
predictable set of features over Set. While it lacks the spotty
support for pseudo Xpath, its more fully featured dot notation provides
similar features in a more consistent implementation.
Method Summary
- 
          _filter() protected staticCallback function for filtering. 
- 
          _matchToken() protected staticCheck a key against a token. 
- 
          _matches() protected staticChecks whether or not $data matches the attribute patterns 
- 
          _merge() protected staticMerge helper function to reduce duplicated code between merge() and expand(). 
- 
          _simpleOp() protected staticPerform a simple insert/remove operation. 
- 
          _splitConditions() protected staticSplit token conditions 
- 
          _squash() protected staticHelper method for sort() Squashes an array to a single hash so it can be sorted. 
- 
          apply() public staticApply a callback to a set of extracted values using $function. The function will get the extracted values as the first argument.
- 
          check() public staticTest whether or not a given path exists in $data. This method uses the same path syntax as Hash::extract() 
- 
          combine() public staticCreates an associative array using $keyPathas the path to build its keys, and optionally$valuePathas path to get the values. If$valuePathis not specified, all values will be initialized to null (useful for Hash::merge). You can optionally group the values by what is obtained when following the path specified in$groupPath.
- 
          contains() public staticDetermines if one array contains the exact keys and values of another. 
- 
          diff() public staticComputes the difference between two complex arrays. This method differs from the built-in array_diff() in that it will preserve keys and work on multi-dimensional arrays. 
- 
          dimensions() public staticCounts the dimensions of an array. Only considers the dimension of the first element in the array. 
- 
          expand() public staticExpands a flat array to a nested array. 
- 
          extract() public staticGets the values from an array matching the $path expression. The path expression is a dot separated expression, that can contain a set of patterns and expressions: 
- 
          filter() public staticRecursively filters a data set. 
- 
          flatten() public staticCollapses a multi-dimensional array into a single dimension, using a delimited array path for each array element's key, i.e. [['Foo' => ['Bar' => 'Far']]] becomes ['0.Foo.Bar' => 'Far'].) 
- 
          format() public staticReturns a formatted series of values extracted from $data, using$formatas the format and$pathsas the values to extract.
- 
          get() public staticGet a single value specified by $path out of $data. Does not support the full dot notation feature set, but is faster for simple read operations. 
- 
          insert() public staticInsert $values into an array with the given $path. You can use {n}and{s}elements to insert $data multiple times.
- 
          map() public staticMap a callback across all elements in a set. Can be provided a path to only modify slices of the set. 
- 
          maxDimensions() public staticCounts the dimensions of all array elements. Useful for finding the maximum number of dimensions in a mixed array. 
- 
          merge() public staticThis function can be thought of as a hybrid between PHP's array_mergeandarray_merge_recursive.
- 
          mergeDiff() public staticMerges the difference between $data and $compare onto $data. 
- 
          nest() public staticTakes in a flat array and returns a nested array 
- 
          normalize() public staticNormalizes an array, and converts it to a standard format. 
- 
          numeric() public staticChecks to see if all the values in the array are numeric 
- 
          reduce() public staticReduce a set of extracted values using $function.
- 
          remove() public staticRemove data matching $path from the $data array. You can use {n}and{s}to remove multiple elements from $data.
- 
          sort() public staticSorts an array by any value, determined by a Set-compatible path 
Method Detail
_filter() ¶ protected static
_filter(array $var): boolCallback function for filtering.
Parameters
- 
                array$var
- Array to filter. 
Returns
bool_matchToken() ¶ protected static
_matchToken(string $key, string $token): boolCheck a key against a token.
Parameters
- 
                string$key
- The key in the array being searched. 
- 
                string$token
- The token being matched. 
Returns
bool_matches() ¶ protected static
_matches(array|ArrayAccess $data, string $selector): boolChecks whether or not $data matches the attribute patterns
Parameters
- 
                array|ArrayAccess$data
- Array of data to match. 
- 
                string$selector
- The patterns to match. 
Returns
boolFitness of expression.
_merge() ¶ protected static
_merge(array $stack, array $return): voidMerge helper function to reduce duplicated code between merge() and expand().
Parameters
- 
                array$stack
- The stack of operations to work with. 
- 
                array$return
- The return value to operate on. 
Returns
void_simpleOp() ¶ protected static
_simpleOp(string $op, array $data, array $path, mixed $values = null): arrayPerform a simple insert/remove operation.
Parameters
- 
                string$op
- The operation to do. 
- 
                array$data
- The data to operate on. 
- 
                array$path
- The path to work on. 
- 
                mixed$values optional
- The values to insert when doing inserts. 
Returns
arraydata.
_splitConditions() ¶ protected static
_splitConditions(string $token): arraySplit token conditions
Parameters
- 
                string$token
- the token being splitted. 
Returns
array[token, conditions] with token splitted
_squash() ¶ protected static
_squash(array $data, string|null $key = null): arrayHelper method for sort() Squashes an array to a single hash so it can be sorted.
Parameters
- 
                array$data
- The data to squash. 
- 
                string|null$key optional
- The key for the data. 
Returns
arrayapply() ¶ public static
apply(array $data, string $path, callable $function): mixedApply a callback to a set of extracted values using $function.
The function will get the extracted values as the first argument.
Example
You can easily count the results of an extract using apply(). For example to count the comments on an Article:
$count = Hash::apply($data, 'Article.Comment.{n}', 'count');You could also use a function like array_sum to sum the results.
$total = Hash::apply($data, '{n}.Item.price', 'array_sum');Parameters
- 
                array$data
- The data to reduce. 
- 
                string$path
- The path to extract from $data. 
- 
                callable$function
- The function to call on each extracted value. 
Returns
mixedThe results of the applied method.
check() ¶ public static
check(array $data, string $path): boolTest whether or not a given path exists in $data. This method uses the same path syntax as Hash::extract()
Checking for paths that could target more than one element will make sure that at least one matching element exists.
Parameters
- 
                array$data
- The data to check. 
- 
                string$path
- The path to check for. 
Returns
boolExistence of path.
See Also
Links
combine() ¶ public static
combine(array $data, string $keyPath, string|null $valuePath = null, string|null $groupPath = null): arrayCreates an associative array using $keyPath as the path to build its keys, and optionally
$valuePath as path to get the values. If $valuePath is not specified, all values will be initialized
to null (useful for Hash::merge). You can optionally group the values by what is obtained when
following the path specified in $groupPath.
Parameters
- 
                array$data
- Array from where to extract keys and values 
- 
                string$keyPath
- A dot-separated string. 
- 
                string|null$valuePath optional
- A dot-separated string. 
- 
                string|null$groupPath optional
- A dot-separated string. 
Returns
arrayCombined array
Throws
RuntimeExceptionWhen keys and values count is unequal.
Links
contains() ¶ public static
contains(array $data, array $needle): boolDetermines if one array contains the exact keys and values of another.
Parameters
- 
                array$data
- The data to search through. 
- 
                array$needle
- The values to file in $data 
Returns
booltrue If $data contains $needle, false otherwise
Links
diff() ¶ public static
diff(array $data, array $compare): arrayComputes the difference between two complex arrays. This method differs from the built-in array_diff() in that it will preserve keys and work on multi-dimensional arrays.
Parameters
- 
                array$data
- First value 
- 
                array$compare
- Second value 
Returns
arrayReturns the key => value pairs that are not common in $data and $compare The expression for this function is ($data - $compare) + ($compare - ($data - $compare))
Links
dimensions() ¶ public static
dimensions(array $data): intCounts the dimensions of an array. Only considers the dimension of the first element in the array.
If you have an un-even or heterogenous array, consider using Hash::maxDimensions() to get the dimensions of the array.
Parameters
- 
                array$data
- Array to count dimensions on 
Returns
intThe number of dimensions in $data
Links
expand() ¶ public static
expand(array $data, string $separator = '.'): arrayExpands a flat array to a nested array.
For example, unflattens an array that was collapsed with Hash::flatten()
into a multi-dimensional array. So, ['0.Foo.Bar' => 'Far'] becomes
[['Foo' => ['Bar' => 'Far']]].
Parameters
- 
                array$data
- Flattened array 
- 
                string$separator optional
- The delimiter used 
Returns
arrayLinks
extract() ¶ public static
extract(array|ArrayAccess $data, string $path): arrayGets the values from an array matching the $path expression. The path expression is a dot separated expression, that can contain a set of patterns and expressions:
- {n}Matches any numeric key, or integer.
- {s}Matches any string key.
- {*}Matches any value.
- FooMatches any key with the exact same value.
There are a number of attribute operators:
- =,- !=Equality.- >,- <,- >=,- <=Value comparison.
- =/.../Regular expression pattern match.
 
Given a set of User array data, from a $User->find('all') call:
- 1.User.nameGet the name of the user at index 1.
- {n}.User.nameGet the name of every user in the set of users.
- {n}.User[id]Get the name of every user with an id key.
- {n}.User[id>=2]Get the name of every user with an id key greater than or equal to 2.
- {n}.User[username=/^paul/]Get User elements with username matching- ^paul.
Parameters
- 
                array|ArrayAccess$data
- The data to extract from. 
- 
                string$path
- The path to extract. 
Returns
arrayAn array of the extracted values. Returns an empty array if there are no matches.
Links
filter() ¶ public static
filter(array $data, callable $callback = ['self', '_filter']): arrayRecursively filters a data set.
Parameters
- 
                array$data
- Either an array to filter, or value when in callback 
- 
                callable$callback optional
- A function to filter the data with. Defaults to - static::_filter()Which strips out all non-zero empty values.
Returns
arrayFiltered array
Links
flatten() ¶ public static
flatten(array $data, string $separator = '.'): arrayCollapses a multi-dimensional array into a single dimension, using a delimited array path for each array element's key, i.e. [['Foo' => ['Bar' => 'Far']]] becomes ['0.Foo.Bar' => 'Far'].)
Parameters
- 
                array$data
- Array to flatten 
- 
                string$separator optional
- String used to separate array key elements in a path, defaults to '.' 
Returns
arrayLinks
format() ¶ public static
format(array $data, array $paths, string $format): array|nullReturns a formatted series of values extracted from $data, using
$format as the format and $paths as the values to extract.
Usage:
$result = Hash::format($users, ['{n}.User.id', '{n}.User.name'], '%s : %s');The $format string can use any format options that vsprintf() and sprintf() do.
Parameters
- 
                array$data
- Source array from which to extract the data 
- 
                array$paths
- An array containing one or more Hash::extract()-style key paths 
- 
                string$format
- Format string into which values will be inserted, see sprintf() 
Returns
array|nullAn array of strings extracted from $path and formatted with $format
See Also
Hash::extract()
Links
get() ¶ public static
get(array|ArrayAccess $data, string|array $path, mixed $default = null): mixedGet a single value specified by $path out of $data. Does not support the full dot notation feature set, but is faster for simple read operations.
Parameters
- 
                array|ArrayAccess$data
- Array of data or object implementing \ArrayAccess interface to operate on. 
- 
                string|array$path
- The path being searched for. Either a dot separated string, or an array of path segments. 
- 
                mixed$default optional
- The return value when the path does not exist 
Returns
mixedThe value fetched from the array, or null.
Throws
InvalidArgumentExceptionLinks
insert() ¶ public static
insert(array $data, string $path, array|null $values = null): arrayInsert $values into an array with the given $path. You can use
{n} and {s} elements to insert $data multiple times.
Parameters
- 
                array$data
- The data to insert into. 
- 
                string$path
- The path to insert at. 
- 
                array|null$values optional
- The values to insert. 
Returns
arrayThe data with $values inserted.
Links
map() ¶ public static
map(array $data, string $path, callable $function): arrayMap a callback across all elements in a set. Can be provided a path to only modify slices of the set.
Parameters
- 
                array$data
- The data to map over, and extract data out of. 
- 
                string$path
- The path to extract for mapping over. 
- 
                callable$function
- The function to call on each extracted value. 
Returns
arrayAn array of the modified values.
Links
maxDimensions() ¶ public static
maxDimensions(array $data): intCounts the dimensions of all array elements. Useful for finding the maximum number of dimensions in a mixed array.
Parameters
- 
                array$data
- Array to count dimensions on 
Returns
intThe maximum number of dimensions in $data
Links
merge() ¶ public static
merge(array $data, mixed $merge): arrayThis function can be thought of as a hybrid between PHP's array_merge and array_merge_recursive.
The difference between this method and the built-in ones, is that if an array key contains another array, then
Hash::merge() will behave in a recursive fashion (unlike array_merge). But it will not act recursively for
keys that contain scalar values (unlike array_merge_recursive).
Note: This function will work with an unlimited amount of arguments and typecasts non-array parameters into arrays.
Parameters
- 
                array$data
- Array to be merged 
- 
                mixed$merge
- Array to merge with. The argument and all trailing arguments will be array cast when merged 
Returns
arrayMerged array
Links
mergeDiff() ¶ public static
mergeDiff(array $data, array $compare): arrayMerges the difference between $data and $compare onto $data.
Parameters
- 
                array$data
- The data to append onto. 
- 
                array$compare
- The data to compare and append onto. 
Returns
arrayThe merged array.
Links
nest() ¶ public static
nest(array $data, array $options = []): arrayTakes in a flat array and returns a nested array
Options:
- childrenThe key name to use in the resultset for children.
- idPathThe path to a key that identifies each entry. Should be compatible with Hash::extract(). Defaults to- {n}.$alias.id
- parentPathThe path to a key that identifies the parent of each entry. Should be compatible with Hash::extract(). Defaults to- {n}.$alias.parent_id
- rootThe id of the desired top-most result.
Parameters
- 
                array$data
- The data to nest. 
- 
                array$options optional
- Options are: 
Returns
arrayof results, nested
Throws
InvalidArgumentExceptionWhen providing invalid data.
See Also
Links
normalize() ¶ public static
normalize(array $data, bool $assoc = true): arrayNormalizes an array, and converts it to a standard format.
Parameters
- 
                array$data
- List to normalize 
- 
                bool$assoc optional
- If true, $data will be converted to an associative array. 
Returns
arrayLinks
numeric() ¶ public static
numeric(array $data): boolChecks to see if all the values in the array are numeric
Parameters
- 
                array$data
- The array to check. 
Returns
booltrue if values are numeric, false otherwise
Links
reduce() ¶ public static
reduce(array $data, string $path, callable $function): mixedReduce a set of extracted values using $function.
Parameters
- 
                array$data
- The data to reduce. 
- 
                string$path
- The path to extract from $data. 
- 
                callable$function
- The function to call on each extracted value. 
Returns
mixedThe reduced value.
Links
remove() ¶ public static
remove(array $data, string $path): arrayRemove data matching $path from the $data array.
You can use {n} and {s} to remove multiple elements
from $data.
Parameters
- 
                array$data
- The data to operate on 
- 
                string$path
- A path expression to use to remove. 
Returns
arrayThe modified array.
Links
sort() ¶ public static
sort(array $data, string $path, string $dir = 'asc', array|string $type = 'regular'): arraySorts an array by any value, determined by a Set-compatible path
Sort directions
- ascSort ascending.
- descSort descending.
Sort types
- regularFor regular sorting (don't change types)
- numericCompare values numerically
- stringCompare values as strings
- naturalCompare items as strings using "natural ordering" in a human friendly way. Will sort foo10 below foo2 as an example.
To do case insensitive sorting, pass the type as an array as follows:
Hash::sort($data, 'some.attribute', 'asc', ['type' => 'regular', 'ignoreCase' => true]);When using the array form, type defaults to 'regular'. The ignoreCase option
defaults to false.
Parameters
- 
                array$data
- An array of data to sort 
- 
                string$path
- A Set-compatible path to the array value 
- 
                string$dir optional
- See directions above. Defaults to 'asc'. 
- 
                array|string$type optional
- See direction types above. Defaults to 'regular'. 
Returns
arraySorted array of data
