Usephul

ArrayMap extends ArrayObject
in package

Iterables

implements Filterable, Stack uses Filler, Filter

Interfaces

Filterable: Interface for iterable objects that can be filtered.
Stack

Constants

FLAG_ARRAY_AS_PROPS = parent::ARRAY_AS_PROPS: Entries can be accessed as properties (read and write).
FLAG_STD_PROP_LIST = parent::STD_PROP_LIST: Properties of the object have their normal functionality when accessed as list (var_dump(), foreach, etc.).

Methods

__construct() : mixed: Construct a new Map.
__serialize() : array<string|int, mixed>
__unserialize() : void
all() : bool: Checks if all elements satisfy a callback function.
any() : bool: Checks if at least one element satisfies a callback function.
changeKeyCase() : static: Changes the case of all keys.
chunk() : array<string|int, mixed>: Split this Map into chunks.
column() : static: Return the values from a single column.
contains() : bool: Checks if a value exists in this Map.
countValues() : mixed: Counts the occurences of each distinct value.
current() : TValue|false: Return the current element in this Map.
diff() : static: Computes the difference of this Map to given iterables.
diffAssoc() : static: Computes the difference of iterables with additional index check.
diffKey() : static: Computes the difference of this Map to **iterables** using keys for comparison.
diffUAssoc() : static: Computes the difference of this Map to given iterables with additional index check which is performed by a user supplied callback function.
diffUKey() : static: Computes the difference of this Map to given iterables using a callback function on the keys for comparison.
end() : TValue|false: Set the internal pointer of this Map to its last element.
fill() : static: Fill an ArrayObject with values.
fillKeys() : static: Fill a Map with values, specifying keys.
filter() : static: Filters elements using a callback function.
find() : TValue|null: Returns the first element satisfying a callback function.
findKey() : TKey|null: Returns the key of the first element satisfying a callback function.
firstKey() : (array-key)|null: Gets the first key of this Map.
flip() : mixed: Exchanges all keys with their associated values.
intersect() : static: Computes the intersection of this Map with given arrays.
intersectAssoc() : static: Computes the intersection of this Map with given iterables with additional index check.
isList() : bool: Checks whether this Map is a list.
key() : TKey|null: Fetch a key from this {@see Map}.
keyExists() : bool: Checks if the given key or index exists in this Map.
keys() : static: Return all the keys or a subset of the keys of this Map.
lastKey() : (array-key)|null: Gets the last key of this Map.
list() : void
map() : static: Applies the callback to the elements of this Map.
merge() : static: Merge one or more iterables into this Map.
pad() : static: Pad this Map to the specified length with a value.
pop() : TValue|null: Pop the element off the end of this {@see Map}.
product() : int|float: Calculate the product of values in this Map.
push() : int: Push one or more elements onto the end of this Map.
rand() : (array-key)|array<string|int, string|int>: Pick one or more random keys out of this Map.
range() : static: Create a Map containing a range of elements.
reduce() : C: Iteratively reduce this Map to a single value using a callback function.
replace() : static: Replaces elements from passed iterables into this Map.
reset() : TValue|null: Set the internal pointer of this Map to its first element.
reverse() : static: Return a new Map with elements in reverse order.
search() : TKey|false: Searches this {@see Map} for a given value and returns the first corresponding key if successful.
shift() : mixed: Shift an element off the beginning of array.
slice() : static: Extract a slice of the array.
splice() : static: Remove a portion of this {@see Map} and replace it with something else.
sum() : int|float: Calculate the sum of values in this Map.
udiff() : static: Computes the difference of this Map to iterables by using a callback function for data comparison.
unshift() : mixed
fromArray() : static: Construct a new Map from an array.
withArray() : static: Returns a new Map with the provided elements.

FLAG_ARRAY_AS_PROPS

Entries can be accessed as properties (read and write).


    public
        mixed
    FLAG_ARRAY_AS_PROPS
    = parent::ARRAY_AS_PROPS

The Map class uses its own logic to access properties, thus no warning or error is raised when trying to read or write dynamic properties.

FLAG_STD_PROP_LIST

Properties of the object have their normal functionality when accessed as list (var_dump(), foreach, etc.).


    public
        mixed
    FLAG_STD_PROP_LIST
    = parent::STD_PROP_LIST

__construct()

Construct a new Map.


    public
                    __construct([iterable<TKey, TValue> $array = [] ][, int $flags = 0 ][, ArrayIterator> $iteratorClass = ArrayIterator::class ]) : mixed

This constructs a new Map.

Parameters

$array : iterable<TKey, TValue> = []: The array parameter accepts an array.
$flags : int = 0
$iteratorClass : ArrayIterator> = ArrayIterator::class: Specify the class that will be used for iteration of the Map.

__serialize()


    public
                    __serialize() : array<string|int, mixed>

Return values

array<string|int, mixed>

__unserialize()


    public
                    __unserialize(array<string|int, mixed> $data) : void

Parameters

$data : array<string|int, mixed>

all()

Checks if all elements satisfy a callback function.


    public
                    all(callable(TValue $value, TKey $key): bool $callback) : bool

This method returns true if the given callback returns true for all elements. Otherwise, the method returns false.

Parameters

$callback : callable(TValue $value, TKey $key): bool: The callback function to call to check each element. If callback returns false, false is returned from all() and callback will not be called for further elements.

Return values

bool —

Returns true if callback returns true for all elements. Otherwise, returns false.

any()

Checks if at least one element satisfies a callback function.


    public
                    any(callable(TValue $value, TKey $key): bool $callback) : bool

This method returns true if the given callback returns true for any element. Otherwise, the method returns false.

Parameters

$callback : callable(TValue $value, TKey $key): bool: The callback function to call to check each element. If this function returns true, true is returned from any() and the callback will not be called for further elements.

Return values

bool —

Returns true if there is at least one element for which callback returns true. Otherwise, the method returns false.

changeKeyCase()

Changes the case of all keys.


    public
                    changeKeyCase([KeyCase $case = KeyCase::Lower ]) : static

Returns a Map with all keys lowercased or uppercased. Numbered indices are left as is.

Parameters

$case : KeyCase = KeyCase::Lower: Either KeyCase::Upper or KeyCase::Lower (default)

Return values

static

chunk()

Split this Map into chunks.


    public
                    chunk(positive-int $length[, bool $preserveKeys = false ]) : array<string|int, mixed>

Chunks this Map into Maps with length elements. The last chunk may contain less than length elements.

Parameters

$length : positive-int: The size of each chunk.
$preserveKeys : bool = false: When set to true keys will be preserved. Default is false which will reindex the chunk numerically.

Return values

array<string|int, mixed>

column()

Return the values from a single column.


    public
                    column(int|string|null $columnKey[, int|string|null $indexKey = null ]) : static

ArrayMap::column() returns the values from a single column of this Map, identified by the columnKey. Optionally, an indexKey may be provided to index the values in the returned Map by the values from the indexKey column of this Map.

Parameters

$columnKey : int|string|null: The column of values to return. This value may be an integer key of the column you wish to retrieve, or it may be a string key name. It may also be null to return complete Maps (this is useful together with indexKey to reindex the Map).
$indexKey : int|string|null = null: The column to use as the index/keys for the returned Map. The value is cast as usual for Map keys.

Return values

static —

Returns a new Map of values representing a single column from this Map.

contains()

Checks if a value exists in this Map.


    public
                    contains(mixed $needle[, bool $strict = false ]) : bool

Searches for needle in this Map using loose comparison unless strict is set.

Parameters

$needle : mixed: The searched value.

Note:

If needle is a string, the comparison is done in a case-sensitive manner.
$strict : bool = false: If the third parameter strict is set to true then the ArrayMap::contains() function will also check the types of the needle in this Map.

Return values

bool —

Returns true if needle is found in this Map, false otherwise.

countValues()

Counts the occurences of each distinct value.


    public
                    countValues() : mixed

ArrayMap::countValues() returns a new Map using the values of this Map (which must be ints or strings) as keys and their frequency as values.

Return values

mixed —

Returns a new Map with values from this Map as keys and their count as value.

current()

Return the current element in this Map.


    public
                    current() : TValue|false

Every Map has an internal pointer to its "current" element, which is initialized to the first element inserted into the Map.

Return values

TValue|false —

The ArrayMap::current() function simply returns the value of the Map element that's currently being pointed to by the internal pointer. It does not move the pointer in any way. If the internal pointer points beyond the end of the elements list or this Map is empty, ArrayMap::current() returns false.

Warning This function may return Boolean false, but may also return a non-Boolean value which evaluates to false. Please read the section on Booleans for more information. Use the === operator for testing the return value of this function.

diff()

Computes the difference of this Map to given iterables.


    public
                    diff(iterable<string|int, mixed> ...$iterables) : static

Compares this Map against one or more iterables and returns the values in this Map that are not present in any of the iterables.

Parameters

$iterables : iterable<string|int, mixed>: Iterab;es to compare against.

Return values

static

diffAssoc()

Computes the difference of iterables with additional index check.


    public
                    diffAssoc(iterable<string|int, mixed> ...$iterables) : static

Compares this Map against iterables and returns the difference. Unlike ArrayMap::diff() the iterables keys are also used in the comparison.

Parameters

$iterables : iterable<string|int, mixed>: Iterables to compare against.

Return values

static

diffKey()

Computes the difference of this Map to **iterables** using keys for comparison.


    public
                    diffKey(iterable<string|int, mixed> ...$iterables) : static

Compares the keys from this Map against the keys from iterables and returns the difference. This method is like ArrayMap::diff() except the comparison is done on the keys instead of the values.

Parameters

$iterables : iterable<string|int, mixed>: Iterables to compare against.

Return values

static

diffUAssoc()

Computes the difference of this Map to given iterables with additional index check which is performed by a user supplied callback function.


    public
                    diffUAssoc(callable(TKey $a, K $b): int $keyCompareFunc, iterable<K, V> ...$iterables) : static

Compares this Map against iterables and returns the difference. Unlike ArrayMap::diff() the iterable keys are used in the comparison.

Unlike ArrayMap::diffAssoc() a user supplied callback function is used for the indices comparison, not internal function.

Parameters

$keyCompareFunc : callable(TKey $a, K $b): int: The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.

Caution Returning non-integer values from the comparison function, such as float, will result in an internal cast to int of the callback's return value. So values such as 0.99 and 0.1 will both be cast to an integer value of 0, which will compare such values as equal.
$iterables : iterable<K, V>: Iterables to compare against.

Return values

static

diffUKey()

Computes the difference of this Map to given iterables using a callback function on the keys for comparison.


    public
                    diffUKey(callable(TKey $a, K $b): int $keyCompareFunc, iterable<K, V> ...$iterables) : static

Compares the keys from this Map against the keys from iterables and returns the difference. This method is like ArrayMap::diff() except the comparison is done on the keys instead of the values.

Unlike ArrayMap::diffKey() a user supplied callback function is used for the indices comparison, not internal function.

Parameters

$keyCompareFunc : callable(TKey $a, K $b): int: The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.

Caution Returning non-integer values from the comparison function, such as float, will result in an internal cast to int of the callback's return value. So values such as 0.99 and 0.1 will both be cast to an integer value of 0, which will compare such values as equal.
$iterables : iterable<K, V>: Iterables to compare against.

Return values

static

end()

Set the internal pointer of this Map to its last element.


    public
                    end() : TValue|false

ArrayMap::end() advances this Map's internal pointer to the last element, and returns its value.

Return values

TValue|false —

Returns the value of the last element or false for empty Map.

fill()

Fill an ArrayObject with values.


    public
            static        fill(int $startIndex, int $count, V $value) : static

Fills a static with count entries of the value of the value parameter, keys starting at the startIndex parameter.

Parameters

$startIndex : int: The first index of the returned static.
$count : int
$value : V: Value to use for filling.

Return values

static

fillKeys()

Fill a Map with values, specifying keys.


    public
            static        fillKeys(iterable<string|int, K> $keys, V $value) : static

Fills a ArrayMap with the value of the value parameter, using the values of the keys iterable as keys.

Parameters

$keys : iterable<string|int, K>: Iterable of values that will be used as keys. Illegal values for key will be converted to string.
$value : V: Value to use for filling.

Return values

static

filter()

Filters elements using a callback function.


    public
                    filter([null|mixed $callback = null ][, FilterMode $mode = FilterMode::UseValue ]) : static

Iterates over each element's value, passing them to the callback function. If the callback function returns true, the value is returned into the result.

Keys are preserved.

Parameters

$callback : null|mixed = null: The callback function to use.

If no callback is supplied, all elements with empty values will be removed.
$mode : FilterMode = FilterMode::UseValue: Flag determining what arguments are sent to callback:

Return values

static

find()

Returns the first element satisfying a callback function.


    public
                    find(callable(TValue $value, TKey $key): bool $callback) : TValue|null

This method returns the value of the first element for which the given callback returns true. If no matching element is found the function returns null.

Parameters

$callback : callable(TValue $value, TKey $key): bool: The callback function to call to check each element.

If this function returns true, the value is returned from find() and the callback will not be called for further elements.

Return values

TValue|null —

Returns the value of the first element for which the callback returns true. If no matching element is found null is returned.

findKey()

Returns the key of the first element satisfying a callback function.


    public
                    findKey(callable(TValue $value, TKey $key): bool $callback) : TKey|null

This method returns the key of the first element for which the given callback returns true. If no matching element is found the function returns null.

Parameters

$callback : callable(TValue $value, TKey $key): bool: The callback function to call to check each element.

If this function returns true, the key is returned from findKey() and the callback will not be called for further elements.

Return values

TKey|null —

Returns the key of the first element for which the callback returns true. If no matching element is found null is returned.

firstKey()

Gets the first key of this Map.


    public
                    firstKey() : (array-key)|null

Get the first key of this Map without affecting the internal pointer.

Return values

(array-key)|null —

Returns the first key of this Map if it's not empty; null otherwise.

flip()

Exchanges all keys with their associated values.


    public
                    flip() : mixed

ArrayMap::flip() returns a new Map in flip order, i.e. keys from this Map become values and values from this Map become keys.

Note that the values of this Map need to be valid keys, i.e. they need to be either int or string. A warning will be emitted if a value has the wrong type, and the key/value pair in question will not be included in the result.

If a value has several occurrences, the latest key will be used as its value, and all others will be lost.

Return values

mixed —

Returns the flipped array.

intersect()

Computes the intersection of this Map with given arrays.


    public
                    intersect(iterable<string|int, mixed> ...$iterables) : static

ArrayMap::intersect() returns a new Map containing all the values of this Map that are present in all the arguments. Note that keys are preserved.

Parameters

$iterables : iterable<string|int, mixed>: Iterables to compare values against.

Return values

static

intersectAssoc()

Computes the intersection of this Map with given iterables with additional index check.


    public
                    intersectAssoc(iterable<string|int, mixed> ...$iterables) : static

ArrayMap::intersectAssoc() returns a new Map containing all the values of this Map that are present in all the arguments. Note that the keys are also used in the comparison unlike in ArrayMap::intersect().

Parameters

$iterables : iterable<string|int, mixed>: Iterables to compare values against.

Return values

static

isList()

Checks whether this Map is a list.


    public
                    isList() : bool

Determines if this Map is a list. It is considered a list if its keys consist of consecutive numbers from 0 to count($array)-1.

Return values

bool —

Returns true if this Map is a list, false otherwise.

key()

Fetch a key from this {@see Map}.


    public
                    key() : TKey|null

ArrayMap::key() returns the index element of the current Map position.

Return values

TKey|null —

The ArrayMap::key() method simply returns the key of this Map's element that's currently being pointed to by the internal pointer. It does not move the pointer in any way. If the internal pointer points beyond the end of the elements list or this Map is empty, ArrayMap::key() returns null.

keyExists()

Checks if the given key or index exists in this Map.


    public
                    keyExists(TKey $key) : bool

ArrayMap::keyExists() returns true if the given key is set in this Map. key can be any value possible for an array index.

Note:

ArrayMap::keyExists() will search for the keys in the first dimension only. Nested keys in multidimensional Maps will not be found.

Parameters

$key : TKey: Value to check.

Return values

bool —

Returns true on success or false on failure.

keys()

Return all the keys or a subset of the keys of this Map.


    public
                    keys([mixed|null $filterValue = null ][, bool $strict = false ]) : static

ArrayMap::keys() returns the keys, numeric and string, from this Map.

If a filterValue is specified, then only the keys for that value are returned. Otherwise, all the keys from this Map are returned.

Parameters

$filterValue : mixed|null = null: If specified, then only keys containing this value are returned.
$strict : bool = false: Determines if strict comparison (===) should be used during the search.

Return values

static —

Returns a new Map of all the keys in this Map.

lastKey()

Gets the last key of this Map.


    public
                    lastKey() : (array-key)|null

Get the last key of this Map without affecting the internal pointer.

Return values

(array-key)|null —

Returns the last key of this Map if it's not empty; null otherwise.

list()


    public
                    list(mixed ...&$vars) : void

Parameters

$vars : mixed

map()

Applies the callback to the elements of this Map.


    public
                    map(callable(TValue $value): mixed $callback) : static

ArrayMap::map() returns a new Map containing the results of applying the callback to the corresponding value of this Map used as arguments for the callback.

Parameters

$callback : callable(TValue $value): mixed: A callable to run for each element in this Map.

Return values

static —

Returns a new Map containing the results of applying the callback function to the corresponding value of this Map used as arguments for the callback.

The new Map will preserve the keys of this Map.

merge()

Merge one or more iterables into this Map.


    public
                    merge(iterable<K, V> ...$iterables) : static

Merges the elements of one or more iterables into this Map so that the values of one are appended to the end of the previous one.

If the iterables have the same string keys, then the later value for that key will overwrite the previous one. If, however, the iterables contain numeric keys, the later value will not overwrite the original value, but will be appended.

Values in the input iterables with numeric keys will be renumbered with incrementing keys starting from zero in the result Map.

Parameters

$iterables : iterable<K, V>: Variable list of iterables to merge.

Return values

static

pad()

Pad this Map to the specified length with a value.


    public
                    pad(int $length, V $value) : static

ArrayMap::pad() returns a copy of this Map padded to size specified by length with value value. If length is positive then the Map is padded on the right, if it's negative then on the left. If the absolute value of length is less than or equal to the length of this Map then no padding takes place.

Parameters

$length : int: Size of the new Map.
$value : V: Value to pad if this Map is smaller than length.

Return values

static

pop()

Pop the element off the end of this {@see Map}.


    public
                    pop() : TValue|null

ArrayMap::pop() pops and returns the value of the last element of this Map, shortening the Map by one element.

Note:

This function will ArrayMap::reset() the pointer of this Map after use.

Return values

TValue|null —

Returns the value of the last element of this Map. If this Map is empty, null will be returned.

product()

Calculate the product of values in this Map.


    public
                    product() : int|float

ArrayMap::product() returns the product of values in this Map.

Return values

int|float —

Returns the product as an integer or float.

push()

Push one or more elements onto the end of this Map.


    public
                    push(mixed ...$values) : int

ArrayMap::push() treats this Map as a stack, and pushes the passed variables onto the end of it. The length of this Map increases by the number of variables pushed. Has the same effect as:

$array[] = $var;

repeated for each passed value.

Parameters

$values : mixed: The values to push onto the end of the array.

Return values

int —

Returns the new number of elements in the array.

rand()

Pick one or more random keys out of this Map.


    public
                    rand([int $num = 1 ]) : (array-key)|array<string|int, string|int>

Picks one or more random entries out of this Map, and returns the key (or keys) of the random entries.

Caution This function does not generate cryptographically secure values, and must not be used for cryptographic purposes, or purposes that require returned values to be unguessable.

If cryptographically secure randomness is required, the Random\Randomizer may be used with the Random\Engine\Secure engine. For simple use cases, the random_int() and random_bytes() functions provide a convenient and secure API that is backed by the operating system’s CSPRNG.

Parameters

$num : int = 1: Specifies how many entries should be picked. Must be greater than zero, and less than or equal to the length of this Map.

Return values

(array-key)|array<string|int, string|int> —

When picking only one entry, ArrayMap::rand() returns the key for a random entry. Otherwise, an array of keys for the random entries is returned. This is done so that random keys can be picked from the array as well as random values. If multiple keys are returned, they will be returned in the order they were present in the original array.

range()

Create a Map containing a range of elements.


    public
            static        range(V $start, V $end[, int|float $step = 1 ]) : static

If both start and end are strings, and step is int the produced ArrayMap will be a sequence of bytes. Otherwise, the produced ArrayMap will be a sequence of numbers.

The sequence is increasing if start is less than equal to end. Otherwise, the sequence is decreasing.

Parameters

$start : V: First value of the sequence.
$end : V: Last possible value of the sequence.
$step : int|float = 1: step indicates by how much the produced sequence is progressed between values of the sequence.

step may be negative for decreasing sequences.

If step is a float without a fractional part, it is interpreted as int.

Return values

static

reduce()

Iteratively reduce this Map to a single value using a callback function.


    public
                    reduce(
Warning: Array to string conversion in /opt/phpdoc/src/phpDocumentor/Transformer/Writer/Twig/LinkRenderer/CallableAdapter.php on line 70
callable(Array $carry, TValue $item): C $callback[, I $initial = null ]) : C

ArrayMap::reduce() applies iteratively the callback function to the elements of this Map, to reduce it to a single value.

Parameters

$callback : Warning: Array to string conversion in /opt/phpdoc/src/phpDocumentor/Transformer/Writer/Twig/LinkRenderer/CallableAdapter.php on line 70 callable(Array $carry, TValue $item): C

**carry**: Holds the return value of the previous iteration; in the case of the first iteration it instead holds the value of **initial**.
**item**: Holds the value of the current iteration.

$initial : I = null

If the optional initial is available, it will be used at the beginning of the process, or as a final result in case the Map is empty.

Return values

C —

Returns the resulting value.

If this Map is empty and initial is not passed, ArrayMap::reduce() returns null.

replace()

Replaces elements from passed iterables into this Map.


    public
                    replace(iterable<K, V> ...$replacements) : static

ArrayMap::replace() creates a new Map and assigns items into it for each key in each of the provided iterables. If a key appears in multiple input iterables, the value from the right-most input iterable will be used.

ArrayMap::replace() does not process elements items recursively, it replaces the entire value for each key when it does a replacement.

Parameters

$replacements : iterable<K, V>: Iterables from which elements will be extracted. Values from later iterables overwrite the previous values.

Return values

static

reset()

Set the internal pointer of this Map to its first element.


    public
                    reset() : TValue|null

ArrayMap::reset() rewinds this Map's internal pointer to the first element and returns the value of the first array element.

Return values

TValue|null —

Returns the value of the first array element, or false if the array is empty.

Warning This function may return Boolean false, but may also return a non-Boolean value which evaluates to false. Please read the section on Booleans for more information.

reverse()

Return a new Map with elements in reverse order.


    public
                    reverse([bool $preserveKeys = false ]) : static

Takes an input array and returns a new array with the order of the elements reversed.

Parameters

$preserveKeys : bool = false: If set to true numeric keys are preserved. Non-numeric keys are not affected by this setting and will always be preserved.

Return values

static

search()

Searches this {@see Map} for a given value and returns the first corresponding key if successful.


    public
                    search(TValue $needle[, bool $strict = false ]) : TKey|false

Searches for needle in this Map.

Parameters

$needle : TValue: The searched value.

Note:

If needle is a string, the comparison is done in a case-sensitive manner.
$strict : bool = false: If strict is set to true then the ArrayMap::search() function will search for identical elements in this Map. This means it will also perform a strict type comparison of the needle in this Map and objects must be the same instance.

Return values

TKey|false —

Returns the key for needle if it is found in this Map, false otherwise.

If needle is found in this Map more than once, the first matching key is returned. To return the keys for all matching values, use ArrayMap::keys() with the optional filterValue parameter instead.

Warning This function may return Boolean false, but may also return a non-Boolean value which evaluates to false. Please read the section on Booleans for more information. Use the === operator for testing the return value of this function.

shift()

Shift an element off the beginning of array.


    public
                    shift() : mixed

ArrayMap::shift() shifts the first value of this Map off and returns it, shortening this Map by one element and moving everything down. All numerical keys will be modified to start counting from zero while literal keys won't be affected.

Note: This function will reset the pointer of this Map after use.

Return values

mixed —

Returns the shifted value, or null if this Map is empty.

slice()

Extract a slice of the array.


    public
                    slice(int $offset[, int|null $length = null ][, bool $preserveKeys = false ]) : static

ArrayMap::slice() returns the sequence of elements from this Map as specified by the offset and length parameters.

Parameters

$offset : int: If offset is non-negative, the sequence will start at that offset in this Map.

If offset is negative, the sequence will start that far from the end of this Map.

Note:

The offset parameter denotes the position in this Map, not the key.
$length : int|null = null: If length is given and is positive, then the sequence will have up to that many elements in it.

If this Map is shorter than the length, then only the available Map elements will be present.

If length is given and is negative then the sequence will stop that many elements from the end of this Map.

If it is omitted, then the sequence will have everything from offset up until the end of this Map.
$preserveKeys : bool = false: Note:

ArrayMap::slice() will reorder and reset the integer Map indices by default. This behaviour can be changed by setting preserveKeys to true. String keys are always preserved regardless of this parameter

Return values

static

splice()

Remove a portion of this {@see Map} and replace it with something else.


    public
                    splice(int $offset[, int|null $length = null ][, mixed $replacement = [] ]) : static

Removes the elements designated by offset and length from this Map, and replaces them with the elements of replacement, if supplied.

Note:

Numerical keys are not preserved.

Note: If replacement is not an iterable, it will be typecast to one. This may result in unexpected behavior when using an object or null replacement.

Parameters

$offset : int: If offset is positive then the start of the removed portion is at that offset from the beginning of this Map

If offset is negative then the start of the removed portion is at that offset from the end of Map.
$length : int|null = null: If length is omitted, removes everything from offset to the end of this Map.

If length is specified and is positive, then that many elements will be removed.

If length is specified and is negative, then the end of the removed portion will be that many elements from the end of this Map.

If length is specified and is zero, no elements will be removed.

Tip To remove everything from offset to the end of this Map when replacement is also specified, use count($input) for length.
$replacement : mixed = []: If replacement is specified, then the removed elements are replaced with elements from this iterable.

If offset and length are such that nothing is removed, then the elements from replacement are inserted in the place specified by the offset.

Note:

Keys in replacement are not preserved.

If replacement is just one element it is not necessary to put array() or square brackets around it, unless the element is an array itself, an object or null.

Return values

static

sum()

Calculate the sum of values in this Map.


    public
                    sum() : int|float

ArrayMap::sum() returns the sum of values in this Map.

Return values

int|float —

Returns the sum of values as an integer or float; 0 if this Map is empty.

udiff()

Computes the difference of this Map to iterables by using a callback function for data comparison.


    public
                    udiff(
Warning: Array to string conversion in /opt/phpdoc/src/phpDocumentor/Transformer/Writer/Twig/LinkRenderer/CallableAdapter.php on line 70

Warning: Array to string conversion in /opt/phpdoc/src/phpDocumentor/Transformer/Writer/Twig/LinkRenderer/CallableAdapter.php on line 70
callable(Array $a, Array $b): int $valueCompareFunc, iterable<string|int, V> ...$iterables) : static

Computes the difference of this Map to iterables by using a callback function for data comparison. This is unlike ArrayMap::diff() which uses an internal function for comparing the data.

Parameters

$valueCompareFunc : Warning: Array to string conversion in /opt/phpdoc/src/phpDocumentor/Transformer/Writer/Twig/LinkRenderer/CallableAdapter.php on line 70 Warning: Array to string conversion in /opt/phpdoc/src/phpDocumentor/Transformer/Writer/Twig/LinkRenderer/CallableAdapter.php on line 70 callable(Array $a, Array $b): int: The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.

Caution Returning non-integer values from the comparison function, such as float, will result in an internal cast to int of the callback's return value. So values such as 0.99 and 0.1 will both be cast to an integer value of 0, which will compare such values as equal.

Caution The sorting callback must handle any value from either this Map or any iterable in any order, regardless of the order they were originally provided. This is because each individual array is first sorted before being compared against other arrays.
$iterables : iterable<string|int, V>: Iterables to compare against.

Return values

static —

Returns a new Map containing all the values of this Map that are not present in any of the other arguments.

unshift()


    public
                    unshift() : mixed

fromArray()

Construct a new Map from an array.


    protected
            static        fromArray([iterable<K, V> $array = [] ][, int $flags = 0 ][, ArrayIterator> $iteratorClass = ArrayIterator::class ]) : static

This method is primarily provided so classes extending Map have a way to work with their own constructor.

Parameters

$array : iterable<K, V> = []: The array parameter accepts any iterable.
$flags : int = 0
$iteratorClass : ArrayIterator> = ArrayIterator::class: Specify the class that will be used for iteration of the Map object.

Return values

static

withArray()

Returns a new Map with the provided elements.


    protected
        final            withArray(iterable<K, V> $array) : static

The new Map will have the same flags and Iterator Class as this one.

Parameters

$array : iterable<K, V>: The Map elements.

Return values

static

ArrayMap extends ArrayObject in package Iterables implements Filterable, Stack uses Filler, Filter

Tags

Table of Contents

Interfaces

Constants

Methods

Constants

FLAG_ARRAY_AS_PROPS

FLAG_STD_PROP_LIST

Methods

__construct()

Parameters

__serialize()

Return values

__unserialize()

Parameters

all()

Parameters

Return values

any()

Parameters

Return values

changeKeyCase()

Parameters

Return values

chunk()

Parameters

Return values

column()

Parameters

Return values

contains()

Parameters

Return values

countValues()

Return values

current()

Return values

diff()

Parameters

Return values

diffAssoc()

Parameters

Return values

diffKey()

Parameters

Return values

diffUAssoc()

Parameters

Return values

diffUKey()

Parameters

Return values

end()

Return values

fill()

Parameters

Return values

fillKeys()

Parameters

Return values

filter()

Parameters

Return values

find()

Parameters

Return values

findKey()

Parameters

Return values

firstKey()

Return values

flip()

Return values

intersect()

Parameters

Return values

intersectAssoc()

Parameters

Return values

ArrayMap extends ArrayObject
in package

Iterables

implements Filterable, Stack uses Filler, Filter