Popularity
4.1
Growing
Activity
7.0
Declining
354
15
27

Description

A PHP array manipulation library. Compatible with PHP 5.3+, PHP 7, and HHVM.

Arrayy::create(['Array', 'Array'])->unique()->append('y')->implode() // Arrayy

Code Quality Rank: L4
Programming language: PHP
License: MIT License
Latest version: v7.8.6

Arrayy alternatives and similar libraries

Based on the "Data Structure and Storage" category.
Alternatively, view Arrayy alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of Arrayy or a related project?

Add another 'Data Structure and Storage' Library

README

Build Status codecov.io Codacy Badge Latest Stable Version Total Downloads License Donate to this project using Paypal Donate to this project using Patreon

馃梼 Arrayy

A PHP array manipulation library. Compatible with PHP 7+ & PHP 8+

\Arrayy\Type\StringCollection::create(['Array', 'Array'])->unique()->append('y')->implode() // Arrayy

documentation via gitbooks.io

Installation via "composer require"

composer require voku/arrayy

Multidimensional ArrayAccess

You can access / change the array via Object, Array or with "Arrayy"-syntax.

Access via "Arrayy"-syntax: (dot-notation)

$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);

$arrayy->get('Lars'); // ['lastname' => 'Moelleken']
$arrayy->get('Lars.lastname'); // 'Moelleken'

Access via "array"-syntax:

$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);

$arrayy['Lars'];             // ['lastname' => 'Moelleken']
$arrayy['Lars']['lastname']; // 'Moelleken'

Access via "object"-syntax:

$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);

$arrayy->Lars; // Arrayy['lastname' => 'Moelleken']
$arrayy->Lars->lastname; // 'Moelleken'

Set values via "Arrayy"-syntax: (dot-notation)

$arrayy = new A(['Lars' => ['lastname' => 'Mueller']]);

$arrayy->set('Lars.lastname', 'Moelleken');
$arrayy->get('Lars.lastname'); // 'Moelleken'

Set values via "array"-syntax:

$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);

$arrayy['Lars'] = array('lastname' => 'M眉ller');
$arrayy['Lars']['lastname']; // 'M眉ller'

Set values via "object"-syntax:

$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);

$arrayy->Lars = array('lastname' => 'M眉ller');
$arrayy->Lars->lastname; // 'M眉ller'

PhpDoc @property checking

The library offers a type checking for @property phpdoc-class-comments, as seen below:

/**
 * @property int        $id
 * @property int|string $firstName
 * @property string     $lastName
 * @property null|City  $city
 *
 * @extends  \Arrayy\Arrayy<array-key,mixed>
 */
class User extends \Arrayy\Arrayy
{
  protected $checkPropertyTypes = true;

  protected $checkPropertiesMismatchInConstructor = true;
}

/**
 * @property string|null $plz
 * @property string      $name
 * @property string[]    $infos
 *
 * @extends  \Arrayy\Arrayy<array-key,mixed>
 */
class City extends \Arrayy\Arrayy
{
    protected $checkPropertyTypes = true;

    protected $checkPropertiesMismatchInConstructor = true;
}

$cityMeta = City::meta();
$city = new City(
    [
        $cityMeta->plz   => null,
        $cityMeta->name  => 'D眉sseldorf',
        $cityMeta->infos => ['lall'],
    ]
);

$userMeta = User::meta();
$user = new User(
    [
        $userMeta->id        => 1,
        $userMeta->firstName => 'Lars',
        $userMeta->lastName  => 'Moelleken',
        $userMeta->city      => $city,
    ]
);

var_dump($user['lastName']); // 'Moelleken'
var_dump($user[$userMeta->lastName]); // 'Moelleken'
var_dump($user->lastName); // Moelleken

var_dump($user['city.name']); // 'D眉sseldorf'
var_dump($user[$userMeta->city][$cityMeta->name]); // 'D眉sseldorf'
var_dump($user->city->name); // D眉sseldorf
  • "checkPropertyTypes": activate the type checking for all defined @property in the class-phpdoc
  • "checkPropertiesMismatchInConstructor": activate the property mismatch check, so you can only add an array with all needed properties (or an empty array) into the constructor

OO and Chaining

The library also offers OO method chaining, as seen below:

echo a(['f貌么', 'b脿艡', 'b脿艡'])->unique()->reverse()->implode(','); // 'b脿艡,f貌么'

Implemented Interfaces

Arrayy\Arrayy implements the IteratorAggregate interface, meaning that foreach can be used with an instance of the class:

$arrayy = a(['f貌么b脿艡', 'foo']);
foreach ($arrayy as $value) {
    echo $value;
}
// 'f貌么b脿艡'
// 'foo'

It implements the Countable interface, enabling the use of count() to retrieve the number of elements in the array:

$arrayy = a(['f貌么', 'foo']);
count($arrayy);  // 2

PHP 5.6 Creation

As of PHP 5.6, use function is available for importing functions. Arrayy exposes a namespaced function, Arrayy\create, which emits the same behaviour as Arrayy\Arrayy::create(). If running PHP 5.6, or another runtime that supports the use function syntax, you can take advantage of an even simpler API as seen below:

use function Arrayy\create as a;

// Instead of: A::create(['f貌么', 'b脿艡'])->reverse()->implode();
a(['f貌么', 'b脿艡'])->reverse()->implode(','); // 'b脿艡,f貌么'

Collections

If you need to group objects together, it's not a good idea to use a simple array or Arrayy object. For these cases you can use the AbstractCollection class.

It will throw a InvalidArgumentException if you try to add a non valid object into the collection.

e.g.: "YOURCollection.php" (see example /tests/CollectionTest.php on github)

use Arrayy\Collection\AbstractCollection;

/**
 * @extends  AbstractCollection<array-key,YOURInterface>
 */
class YOURCollection extends AbstractCollection
{
    /**
     * The type (FQCN) associated with this collection.
     *
     * @return string
     */
    public function getType(): string
    {
        return YOURInterface::class;
    }
}

$YOURobject1 = new YOURClass();
$YOURobject2 = new YOURClass();

$YOURcollection = new YOURCollection($YOURobject1);
$YOURcollection->add($YOURobject2); // add one more object

// Or, you can use an array of objects.
//
// $YOURcollection = new YOURCollection([$YOURobject1, $YOURobject2]);

// Or, if you don't want to create new classes ... 
// ... and you don't need typehints and autocompletion via classes.
//
// $YOURcollection = \Arrayy\Collection::construct(YOURInterface::class, [$YOURobject1]);
// $YOURcollection->add($YOURobject2); // add one more object

// Or, if you don't like classes at all. ;-)
//
// $YOURcollection = \Arrayy\collection(YOURInterface::class, [$YOURobject1]);
// $YOURcollection->add($YOURobject2); // add one more object

foreach ($YOURcollection as $YOURobject) {
    if ($YOURobject instanceof YOURInterface) {
        // Do something with $YOURobject
    }
}

You can also use "dot-notation" to get data from your collections e.g.


## Pre-Defined Typified Collections

### simple example

This will throw a "TypeError"-Exception. 

```php
use Arrayy\Type\StringCollection;

$collection = new StringCollection(['A', 'B', 'C', 1]);

complex example

This will NOT throw a "TypeError"-Exception.

use Arrayy\Type\IntCollection;
use Arrayy\Type\StringCollection;
use Arrayy\Type\InstancesCollection;
use Arrayy\Type\TypeInterface;

$collection = InstancesCollection::construct(
    TypeInterface::class,
    [new StringCollection(['A', 'B', 'C']), new IntCollection([1])]
);

$collection->toArray(true); // [['A', 'B', 'C'], [1]]

Convert JSON-Data into Objects (Collection)


namespace Arrayy\tests\Collection;

use Arrayy\Collection\AbstractCollection;

/**
 * @extends  AbstractCollection<array-key,\Arrayy\tests\UserData>
 */
class UserDataCollection extends AbstractCollection
{
    /**
     * The type (FQCN) associated with this collection.
     *
     * @return string
     */
    public function getType()
    {
        return \Arrayy\tests\UserData::class;
    }
}

$json = '[{"id":1,"firstName":"Lars","lastName":"Moelleken","city":{"name":"D眉sseldorf","plz":null,"infos":["lall"]}}, {"id":1,"firstName":"Sven","lastName":"Moelleken","city":{"name":"K枚ln","plz":null,"infos":["foo"]}}]';
$userDataCollection = UserDataCollection::createFromJsonMapper($json);

/** @var \Arrayy\tests\UserData[] $userDatas */
$userDataCollection->getAll();

$userData0 = $userDataCollection[0];
echo $userData0->firstName; // 'Lars'
$userData0->city; // CityData::class
echo $userData0->city->name; // 'D眉sseldorf'

$userData1 = $userDataCollection[1];
echo $userData1->firstName; // 'Sven'
$userData1->city; // CityData::class
echo $userData1->city->name; // 'K枚ln'

Class methods

use a "default object"

Creates an Arrayy object.

$arrayy = new Arrayy(array('f貌么', 'b脿艡')); // Arrayy['f貌么', 'b脿艡']
create(array $array) : Arrayy (Immutable)

Creates an Arrayy object, via static "create()"-method

$arrayy = A::create(array('f貌么', 'b脿艡')); // Arrayy['f貌么', 'b脿艡']
createByReference(array &$array) : Arrayy (Mutable)

WARNING: Creates an Arrayy object by reference.

$array = array('f貌么', 'b脿艡');
$arrayy = A::createByReference($array); // Arrayy['f貌么', 'b脿艡']
createFromJson(string $json) : Arrayy (Immutable)

Create an new Arrayy object via JSON.

$str = '{"firstName":"John", "lastName":"Doe"}';
$arrayy = A::createFromJson($str); // Arrayy['firstName' => 'John', 'lastName' => 'Doe']
createFromJsonMapper(string $json) : Arrayy (Immutable)

Create an new Arrayy object via JSON and fill sub-objects is possible.

<?php

namespace Arrayy\tests;

/**
 * @property int                         $id
 * @property int|string                  $firstName
 * @property string                      $lastName
 * @property \Arrayy\tests\CityData|null $city
 *
 * @extends  \Arrayy\Arrayy<array-key,mixed>
 */
class UserData extends \Arrayy\Arrayy
{
    protected $checkPropertyTypes = true;

    protected $checkForMissingPropertiesInConstructor = true;
}

/**
 * @property string|null $plz
 * @property string      $name
 * @property string[]    $infos
 *
 * @extends  \Arrayy\Arrayy<array-key,mixed>
 */
class CityData extends \Arrayy\Arrayy
{
    protected $checkPropertyTypes = true;

    protected $checkPropertiesMismatchInConstructor = true;

    protected $checkForMissingPropertiesInConstructor = true;

    protected $checkPropertiesMismatch = true;
}

$json = '{"id":1,"firstName":"Lars","lastName":"Moelleken","city":{"name":"D眉sseldorf","plz":null,"infos":["lall"]}}';
$userData = UserData::createFromJsonMapper($json);

$userData; // => \Arrayy\tests\UserData::class
echo $userData->firstName; // 'Lars' 
$userData->city; // => \Arrayy\tests\CityData::class
echo $userData->city->name; // 'D眉sseldorf'
createFromObject(ArrayAccess $object) : Arrayy (Immutable)

Create an new instance filled with values from an object that have implemented ArrayAccess.

$object = A::create(1, 'foo');
$arrayy = A::createFromObject($object); // Arrayy[1, 'foo']
createFromObjectVars(\object $object) : Arrayy (Immutable)

Create an new instance filled with values from an object.

$object = new stdClass();
$object->x = 42;
$arrayy = A::createFromObjectVars($object); // Arrayy['x' => 42]
createWithRange() : Arrayy (Immutable)

Create an new instance containing a range of elements.

$arrayy = A::createWithRange(2, 4); // Arrayy[2, 3, 4]
createFromGeneratorImmutable() : Arrayy (Immutable)

Create an new instance filled with a copy of values from a "Generator"-object.

WARNING: Need more memory then the "A::createFromGeneratorFunction()" call, because we will fetch and store all keys and values from the Generator.

$generator = A::createWithRange(2, 4)->getGenerator();
$arrayy = A::createFromGeneratorImmutable($generator); // Arrayy[2, 3, 4]
createFromGeneratorFunction() : Arrayy (Immutable)

Create an new instance from a callable function which will return a Generator.

$generatorFunction = static function() {
    yield from A::createWithRange(2, 4)->getArray();
};
$arrayy = A::createFromGeneratorFunction($generatorFunction); // Arrayy[2, 3, 4]
createFromString(string $str) : Arrayy (Immutable)

Create an new Arrayy object via string.

$arrayy = A::createFromString(' foo, bar '); // Arrayy['foo', 'bar']

Instance Methods

Arrayy: All examples below make use of PHP 5.6 function importing, and PHP 5.4 short array syntax. For further details, see the documentation for the create method above, as well as the notes on PHP 5.6 creation.

"set an array value"
$arrayy = a(['f貌么' => 'b脿艡']);
$arrayy['foo'] = 'bar';
var_dump($arrayy); // Arrayy['f貌么' => 'b脿艡', 'foo' => 'bar']
"get an array value"
$arrayy = a(['f貌么' => 'b脿艡']);
var_dump($arrayy['f貌么']); // 'b脿艡'
"get the array"
$arrayy = a(['f貌么' => 'b脿艡']);
var_dump($arrayy->getArray()); // ['f貌么' => 'b脿艡']
"delete an array value"
$arrayy = a(['f貌么' => 'b脿艡', 'lall']);
unset($arrayy['f貌么']);
var_dump($arrayy); // Arrayy[0 => 'lall']
"check if an array value is-set"
$arrayy = a(['f貌么' => 'b脿艡']);
isset($arrayy['f貌么']); // true
"simple loop with an Arrayy-object"
$arrayy = a(['f貌么' => 'b脿艡']);
foreach ($arrayy) as $key => $value) {
  echo $key . ' | ' . $value; // f貌么 | b脿艡
}

Arrayy methods

add append appendArrayValues appendImmutable appendToEachKey appendToEachValue arsort arsortImmutable asort asortImmutable at average changeKeyCase changeSeparator chunk clean clear contains containsCaseInsensitive containsKey containsKeys containsKeysRecursive containsValue containsValueRecursive containsValues count countValues create createByReference createFromArray createFromGeneratorFunction createFromGeneratorImmutable createFromJson createFromJsonMapper createFromObject createFromObjectVars createFromString createFromTraversableImmutable createWithRange current customSortKeys customSortKeysImmutable customSortValues customSortValuesImmutable delete diff diffKey diffKeyAndValue diffRecursive diffReverse divide each end exchangeArray exists fillWithDefaults filter filterBy find findBy first firstKey firstsImmutable firstsKeys firstsMutable flatten flip get getAll getArray getArrayCopy getColumn getGenerator getGeneratorByReference getIterator getIteratorClass getKeys getList getObject getPhpDocPropertiesFromClass getRandom getRandomKey getRandomKeys getRandomValue getRandomValues getValues getValuesYield group has hasValue implode implodeKeys indexBy indexOf initial intersection intersectionMulti intersects invoke isAssoc isEmpty isEqual isMultiArray isNumeric isSequential jsonSerialize key keyExists keys krsort krsortImmutable ksort ksortImmutable last lastKey lastsImmutable lastsMutable length map matches matchesAny max mergeAppendKeepIndex mergeAppendNewIndex mergePrependKeepIndex mergePrependNewIndex meta min mostUsedValue mostUsedValues moveElement moveElementToFirstPlace moveElementToLastPlace natcasesort natcasesortImmutable natsort natsortImmutable next nth offsetExists offsetGet offsetSet offsetUnset only pad partition pop prepend prependImmutable prependToEachKey prependToEachValue pull push randomImmutable randomKey randomKeys randomMutable randomValue randomValues randomWeighted reduce reduce_dimension reindex reject remove removeElement removeFirst removeLast removeValue repeat replace replaceAllKeys replaceAllValues replaceKeys replaceOneValue replaceValues rest reverse rsort rsortImmutable searchIndex searchValue serialize set setAndGet setIteratorClass shift shuffle size sizeIs sizeIsBetween sizeIsGreaterThan sizeIsLessThan sizeRecursive slice sort sortImmutable sortKeys sortKeysImmutable sortValueKeepIndex sortValueNewIndex sorter splice split stripEmpty swap toArray toJson toList toPermutation toString uasort uasortImmutable uksort uksortImmutable unique uniqueKeepIndex uniqueNewIndex unserialize unshift validate values walk where

add(mixed $value, int|string|null $key): static

鈫 Add new values (optional using dot-notation).

Parameters:

  • T $value
  • TKey $key

Return:

  • static <p>(Immutable) Return this Arrayy object, with the appended values.</p>

append(mixed $value, mixed $key): $this

鈫 Append a (key) + value to the current array.

EXAMPLE: a(['f貌么' => 'b脿艡'])->append('foo'); // Arrayy['f貌么' => 'b脿艡', 0 => 'foo']

Parameters:

  • T $value
  • TKey|null $key

Return:

  • $this <p>(Mutable) Return this Arrayy object, with the appended values.</p>

appendArrayValues(array $values, mixed $key): $this

鈫 Append a (key) + values to the current array.

EXAMPLE: a(['f貌么' => ['b脿艡']])->appendArrayValues(['foo1', 'foo2'], 'f貌么'); // Arrayy['f貌么' => ['b脿艡', 'foo1', 'foo2']]

Parameters:

  • array<array-key, T> $values
  • TKey|null $key

Return:

  • $this <p>(Mutable) Return this Arrayy object, with the appended values.</p>

appendImmutable(mixed $value, mixed $key): $this

鈫 Append a (key) + value to the current array.

EXAMPLE: a(['f貌么' => 'b脿艡'])->appendImmutable('foo')->getArray(); // ['f貌么' => 'b脿艡', 0 => 'foo']

Parameters:

  • T $value
  • TKey $key

Return:

  • $this <p>(Immutable) Return this Arrayy object, with the appended values.</p>

appendToEachKey(int|string $prefix): static

鈫 Add a suffix to each key.

Parameters:

  • int|string $prefix

Return:

  • static <p>(Immutable) Return an Arrayy object, with the prefixed keys.</p>

appendToEachValue(float|int|string $prefix): static

鈫 Add a prefix to each value.

Parameters:

  • float|int|string $prefix

Return:

  • static <p>(Immutable) Return an Arrayy object, with the prefixed values.</p>

arsort(): $this

鈫 Sort an array in reverse order and maintain index association.

Parameters: nothing

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

arsortImmutable(): $this

鈫 Sort an array in reverse order and maintain index association.

Parameters: nothing

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

asort(int $sort_flags): $this

鈫 Sort the entries by value.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

asortImmutable(int $sort_flags): $this

鈫 Sort the entries by value.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

at(\Closure $closure): static

鈫 Iterate over the current array and execute a callback for each loop.

EXAMPLE: $result = A::create(); $closure = function ($value, $key) use ($result) { $result[$key] = ':' . $value . ':'; }; a(['foo', 'bar' => 'bis'])->at($closure); // Arrayy[':foo:', 'bar' => ':bis:']

Parameters:

  • \Closure $closure

Return:

  • static <p>(Immutable)</p>

average(int $decimals): float|int

鈫 Returns the average value of the current array.

EXAMPLE: a([-9, -8, -7, 1.32])->average(2); // -5.67

Parameters:

  • int $decimals <p>The number of decimal-numbers to return.</p>

Return:

  • float|int <p>The average value.</p>

changeKeyCase(int $case): static

鈫 Changes all keys in an array.

Parameters:

  • int $case [optional] <p> Either <strong>CASE_UPPER</strong><br /> or <strong>CASE_LOWER</strong> (default)</p>

Return:

  • static <p>(Immutable)</p>

changeSeparator(string $separator): $this

鈫 Change the path separator of the array wrapper.

By default, the separator is: "."

Parameters:

  • string $separator <p>Separator to set.</p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

chunk(int $size, bool $preserveKeys): static

鈫 Create a chunked version of the current array.

EXAMPLE: a([-9, -8, -7, 1.32])->chunk(2); // Arrayy[[-9, -8], [-7, 1.32]]

Parameters:

  • int $size <p>Size of each chunk.</p>
  • bool $preserveKeys <p>Whether array keys are preserved or no.</p>

Return:

  • static <p>(Immutable) A new array of chunks from the original array.</p>

clean(): static

鈫 Clean all falsy values from the current array.

EXAMPLE: a([-8 => -9, 1, 2 => false])->clean(); // Arrayy[-8 => -9, 1]

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

clear(int|int[]|string|string[]|null $key): $this

鈫 WARNING!!! -> Clear the current full array or a $key of it.

EXAMPLE: a([-8 => -9, 1, 2 => false])->clear(); // Arrayy[]

Parameters:

  • int|int[]|string|string[]|null $key

Return:

  • $this <p>(Mutable) Return this Arrayy object, with an empty array.</p>

contains(float|int|string $value, bool $recursive, bool $strict): bool

鈫 Check if an item is in the current array.

EXAMPLE: a([1, true])->contains(true); // true

Parameters:

  • float|int|string $value
  • bool $recursive
  • bool $strict

Return:

  • bool

containsCaseInsensitive(mixed $value, bool $recursive): bool

鈫 Check if an (case-insensitive) string is in the current array.

EXAMPLE: a(['E', '茅'])->containsCaseInsensitive('脡'); // true

Parameters:

  • mixed $value
  • bool $recursive

Return:

  • bool

containsKey(int|string $key): bool

鈫 Check if the given key/index exists in the array.

EXAMPLE: a([1 => true])->containsKey(1); // true

Parameters:

  • int|string $key <p>key/index to search for</p>

Return:

  • bool <p>Returns true if the given key/index exists in the array, false otherwise.</p>

containsKeys(array $needles, bool $recursive): bool

鈫 Check if all given needles are present in the array as key/index.

EXAMPLE: a([1 => true])->containsKeys(array(1 => 0)); // true

Parameters:

  • array<array-key>|array<TKey> $needles <p>The keys you are searching for.</p>
  • bool $recursive

Return:

  • bool <p>Returns true if all the given keys/indexes exists in the array, false otherwise.</p>

containsKeysRecursive(array $needles): bool

鈫 Check if all given needles are present in the array as key/index.

Parameters:

  • array<array-key>|array<TKey> $needles <p>The keys you are searching for.</p>

Return:

  • bool <p>Returns true if all the given keys/indexes exists in the array, false otherwise.</p>

containsValue(float|int|string $value): bool

鈫 alias: for "Arrayy->contains()"

Parameters:

  • float|int|string $value

Return:

  • bool

containsValueRecursive(float|int|string $value): bool

鈫 alias: for "Arrayy->contains($value, true)"

Parameters:

  • float|int|string $value

Return:

  • bool

containsValues(array $needles): bool

鈫 Check if all given needles are present in the array.

EXAMPLE: a([1, true])->containsValues(array(1, true)); // true

Parameters:

  • array<mixed>|array<T> $needles

Return:

  • bool <p>Returns true if all the given values exists in the array, false otherwise.</p>

count(int $mode): int

鈫 Counts all elements in an array, or something in an object.

EXAMPLE: a([-9, -8, -7, 1.32])->count(); // 4

For objects, if you have SPL installed, you can hook into count() by implementing interface {@see \Countable}. The interface has exactly one method, {@see \Countable::count()}, which returns the return value for the count() function. Please see the {@see \Array} section of the manual for a detailed explanation of how arrays are implemented and used in PHP.

Parameters:

  • int $mode [optional] If the optional mode parameter is set to COUNT_RECURSIVE (or 1), count will recursively count the array. This is particularly useful for counting all the elements of a multidimensional array. count does not detect infinite recursion.

Return:

  • int <p> The number of elements in var, which is typically an array, since anything else will have one element. </p> <p> If var is not an array or an object with implemented Countable interface, 1 will be returned. There is one exception, if var is &null;, 0 will be returned. </p> <p> Caution: count may return 0 for a variable that isn't set, but it may also return 0 for a variable that has been initialized with an empty array. Use isset to test if a variable is set. </p>

countValues(): static

鈫 Counts all the values of an array

Parameters: nothing

Return:

  • static <p> (Immutable) An associative Arrayy-object of values from input as keys and their count as value. </p>

create(array|\Traversable|callable():\Generator|(T|\Traversable) $data, array|\Traversable|callable():\Generator|(T|\Traversable) $iteratorClass, array|\Traversable|callable():\Generator|(T|\Traversable) $checkPropertiesInConstructor): static

鈫 Creates an Arrayy object.

Parameters:

  • array<array-key,T>|\Traversable<array-key,T>|callable():\Generator<TKey,T>|(T&\Traversable)array<array-key,T>|\Traversable<array-key,T>|callable():\Generator<TKey,T>|(T&\Traversable) $data
  • array<array-key,T>|\Traversable<array-key,T>|callable():\Generator<TKey,T>|(T&\Traversable)array<array-key,T>|\Traversable<array-key,T>|callable():\Generator<TKey,T>|(T&\Traversable) $data
  • array<array-key,T>|\Traversable<array-key,T>|callable():\Generator<TKey,T>|(T&\Traversable)array<array-key,T>|\Traversable<array-key,T>|callable():\Generator<TKey,T>|(T&\Traversable) $data

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createByReference(array $array): $this

鈫 WARNING: Creates an Arrayy object by reference.

Parameters:

  • array<TKey, T> $array

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

createFromArray(array $array): static

鈫 Create an new Arrayy object via JSON.

Parameters:

  • array<TKey, T> $array

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromGeneratorFunction(callable $generatorFunction): static

鈫 Create an new instance from a callable function which will return an Generator.

Parameters:

  • callable(): \Generator<TKey, T> $generatorFunction

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromGeneratorImmutable(\Generator $generator): static

鈫 Create an new instance filled with a copy of values from a "Generator"-object.

Parameters:

  • \Generator<TKey, T> $generator

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromJson(string $json): static

鈫 Create an new Arrayy object via JSON.

Parameters:

  • string $json

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromJsonMapper(string $json): $this

Parameters:

  • string $json

Return:

  • $this

createFromObject(\Traversable $object): static

鈫 Create an new instance filled with values from an object that is iterable.

Parameters:

  • \Traversable<array-key, T> $object <p>iterable object</p>

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromObjectVars(object $object): static

鈫 Create an new instance filled with values from an object.

Parameters:

  • object $object

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromString(string $str, string|null $delimiter, string|null $regEx): static

鈫 Create an new Arrayy object via string.

Parameters:

  • string $str <p>The input string.</p>
  • string|null $delimiter <p>The boundary string.</p>
  • string|null $regEx <p>Use the $delimiter or the $regEx, so if $pattern is null, $delimiter will be used.</p>

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createFromTraversableImmutable(\Traversable $traversable, bool $use_keys): static

鈫 Create an new instance filled with a copy of values from a "Traversable"-object.

Parameters:

  • \Traversable<(array-key|TKey), T> $traversable
  • bool $use_keys [optional] <p> Whether to use the iterator element keys as index. </p>

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

createWithRange(float|int|string $low, float|int|string $high, float|int $step): static

鈫 Create an new instance containing a range of elements.

Parameters:

  • float|int|string $low <p>First value of the sequence.</p>
  • float|int|string $high <p>The sequence is ended upon reaching the end value.</p>
  • float|int $step <p>Used as the increment between elements in the sequence.</p>

Return:

  • static <p>(Immutable) Returns an new instance of the Arrayy object.</p>

current(): false|mixed

鈫 Gets the element of the array at the current internal iterator position.

Parameters: nothing

Return:

  • false|mixed

customSortKeys(callable $function): $this

鈫 Custom sort by index via "uksort".

EXAMPLE: $callable = function ($a, $b) { if ($a == $b) { return 0; } return ($a > $b) ? 1 : -1; }; $arrayy = a(['three' => 3, 'one' => 1, 'two' => 2]); $resultArrayy = $arrayy->customSortKeys($callable); // Arrayy['one' => 1, 'three' => 3, 'two' => 2]

Parameters:

  • callable $function

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

customSortKeysImmutable(callable $function): $this

鈫 Custom sort by index via "uksort".

Parameters:

  • callable $function

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

customSortValues(callable $function): $this

鈫 Custom sort by value via "usort".

EXAMPLE: $callable = function ($a, $b) { if ($a == $b) { return 0; } return ($a > $b) ? 1 : -1; }; $arrayy = a(['three' => 3, 'one' => 1, 'two' => 2]); $resultArrayy = $arrayy->customSortValues($callable); // Arrayy['one' => 1, 'two' => 2, 'three' => 3]

Parameters:

  • callable $function

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

customSortValuesImmutable(callable $function): $this

鈫 Custom sort by value via "usort".

Parameters:

  • callable $function

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

delete(int|int[]|string|string[] $keyOrKeys): void

鈫 Delete the given key or keys.

Parameters:

  • int|int[]|string|string[] $keyOrKeys

Return:

  • void

diff(array $array): static

鈫 Return elements where the values that are only in the current array.

EXAMPLE: a([1 => 1, 2 => 2])->diff([1 => 1]); // Arrayy[2 => 2]

Parameters:

  • array<TKey, T> ...$array

Return:

  • static <p>(Immutable)</p>

diffKey(array $array): static

鈫 Return elements where the keys are only in the current array.

Parameters:

  • array<TKey, T> ...$array

Return:

  • static <p>(Immutable)</p>

diffKeyAndValue(array $array): static

鈫 Return elements where the values and keys are only in the current array.

Parameters:

  • array<TKey, T> ...$array

Return:

  • static <p>(Immutable)</p>

diffRecursive(array $array, array|\Generator|null $helperVariableForRecursion): static

鈫 Return elements where the values are only in the current multi-dimensional array.

EXAMPLE: a([1 => [1 => 1], 2 => [2 => 2]])->diffRecursive([1 => [1 => 1]]); // Arrayy[2 => [2 => 2]]

Parameters:

  • array<TKey, T> $array
  • null|array<TKey, T>|\Generator<TKey, T> $helperVariableForRecursion <p>(only for internal usage)</p>

Return:

  • static <p>(Immutable)</p>

diffReverse(array $array): static

鈫 Return elements where the values that are only in the new $array.

EXAMPLE: a([1 => 1])->diffReverse([1 => 1, 2 => 2]); // Arrayy[2 => 2]

Parameters:

  • array<TKey, T> $array

Return:

  • static <p>(Immutable)</p>

divide(): static

鈫 Divide an array into two arrays. One with keys and the other with values.

EXAMPLE: a(['a' => 1, 'b' => ''])->divide(); // Arrayy[Arrayy['a', 'b'], Arrayy[1, '']]

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

each(\Closure $closure): static

鈫 Iterate over the current array and modify the array's value.

EXAMPLE: $result = A::create(); $closure = function ($value) { return ':' . $value . ':'; }; a(['foo', 'bar' => 'bis'])->each($closure); // Arrayy[':foo:', 'bar' => ':bis:']

Parameters:

  • \Closure(T = default): T|\Closure(T = default, TKey = default): T $closure

Return:

  • static <p>(Immutable)</p>

end(): false|mixed

鈫 Sets the internal iterator to the last element in the array and returns this element.

Parameters: nothing

Return:

  • false|mixed

exchangeArray(array|mixed|static $data): array

鈫 Exchange the array for another one.

Parameters:

  • `T|array|self $data 1. use the current array, if it's a array
  • fallback to empty array, if there is nothing
  • call "getArray()" on object, if there is a "Arrayy"-object
  • call "createFromObject()" on object, if there is a "\Traversable"-object
  • call "__toArray()" on object, if the method exists
  • cast a string or object with "__toString()" into an array
  • throw a "InvalidArgumentException"-Exception`

Return:

  • array

exists(\Closure $closure): bool

鈫 Check if a value is in the current array using a closure.

EXAMPLE: $callable = function ($value, $key) { return 2 === $key and 'two' === $value; }; a(['foo', 2 => 'two'])->exists($callable); // true

Parameters:

  • \Closure(T = default, TKey = default): bool $closure

Return:

  • bool <p>Returns true if the given value is found, false otherwise.</p>

fillWithDefaults(int $num, mixed $default): static

鈫 Fill the array until "$num" with "$default" values.

EXAMPLE: a(['bar'])->fillWithDefaults(3, 'foo'); // Arrayy['bar', 'foo', 'foo']

Parameters:

  • int $num
  • T $default

Return:

  • static <p>(Immutable)</p>

filter(\Closure|null $closure, int $flag): static

鈫 Find all items in an array that pass the truth test.

EXAMPLE: $closure = function ($value) { return $value % 2 !== 0; } a([1, 2, 3, 4])->filter($closure); // Arrayy[0 => 1, 2 => 3]

Parameters:

  • null|\Closure(T = default, TKey = default): bool|\Closure(T = default): bool|\Closure(TKey = default): bool $closure [optional] <p> The callback function to use </p> <p> If no callback is supplied, all entries of input equal to false (see converting to boolean) will be removed. </p>
  • int $flag [optional] <p> Flag determining what arguments are sent to <i>callback</i>: </p> <ul> <li> <b>ARRAY_FILTER_USE_KEY</b> (1) - pass key as the only argument to <i>callback</i> instead of the value </li> <li> <b>ARRAY_FILTER_USE_BOTH</b> (2) - pass both value and key as arguments to <i>callback</i> instead of the value </li> </ul>

Return:

  • static <p>(Immutable)</p>

filterBy(string $property, mixed $value, string $comparisonOp): static

鈫 Filters an array of objects (or a numeric array of associative arrays) based on the value of a particular property within that.

Parameters:

  • string $property
  • mixed|T $value
  • string $comparisonOp <p> 'eq' (equals),<br /> 'gt' (greater),<br /> 'gte' || 'ge' (greater or equals),<br /> 'lt' (less),<br /> 'lte' || 'le' (less or equals),<br /> 'ne' (not equals),<br /> 'contains',<br /> 'notContains',<br /> 'newer' (via strtotime),<br /> 'older' (via strtotime),<br /> </p>

Return:

  • static <p>(Immutable)</p>

find(\Closure $closure): false|mixed

鈫 Find the first item in an array that passes the truth test, otherwise return false.

EXAMPLE: $search = 'foo'; $closure = function ($value, $key) use ($search) { return $value === $search; }; a(['foo', 'bar', 'lall'])->find($closure); // 'foo'

Parameters:

  • \Closure(T = default, TKey = default): bool $closure

Return:

  • false|mixed <p>Return false if we did not find the value.</p>

findBy(string $property, mixed $value, string $comparisonOp): static

鈫 find by .

..

EXAMPLE: $array = [ 0 => ['id' => 123, 'name' => 'foo', 'group' => 'primary', 'value' => 123456, 'when' => '2014-01-01'], 1 => ['id' => 456, 'name' => 'bar', 'group' => 'primary', 'value' => 1468, 'when' => '2014-07-15'], ]; a($array)->filterBy('name', 'foo'); // Arrayy[0 => ['id' => 123, 'name' => 'foo', 'group' => 'primary', 'value' => 123456, 'when' => '2014-01-01']]

Parameters:

  • string $property
  • mixed|T $value
  • string $comparisonOp

Return:

  • static <p>(Immutable)</p>

first(): mixed|null

鈫 Get the first value from the current array.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->first(); // 'foo'

Parameters: nothing

Return:

  • mixed|null <p>Return null if there wasn't a element.</p>

firstKey(): mixed|null

鈫 Get the first key from the current array.

Parameters: nothing

Return:

  • mixed|null <p>Return null if there wasn't a element.</p>

firstsImmutable(int|null $number): static

鈫 Get the first value(s) from the current array.

And will return an empty array if there was no first entry.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->firstsImmutable(2); // Arrayy[0 => 'foo', 1 => 'bar']

Parameters:

  • int|null $number <p>How many values you will take?</p>

Return:

  • static <p>(Immutable)</p>

firstsKeys(int|null $number): static

鈫 Get the first value(s) from the current array.

And will return an empty array if there was no first entry.

Parameters:

  • int|null $number <p>How many values you will take?</p>

Return:

  • static <p>(Immutable)</p>

firstsMutable(int|null $number): $this

鈫 Get and remove the first value(s) from the current array.

And will return an empty array if there was no first entry.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->firstsMutable(); // 'foo'

Parameters:

  • int|null $number <p>How many values you will take?</p>

Return:

  • $this <p>(Mutable)</p>

flatten(string $delimiter, string $prepend, array|null $items): array

鈫 Flatten an array with the given character as a key delimiter.

EXAMPLE: $dot = a(['foo' => ['abc' => 'xyz', 'bar' => ['baz']]]); $flatten = $dot->flatten(); $flatten['foo.abc']; // 'xyz' $flatten['foo.bar.0']; // 'baz'

Parameters:

  • string $delimiter
  • string $prepend
  • array|null $items

Return:

  • array

flip(): static

鈫 Exchanges all keys with their associated values in an array.

EXAMPLE: a([0 => 'foo', 1 => 'bar'])->flip(); // Arrayy['foo' => 0, 'bar' => 1]

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

get(int|string $key, mixed $fallback, array $array, bool $useByReference): mixed|static

鈫 Get a value from an array (optional using dot-notation).

EXAMPLE: $arrayy = a(['user' => ['lastname' => 'Moelleken']]); $arrayy->get('user.lastname'); // 'Moelleken' // --- $arrayy = new A(); $arrayy['user'] = ['lastname' => 'Moelleken']; $arrayy['user.firstname'] = 'Lars'; $arrayy['user']['lastname']; // Moelleken $arrayy['user.lastname']; // Moelleken $arrayy['user.firstname']; // Lars

Parameters:

  • array-key $key <p>The key to look for.</p>
  • mixed $fallback <p>Value to fallback to.</p>
  • array<array-key, mixed>|array<TKey, T> $array <p>The array to get from, if it's set to "null" we use the current array from the class.</p>
  • bool $useByReference

Return:

  • mixed|static

getAll(): array

鈫 alias: for "Arrayy->toArray()"

Parameters: nothing

Return:

  • array

getArray(bool $convertAllArrayyElements, bool $preserveKeys): array

鈫 Get the current array from the "Arrayy"-object.

alias for "toArray()"

Parameters:

  • bool $convertAllArrayyElements <p> Convert all Child-"Arrayy" objects also to arrays. </p>
  • bool $preserveKeys <p> e.g.: A generator maybe return the same key more then once, so maybe you will ignore the keys. </p>

Return:

  • array

getArrayCopy(): array

鈫 Creates a copy of the ArrayyObject.

Parameters: nothing

Return:

  • array

getColumn(int|string|null $columnKey, int|string|null $indexKey): static

鈫 Returns the values from a single column of the input array, identified by the $columnKey, can be used to extract data-columns from multi-arrays.

EXAMPLE: a([['foo' => 'bar', 'id' => 1], ['foo => 'lall', 'id' => 2]])->getColumn('foo', 'id'); // Arrayy[1 => 'bar', 2 => 'lall']

INFO: Optionally, you may provide an $indexKey to index the values in the returned array by the values from the $indexKey column in the input array.

Parameters:

  • int|string|null $columnKey
  • int|string|null $indexKey

Return:

  • static <p>(Immutable)</p>

getGenerator(): Generator

鈫 Get the current array from the "Arrayy"-object as generator.

Parameters: nothing

Return:

  • \Generator

getGeneratorByReference(): Generator

鈫 Get the current array from the "Arrayy"-object as generator by reference.

Parameters: nothing

Return:

  • \Generator

getIterator(): Iterator

鈫 Returns a new iterator, thus implementing the \Iterator interface.

EXAMPLE: a(['foo', 'bar'])->getIterator(); // ArrayyIterator['foo', 'bar']

Parameters: nothing

Return:

  • \Iterator<mixed,mixed> <p>An iterator for the values in the array.</p>

getIteratorClass(): string

鈫 Gets the iterator classname for the ArrayObject.

Parameters: nothing

Return:

  • string

getKeys(): static

鈫 alias: for "Arrayy->keys()"

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

getList(bool $convertAllArrayyElements): array

鈫 Get the current array from the "Arrayy"-object as list.

alias for "toList()"

Parameters:

  • bool $convertAllArrayyElements <p> Convert all Child-"Arrayy" objects also to arrays. </p>

Return:

  • array

getObject(): stdClass

鈫 Get the current array from the "Arrayy"-object as object.

Parameters: nothing

Return:

  • \stdClass

getPhpDocPropertiesFromClass(): array|mixed|\TypeCheckArray|\TypeInterface

Parameters: nothing

Return:

  • array<int|string,\TypeCheckInterface>|mixed|\TypeCheckArray<int|string,\TypeCheckInterface>|\TypeInterface

getRandom(): static

鈫 alias: for "Arrayy->randomImmutable()"

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

getRandomKey(): mixed

鈫 alias: for "Arrayy->randomKey()"

Parameters: nothing

Return:

  • mixed <p>Get a key/index or null if there wasn't a key/index.</p>

getRandomKeys(int $number): static

鈫 alias: for "Arrayy->randomKeys()"

Parameters:

  • int $number

Return:

  • static <p>(Immutable)</p>

getRandomValue(): mixed

鈫 alias: for "Arrayy->randomValue()"

Parameters: nothing

Return:

  • mixed <p>Get a random value or null if there wasn't a value.</p>

getRandomValues(int $number): static

鈫 alias: for "Arrayy->randomValues()"

Parameters:

  • int $number

Return:

  • static <p>(Immutable)</p>

getValues(): static

鈫 Gets all values.

Parameters: nothing

Return:

  • static <p>The values of all elements in this array, in the order they appear in the array.</p>

getValuesYield(): Generator

鈫 Gets all values via Generator.

Parameters: nothing

Return:

  • \Generator <p>The values of all elements in this array, in the order they appear in the array as Generator.</p>

group(callable|string $grouper, bool $saveKeys): static

鈫 Group values from a array according to the results of a closure.

Parameters:

  • callable|string $grouper <p>A callable function name.</p>
  • bool $saveKeys

Return:

  • static <p>(Immutable)</p>

has(mixed $key): bool

鈫 Check if an array has a given key.

Parameters:

  • mixed $key

Return:

  • bool

hasValue(mixed $value): bool

鈫 Check if an array has a given value.

INFO: If you need to search recursive please use contains($value, true).

Parameters:

  • mixed $value

Return:

  • bool

implode(string $glue, string $prefix): string

鈫 Implodes the values of this array.

EXAMPLE: a([0 => -9, 1, 2])->implode('|'); // '-9|1|2'

Parameters:

  • string $glue
  • string $prefix

Return:

  • string

implodeKeys(string $glue): string

鈫 Implodes the keys of this array.

Parameters:

  • string $glue

Return:

  • string

indexBy(mixed $key): static

鈫 Given a list and an iterate-function that returns a key for each element in the list (or a property name), returns an object with an index of each item.

Parameters:

  • mixed $key

Return:

  • static <p>(Immutable)</p>

indexOf(mixed $value): false|mixed

鈫 alias: for "Arrayy->searchIndex()"

Parameters:

  • mixed $value <p>The value to search for.</p>

Return:

  • false|mixed

initial(int $to): static

鈫 Get everything but the last.

.$to items.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->initial(2); // Arrayy[0 => 'foo']

Parameters:

  • int $to

Return:

  • static <p>(Immutable)</p>

intersection(array $search, bool $keepKeys): static

鈫 Return an array with all elements found in input array.

EXAMPLE: a(['foo', 'bar'])->intersection(['bar', 'baz']); // Arrayy['bar']

Parameters:

  • array<TKey, T> $search
  • bool $keepKeys

Return:

  • static <p>(Immutable)</p>

intersectionMulti(array $array): static

鈫 Return an array with all elements found in input array.

Parameters:

  • array<array<TKey, T>> ...$array

Return:

  • static <p>(Immutable)</p>

intersects(array $search): bool

鈫 Return a boolean flag which indicates whether the two input arrays have any common elements.

EXAMPLE: a(['foo', 'bar'])->intersects(['f枚枚', 'b盲r']); // false

Parameters:

  • array<TKey, T> $search

Return:

  • bool

invoke(callable $callable, mixed $arguments): static

鈫 Invoke a function on all of an array's values.

Parameters:

  • callable(T = default, mixed ): mixed $callable
  • mixed $arguments

Return:

  • static <p>(Immutable)</p>

isAssoc(bool $recursive): bool

鈫 Check whether array is associative or not.

EXAMPLE: a(['foo' => 'bar', 2, 3])->isAssoc(); // true

Parameters:

  • bool $recursive

Return:

  • bool <p>Returns true if associative, false otherwise.</p>

isEmpty(int|int[]|string|string[]|null $keys): bool

鈫 Check if a given key or keys are empty.

Parameters:

  • int|int[]|string|string[]|null $keys

Return:

  • bool <p>Returns true if empty, false otherwise.</p>

isEqual(array $array): bool

鈫 Check if the current array is equal to the given "$array" or not.

EXAMPLE: a(['馃挬'])->isEqual(['馃挬']); // true

Parameters:

  • array<(int|string), mixed> $array

Return:

  • bool

isMultiArray(): bool

鈫 Check if the current array is a multi-array.

EXAMPLE: a(['foo' => [1, 2 , 3]])->isMultiArray(); // true

Parameters: nothing

Return:

  • bool

isNumeric(): bool

鈫 Check whether array is numeric or not.

Parameters: nothing

Return:

  • bool <p>Returns true if numeric, false otherwise.</p>

isSequential(bool $recursive): bool

鈫 Check if the current array is sequential [0, 1, 2, 3, 4, 5 .

..] or not.

EXAMPLE: a([0 => 'foo', 1 => 'lall', 2 => 'foobar'])->isSequential(); // true

INFO: If the array is empty we count it as non-sequential.

Parameters:

  • bool $recursive

Return:

  • bool

jsonSerialize(): array

Parameters: nothing

Return:

  • array

key(): int|string|null

鈫 Gets the key/index of the element at the current internal iterator position.

Parameters: nothing

Return:

  • int|string|null

keyExists(int|string $key): bool

鈫 Checks if the given key exists in the provided array.

INFO: This method only use "array_key_exists()" if you want to use "dot"-notation, then you need to use "Arrayy->offsetExists()".

Parameters:

  • int|string $key the key to look for

Return:

  • bool

keys(bool $recursive, mixed|null $search_values, bool $strict): static

鈫 Get all keys from the current array.

EXAMPLE: a([1 => 'foo', 2 => 'foo2', 3 => 'bar'])->keys(); // Arrayy[1, 2, 3]

Parameters:

  • bool $recursive [optional] <p> Get all keys, also from all sub-arrays from an multi-dimensional array. </p>
  • mixed|null $search_values [optional] <p> If specified, then only keys containing these values are returned. </p>
  • bool $strict [optional] <p> Determines if strict comparison (===) should be used during the search. </p>

Return:

  • static <p>(Immutable) An array of all the keys in input.</p>

krsort(int $sort_flags): $this

鈫 Sort an array by key in reverse order.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

krsortImmutable(int $sort_flags): $this

鈫 Sort an array by key in reverse order.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

ksort(int $sort_flags): $this

鈫 Sort the entries by key.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

ksortImmutable(int $sort_flags): $this

鈫 Sort the entries by key.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

last(): mixed|null

鈫 Get the last value from the current array.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->last(); // 'lall'

Parameters: nothing

Return:

  • mixed|null <p>Return null if there wasn't a element.</p>

lastKey(): mixed|null

鈫 Get the last key from the current array.

Parameters: nothing

Return:

  • mixed|null <p>Return null if there wasn't a element.</p>

lastsImmutable(int|null $number): static

鈫 Get the last value(s) from the current array.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->lasts(2); // Arrayy[0 => 'bar', 1 => 'lall']

Parameters:

  • int|null $number

Return:

  • static <p>(Immutable)</p>

lastsMutable(int|null $number): $this

鈫 Get the last value(s) from the current array.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->lasts(2); // Arrayy[0 => 'bar', 1 => 'lall']

Parameters:

  • int|null $number

Return:

  • $this <p>(Mutable)</p>

length(int $mode): int

鈫 Count the values from the current array.

alias: for "Arrayy->count()"

Parameters:

  • int $mode

Return:

  • int

map(callable $callable, bool $useKeyAsSecondParameter, mixed $arguments): static

鈫 Apply the given function to the every element of the array, collecting the results.

EXAMPLE: a(['foo', 'Foo'])->map('mb_strtoupper'); // Arrayy['FOO', 'FOO']

Parameters:

  • callable(T , TKey = default, mixed = default): mixed $callable
  • bool $useKeyAsSecondParameter
  • mixed ...$arguments

Return:

  • static <p>(Immutable) Arrayy object with modified elements.</p>

matches(\Closure $closure): bool

鈫 Check if all items in current array match a truth test.

EXAMPLE: $closure = function ($value, $key) { return ($value % 2 === 0); }; a([2, 4, 8])->matches($closure); // true

Parameters:

  • \Closure(T = default, TKey = default): bool $closure

Return:

  • bool

matchesAny(\Closure $closure): bool

鈫 Check if any item in the current array matches a truth test.

EXAMPLE: $closure = function ($value, $key) { return ($value % 2 === 0); }; a([1, 4, 7])->matches($closure); // true

Parameters:

  • \Closure(T = default, TKey = default): bool $closure

Return:

  • bool

max(): false|float|int|string

鈫 Get the max value from an array.

EXAMPLE: a([-9, -8, -7, 1.32])->max(); // 1.32

Parameters: nothing

Return:

  • false|float|int|string <p>Will return false if there are no values.</p>

mergeAppendKeepIndex(array $array, bool $recursive): static

鈫 Merge the new $array into the current array.

  • keep key,value from the current array, also if the index is in the new $array

EXAMPLE: $array1 = [1 => 'one', 'foo' => 'bar1']; $array2 = ['foo' => 'bar2', 3 => 'three']; a($array1)->mergeAppendKeepIndex($array2); // Arrayy[1 => 'one', 'foo' => 'bar2', 3 => 'three'] // --- $array1 = [0 => 'one', 1 => 'foo']; $array2 = [0 => 'foo', 1 => 'bar2']; a($array1)->mergeAppendKeepIndex($array2); // Arrayy[0 => 'foo', 1 => 'bar2']

Parameters:

  • array<(int|TKey), T> $array
  • bool $recursive

Return:

  • static <p>(Immutable)</p>

mergeAppendNewIndex(array $array, bool $recursive): static

鈫 Merge the new $array into the current array.

  • replace duplicate assoc-keys from the current array with the key,values from the new $array
  • create new indexes

EXAMPLE: $array1 = [1 => 'one', 'foo' => 'bar1']; $array2 = ['foo' => 'bar2', 3 => 'three']; a($array1)->mergeAppendNewIndex($array2); // Arrayy[0 => 'one', 'foo' => 'bar2', 1 => 'three'] // --- $array1 = [0 => 'one', 1 => 'foo']; $array2 = [0 => 'foo', 1 => 'bar2']; a($array1)->mergeAppendNewIndex($array2); // Arrayy[0 => 'one', 1 => 'foo', 2 => 'foo', 3 => 'bar2']

Parameters:

  • array<TKey, T> $array
  • bool $recursive

Return:

  • static <p>(Immutable)</p>

mergePrependKeepIndex(array $array, bool $recursive): static

鈫 Merge the the current array into the $array.

  • use key,value from the new $array, also if the index is in the current array

EXAMPLE: $array1 = [1 => 'one', 'foo' => 'bar1']; $array2 = ['foo' => 'bar2', 3 => 'three']; a($array1)->mergePrependKeepIndex($array2); // Arrayy['foo' => 'bar1', 3 => 'three', 1 => 'one'] // --- $array1 = [0 => 'one', 1 => 'foo']; $array2 = [0 => 'foo', 1 => 'bar2']; a($array1)->mergePrependKeepIndex($array2); // Arrayy[0 => 'one', 1 => 'foo']

Parameters:

  • array<TKey, T> $array
  • bool $recursive

Return:

  • static <p>(Immutable)</p>

mergePrependNewIndex(array $array, bool $recursive): static

鈫 Merge the current array into the new $array.

  • replace duplicate assoc-keys from new $array with the key,values from the current array
  • create new indexes

EXAMPLE: $array1 = [1 => 'one', 'foo' => 'bar1']; $array2 = ['foo' => 'bar2', 3 => 'three']; a($array1)->mergePrependNewIndex($array2); // Arrayy['foo' => 'bar1', 0 => 'three', 1 => 'one'] // --- $array1 = [0 => 'one', 1 => 'foo']; $array2 = [0 => 'foo', 1 => 'bar2']; a($array1)->mergePrependNewIndex($array2); // Arrayy[0 => 'foo', 1 => 'bar2', 2 => 'one', 3 => 'foo']

Parameters:

  • array<TKey, T> $array
  • bool $recursive

Return:

  • static <p>(Immutable)</p>

meta(): ArrayyMeta|mixed|static

Parameters: nothing

Return:

  • \ArrayyMeta|mixed|static

min(): false|mixed

鈫 Get the min value from an array.

EXAMPLE: a([-9, -8, -7, 1.32])->min(); // -9

Parameters: nothing

Return:

  • false|mixed <p>Will return false if there are no values.</p>

mostUsedValue(): mixed|null

鈫 Get the most used value from the array.

Parameters: nothing

Return:

  • mixed|null <p>(Immutable) Return null if there wasn't a element.</p>

mostUsedValues(int|null $number): static

鈫 Get the most used value from the array.

Parameters:

  • int|null $number <p>How many values you will take?</p>

Return:

  • static <p>(Immutable)</p>

moveElement(int|string $from, int $to): static

鈫 Move an array element to a new index.

EXAMPLE: $arr2 = new A(['A' => 'a', 'B' => 'b', 'C' => 'c', 'D' => 'd', 'E' => 'e']); $newArr2 = $arr2->moveElement('D', 1); // Arrayy['A' => 'a', 'D' => 'd', 'B' => 'b', 'C' => 'c', 'E' => 'e']

Parameters:

  • int|string $from
  • int $to

Return:

  • static <p>(Immutable)</p>

moveElementToFirstPlace(int|string $key): static

鈫 Move an array element to the first place.

INFO: Instead of "Arrayy->moveElement()" this method will NOT loss the keys of an indexed array.

Parameters:

  • int|string $key

Return:

  • static <p>(Immutable)</p>

moveElementToLastPlace(int|string $key): static

鈫 Move an array element to the last place.

INFO: Instead of "Arrayy->moveElement()" this method will NOT loss the keys of an indexed array.

Parameters:

  • int|string $key

Return:

  • static <p>(Immutable)</p>

natcasesort(): $this

鈫 Sort an array using a case insensitive "natural order" algorithm.

Parameters: nothing

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

natcasesortImmutable(): $this

鈫 Sort an array using a case insensitive "natural order" algorithm.

Parameters: nothing

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

natsort(): $this

鈫 Sort entries using a "natural order" algorithm.

Parameters: nothing

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

natsortImmutable(): $this

鈫 Sort entries using a "natural order" algorithm.

Parameters: nothing

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

next(): false|mixed

鈫 Moves the internal iterator position to the next element and returns this element.

Parameters: nothing

Return:

  • false|mixed <p>(Mutable) Will return false if there are no values.</p>

nth(int $step, int $offset): static

鈫 Get the next nth keys and values from the array.

Parameters:

  • int $step
  • int $offset

Return:

  • static <p>(Immutable)</p>

offsetExists(bool|int|string $offset): bool

鈫 Whether or not an offset exists.

Parameters:

  • bool|int|string $offset

Return:

  • bool

offsetGet(int|string $offset): mixed

鈫 Returns the value at specified offset.

Parameters:

  • int|string $offset

Return:

  • mixed <p>Will return null if the offset did not exists.</p>

offsetSet(int|string|null $offset, mixed $value): void

鈫 Assigns a value to the specified offset + check the type.

Parameters:

  • int|string|null $offset
  • mixed $value

Return:

  • void

offsetUnset(int|string $offset): void

鈫 Unset an offset.

Parameters:

  • int|string $offset

Return:

  • void <p>(Mutable) Return nothing.</p>

only(int[]|string[] $keys): static

鈫 Get a subset of the items from the given array.

Parameters:

  • array-key[] $keys

Return:

  • static <p>(Immutable)</p>

pad(int $size, mixed $value): static

鈫 Pad array to the specified size with a given value.

Parameters:

  • int $size <p>Size of the result array.</p>
  • mixed $value <p>Empty value by default.</p>

Return:

  • static <p>(Immutable) Arrayy object padded to $size with $value.</p>

partition(\Closure $closure): array

鈫 Partitions this array in two array according to a predicate.

Keys are preserved in the resulting array.

Parameters:

  • \Closure(T = default, TKey = default): bool $closure <p>The predicate on which to partition.</p>

Return:

  • array<int,static> <p>An array with two elements. The first element contains the array of elements where the predicate returned TRUE, the second element contains the array of elements where the predicate returned FALSE.</p>

pop(): mixed|null

鈫 Pop a specified value off the end of the current array.

Parameters: nothing

Return:

  • mixed|null <p>(Mutable) The popped element from the current array or null if the array is e.g. empty.</p>

prepend(mixed $value, mixed $key): $this

鈫 Prepend a (key) + value to the current array.

EXAMPLE: a(['f貌么' => 'b脿艡'])->prepend('foo'); // Arrayy[0 => 'foo', 'f貌么' => 'b脿艡']

Parameters:

  • T $value
  • TKey|null $key

Return:

  • $this <p>(Mutable) Return this Arrayy object, with the prepended value.</p>

prependImmutable(mixed $value, mixed $key): $this

鈫 Prepend a (key) + value to the current array.

EXAMPLE: a(['f貌么' => 'b脿艡'])->prependImmutable('foo')->getArray(); // [0 => 'foo', 'f貌么' => 'b脿艡']

Parameters:

  • T $value
  • TKey $key

Return:

  • $this <p>(Immutable) Return this Arrayy object, with the prepended value.</p>

prependToEachKey(float|int|string $suffix): static

鈫 Add a suffix to each key.

Parameters:

  • float|int|string $suffix

Return:

  • static <p>(Immutable) Return an Arrayy object, with the prepended keys.</p>

prependToEachValue(float|int|string $suffix): static

鈫 Add a suffix to each value.

Parameters:

  • float|int|string $suffix

Return:

  • static <p>(Immutable) Return an Arrayy object, with the prepended values.</p>

pull(int|int[]|string|string[]|null $keyOrKeys, mixed $fallback): mixed

鈫 Return the value of a given key and delete the key.

Parameters:

  • int|int[]|string|string[]|null $keyOrKeys
  • mixed $fallback

Return:

  • mixed

push(mixed $args): $this

鈫 Push one or more values onto the end of array at once.

Parameters:

  • array<TKey, T> ...$args

Return:

  • $this <p>(Mutable) Return this Arrayy object, with pushed elements to the end of array.</p>

randomImmutable(int|null $number): static

鈫 Get a random value from the current array.

EXAMPLE: a([1, 2, 3, 4])->randomImmutable(2); // e.g.: Arrayy[1, 4]

Parameters:

  • int|null $number <p>How many values you will take?</p>

Return:

  • static <p>(Immutable)</p>

randomKey(): mixed

鈫 Pick a random key/index from the keys of this array.

EXAMPLE: $arrayy = A::create([1 => 'one', 2 => 'two']); $arrayy->randomKey(); // e.g. 2

Parameters: nothing

Return:

  • mixed <p>Get a key/index or null if there wasn't a key/index.</p>

randomKeys(int $number): static

鈫 Pick a given number of random keys/indexes out of this array.

EXAMPLE: a([1 => 'one', 2 => 'two'])->randomKeys(); // e.g. Arrayy[1, 2]

Parameters:

  • int $number <p>The number of keys/indexes (should be <= \count($this->array))</p>

Return:

  • static <p>(Immutable)</p>

randomMutable(int|null $number): $this

鈫 Get a random value from the current array.

EXAMPLE: a([1, 2, 3, 4])->randomMutable(2); // e.g.: Arrayy[1, 4]

Parameters:

  • int|null $number <p>How many values you will take?</p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

randomValue(): mixed

鈫 Pick a random value from the values of this array.

EXAMPLE: a([1 => 'one', 2 => 'two'])->randomValue(); // e.g. 'one'

Parameters: nothing

Return:

  • mixed <p>Get a random value or null if there wasn't a value.</p>

randomValues(int $number): static

鈫 Pick a given number of random values out of this array.

EXAMPLE: a([1 => 'one', 2 => 'two'])->randomValues(); // e.g. Arrayy['one', 'two']

Parameters:

  • int $number

Return:

  • static <p>(Mutable)</p>

randomWeighted(array $array, int $number):

Parameters:

  • array $array
  • int $number

Return:

  • self

reduce(callable $callable, mixed $initial): static

鈫 Reduce the current array via callable e.g. anonymous-function and return the end result.

EXAMPLE: a([1, 2, 3, 4])->reduce( function ($carry, $item) { return $carry * $item; }, 1 ); // Arrayy[24]

Parameters:

  • callable $callable
  • mixed $initial

Return:

  • static <p>(Immutable)</p>

reduce_dimension(bool $unique): static

Parameters:

  • bool $unique

Return:

  • static <p>(Immutable)</p>

reindex(): $this

鈫 Create a numerically re-indexed Arrayy object.

EXAMPLE: a([2 => 1, 3 => 2])->reindex(); // Arrayy[0 => 1, 1 => 2]

Parameters: nothing

Return:

  • $this <p>(Mutable) Return this Arrayy object, with re-indexed array-elements.</p>

reject(\Closure $closure): static

鈫 Return all items that fail the truth test.

EXAMPLE: $closure = function ($value) { return $value % 2 !== 0; } a([1, 2, 3, 4])->reject($closure); // Arrayy[1 => 2, 3 => 4]

Parameters:

  • \Closure(T = default, TKey = default): bool $closure

Return:

  • static <p>(Immutable)</p>

remove(mixed $key): static

鈫 Remove a value from the current array (optional using dot-notation).

EXAMPLE: a([1 => 'bar', 'foo' => 'foo'])->remove(1); // Arrayy['foo' => 'foo']

Parameters:

  • TKey $key

Return:

  • static <p>(Mutable)</p>

removeElement(mixed $element): static

鈫 alias: for "Arrayy->removeValue()"

Parameters:

  • T $element

Return:

  • static <p>(Immutable)</p>

removeFirst(): static

鈫 Remove the first value from the current array.

EXAMPLE: a([1 => 'bar', 'foo' => 'foo'])->removeFirst(); // Arrayy['foo' => 'foo']

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

removeLast(): static

鈫 Remove the last value from the current array.

EXAMPLE: a([1 => 'bar', 'foo' => 'foo'])->removeLast(); // Arrayy[1 => 'bar']

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

removeValue(mixed $value): static

鈫 Removes a particular value from an array (numeric or associative).

EXAMPLE: a([1 => 'bar', 'foo' => 'foo'])->removeValue('foo'); // Arrayy[1 => 'bar']

Parameters:

  • T $value

Return:

  • static <p>(Immutable)</p>

repeat(int $times): static

鈫 Generate array of repeated arrays.

Parameters:

  • int $times <p>How many times has to be repeated.</p>

Return:

  • static <p>(Immutable)</p>

replace(mixed $oldKey, mixed $newKey, mixed $newValue): static

鈫 Replace a key with a new key/value pair.

EXAMPLE: $arrayy = a([1 => 'foo', 2 => 'foo2', 3 => 'bar']); $arrayy->replace(2, 'notfoo', 'notbar'); // Arrayy[1 => 'foo', 'notfoo' => 'notbar', 3 => 'bar']

Parameters:

  • mixed $oldKey
  • mixed $newKey
  • mixed $newValue

Return:

  • static <p>(Immutable)</p>

replaceAllKeys(int[]|string[] $keys): static

鈫 Create an array using the current array as values and the other array as keys.

EXAMPLE: $firstArray = [ 1 => 'one', 2 => 'two', 3 => 'three', ]; $secondArray = [ 'one' => 1, 1 => 'one', 2 => 2, ]; $arrayy = a($firstArray); $arrayy->replaceAllKeys($secondArray); // Arrayy[1 => "one", 'one' => "two", 2 => "three"]

Parameters:

  • array<array-key, TKey> $keys <p>An array of keys.</p>

Return:

  • static <p>(Immutable) Arrayy object with keys from the other array, empty Arrayy object if the number of elements for each array isn't equal or if the arrays are empty. </p>

replaceAllValues(array $array): static

鈫 Create an array using the current array as keys and the other array as values.

EXAMPLE: $firstArray = [ 1 => 'one', 2 => 'two', 3 => 'three', ]; $secondArray = [ 'one' => 1, 1 => 'one', 2 => 2, ]; $arrayy = a($firstArray); $arrayy->replaceAllValues($secondArray); // Arrayy['one' => 1, 'two' => 'one', 'three' => 2]

Parameters:

  • array<array-key, T> $array <p>An array of values.</p>

Return:

  • static <p>(Immutable) Arrayy object with values from the other array, empty Arrayy object if the number of elements for each array isn't equal or if the arrays are empty. </p>

replaceKeys(array $keys): static

鈫 Replace the keys in an array with another set.

EXAMPLE: a([1 => 'bar', 'foo' => 'foo'])->replaceKeys([1 => 2, 'foo' => 'replaced']); // Arrayy[2 => 'bar', 'replaced' => 'foo']

Parameters:

  • array<array-key, TKey> $keys <p>An array of keys matching the array's size.</p>

Return:

  • static <p>(Immutable)</p>

replaceOneValue(mixed $search, mixed $replacement): static

鈫 Replace the first matched value in an array.

EXAMPLE: $testArray = ['bar', 'foo' => 'foo', 'foobar' => 'foobar']; a($testArray)->replaceOneValue('foo', 'replaced'); // Arrayy['bar', 'foo' => 'replaced', 'foobar' => 'foobar']

Parameters:

  • mixed $search <p>The value to replace.</p>
  • mixed $replacement <p>The value to replace.</p>

Return:

  • static <p>(Immutable)</p>

replaceValues(string $search, string $replacement): static

鈫 Replace values in the current array.

EXAMPLE: $testArray = ['bar', 'foo' => 'foo', 'foobar' => 'foobar']; a($testArray)->replaceValues('foo', 'replaced'); // Arrayy['bar', 'foo' => 'replaced', 'foobar' => 'replacedbar']

Parameters:

  • string $search <p>The value to replace.</p>
  • string $replacement <p>What to replace it with.</p>

Return:

  • static <p>(Immutable)</p>

rest(int $from): static

鈫 Get the last elements from index $from until the end of this array.

EXAMPLE: a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->rest(2); // Arrayy[0 => 'lall']

Parameters:

  • int $from

Return:

  • static <p>(Immutable)</p>

reverse(): $this

鈫 Return the array in the reverse order.

EXAMPLE: a([1, 2, 3])->reverse(); // self[3, 2, 1]

Parameters: nothing

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

rsort(int $sort_flags): $this

鈫 Sort an array in reverse order.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

rsortImmutable(int $sort_flags): $this

鈫 Sort an array in reverse order.

Parameters:

  • int $sort_flags [optional] <p> You may modify the behavior of the sort using the optional parameter sort_flags, for details see sort. </p>

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

searchIndex(mixed $value): false|float|int|string

鈫 Search for the first index of the current array via $value.

EXAMPLE: a(['f貌么' => 'b脿艡', 'lall' => 'b脿艡'])->searchIndex('b脿艡'); // Arrayy[0 => 'f貌么']

Parameters:

  • mixed $value

Return:

  • false|float|int|string <p>Will return <b>FALSE</b> if the value can't be found.</p>

searchValue(mixed $index): static

鈫 Search for the value of the current array via $index.

EXAMPLE: a(['f貌么' => 'b脿艡'])->searchValue('f貌么'); // Arrayy[0 => 'b脿艡']

Parameters:

  • mixed $index

Return:

  • static <p>(Immutable) Will return a empty Arrayy if the value wasn't found.</p>

serialize(): string

鈫 Serialize the current "Arrayy"-object.

EXAMPLE: a([1, 4, 7])->serialize();

Parameters: nothing

Return:

  • string

set(string $key, mixed $value): $this

鈫 Set a value for the current array (optional using dot-notation).

EXAMPLE: $arrayy = a(['Lars' => ['lastname' => 'Moelleken']]); $arrayy->set('Lars.lastname', 'M眉ller'); // Arrayy['Lars', ['lastname' => 'M眉ller']]]

Parameters:

  • TKey $key <p>The key to set.</p>
  • T $value <p>Its value.</p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

setAndGet(mixed $key, mixed $fallback): mixed

鈫 Get a value from a array and set it if it was not.

WARNING: this method only set the value, if the $key is not already set

EXAMPLE: $arrayy = a([1 => 1, 2 => 2, 3 => 3]); $arrayy->setAndGet(1, 4); // 1 $arrayy->setAndGet(0, 4); // 4

Parameters:

  • mixed $key <p>The key</p>
  • mixed $fallback <p>The default value to set if it isn't.</p>

Return:

  • mixed <p>(Mutable)</p>

setIteratorClass(string $iteratorClass): void

鈫 Sets the iterator classname for the current "Arrayy"-object.

Parameters:

  • class-string<\Arrayy\ArrayyIterator> $iteratorClass

Return:

  • void

shift(): mixed

鈫 Shifts a specified value off the beginning of array.

Parameters: nothing

Return:

  • mixed <p>(Mutable) A shifted element from the current array.</p>

shuffle(bool $secure, array $array): static

鈫 Shuffle the current array.

EXAMPLE: a([1 => 'bar', 'foo' => 'foo'])->shuffle(); // e.g.: Arrayy[['foo' => 'foo', 1 => 'bar']]

Parameters:

  • bool $secure <p>using a CSPRNG | @link https://paragonie.com/b/JvICXzh_jhLyt4y3</p>
  • array<TKey, T> $array [optional]

Return:

  • static <p>(Immutable)</p>

size(int $mode): int

鈫 Count the values from the current array.

alias: for "Arrayy->count()"

Parameters:

  • int $mode

Return:

  • int

sizeIs(int $size): bool

鈫 Checks whether array has exactly $size items.

Parameters:

  • int $size

Return:

  • bool

sizeIsBetween(int $fromSize, int $toSize): bool

鈫 Checks whether array has between $fromSize to $toSize items. $toSize can be smaller than $fromSize.

Parameters:

  • int $fromSize
  • int $toSize

Return:

  • bool

sizeIsGreaterThan(int $size): bool

鈫 Checks whether array has more than $size items.

Parameters:

  • int $size

Return:

  • bool

sizeIsLessThan(int $size): bool

鈫 Checks whether array has less than $size items.

Parameters:

  • int $size

Return:

  • bool

sizeRecursive(): int

鈫 Counts all elements in an array, or something in an object.

For objects, if you have SPL installed, you can hook into count() by implementing interface {@see \Countable}. The interface has exactly one method, {@see \Countable::count()}, which returns the return value for the count() function. Please see the {@see \Array} section of the manual for a detailed explanation of how arrays are implemented and used in PHP.

Parameters: nothing

Return:

  • int <p> The number of elements in var, which is typically an array, since anything else will have one element. </p> <p> If var is not an array or an object with implemented Countable interface, 1 will be returned. There is one exception, if var is &null;, 0 will be returned. </p> <p> Caution: count may return 0 for a variable that isn't set, but it may also return 0 for a variable that has been initialized with an empty array. Use isset to test if a variable is set. </p>

slice(int $offset, int|null $length, bool $preserveKeys): static

鈫 Extract a slice of the array.

Parameters:

  • int $offset <p>Slice begin index.</p>
  • int|null $length <p>Length of the slice.</p>
  • bool $preserveKeys <p>Whether array keys are preserved or no.</p>

Return:

  • static <p>(Immutable) A slice of the original array with length $length.</p>

sort(int|string $direction, int $strategy, bool $keepKeys): static

鈫 Sort the current array and optional you can keep the keys.

EXAMPLE: a(3 => 'd', 2 => 'f', 0 => 'a')->sort(SORT_ASC, SORT_NATURAL, false); // Arrayy[0 => 'a', 1 => 'd', 2 => 'f']

Parameters:

  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>sort_flags => use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>
  • bool $keepKeys

Return:

  • static <p>(Mutable) Return this Arrayy object.</p>

sortImmutable(int|string $direction, int $strategy, bool $keepKeys): static

鈫 Sort the current array and optional you can keep the keys.

Parameters:

  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>sort_flags => use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>
  • bool $keepKeys

Return:

  • static <p>(Immutable) Return this Arrayy object.</p>

sortKeys(int|string $direction, int $strategy): $this

鈫 Sort the current array by key.

EXAMPLE: a([1 => 2, 0 => 1])->sortKeys(\SORT_ASC); // Arrayy[0 => 1, 1 => 2]

Parameters:

  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

sortKeysImmutable(int|string $direction, int $strategy): $this

鈫 Sort the current array by key.

Parameters:

  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

sortValueKeepIndex(int|string $direction, int $strategy): static

鈫 Sort the current array by value.

EXAMPLE: a(3 => 'd', 2 => 'f', 0 => 'a')->sortValueKeepIndex(SORT_ASC, SORT_REGULAR); // Arrayy[0 => 'a', 3 => 'd', 2 => 'f']

Parameters:

  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>

Return:

  • static <p>(Mutable)</p>

sortValueNewIndex(int|string $direction, int $strategy): static

鈫 Sort the current array by value.

EXAMPLE: a(3 => 'd', 2 => 'f', 0 => 'a')->sortValueNewIndex(SORT_ASC, SORT_NATURAL); // Arrayy[0 => 'a', 1 => 'd', 2 => 'f']

Parameters:

  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>

Return:

  • static <p>(Mutable)</p>

sorter(callable|mixed|null $sorter, int|string $direction, int $strategy): static

鈫 Sort a array by value or by a closure.

  • If the sorter is null, the array is sorted naturally.
  • Associative (string) keys will be maintained, but numeric keys will be re-indexed.

EXAMPLE: $testArray = range(1, 5); $under = a($testArray)->sorter( function ($value) { return $value % 2 === 0; } ); var_dump($under); // Arrayy[1, 3, 5, 2, 4]

Parameters:

  • callable|mixed|null $sorter
  • int|string $direction <p>use <strong>SORT_ASC</strong> (default) or <strong>SORT_DESC</strong></p>
  • int $strategy <p>use e.g.: <strong>SORT_REGULAR</strong> (default) or <strong>SORT_NATURAL</strong></p>

Return:

  • static <p>(Immutable)</p>

splice(int $offset, int|null $length, array $replacement): static

Parameters:

  • int $offset
  • int|null $length
  • array<mixed, T> $replacement

Return:

  • static <p>(Immutable)</p>

split(int $numberOfPieces, bool $keepKeys): static

鈫 Split an array in the given amount of pieces.

EXAMPLE: a(['a' => 1, 'b' => 2])->split(2, true); // Arrayy[['a' => 1], ['b' => 2]]

Parameters:

  • int $numberOfPieces
  • bool $keepKeys

Return:

  • static <p>(Immutable)</p>

stripEmpty(): static

鈫 Strip all empty items from the current array.

EXAMPLE: a(['a' => 1, 'b' => ''])->stripEmpty(); // Arrayy[['a' => 1]]

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

swap(int|string $swapA, int|string $swapB): static

鈫 Swap two values between positions by key.

EXAMPLE: a(['a' => 1, 'b' => ''])->swap('a', 'b'); // Arrayy[['a' => '', 'b' => 1]]

Parameters:

  • int|string $swapA <p>a key in the array</p>
  • int|string $swapB <p>a key in the array</p>

Return:

  • static <p>(Immutable)</p>

toArray(bool $convertAllArrayyElements, bool $preserveKeys): array

鈫 Get the current array from the "Arrayy"-object.

alias for "getArray()"

Parameters:

  • bool $convertAllArrayyElements <p> Convert all Child-"Arrayy" objects also to arrays. </p>
  • bool $preserveKeys <p> e.g.: A generator maybe return the same key more then once, so maybe you will ignore the keys. </p>

Return:

  • array

toJson(int $options, int $depth): string

鈫 Convert the current array to JSON.

EXAMPLE: a(['bar', ['foo']])->toJson(); // '["bar",{"1":"foo"}]'

Parameters:

  • int $options [optional] <p>e.g. JSON_PRETTY_PRINT</p>
  • int $depth [optional] <p>Set the maximum depth. Must be greater than zero.</p>

Return:

  • string

toList(bool $convertAllArrayyElements): array

鈫 Get the current array from the "Arrayy"-object as list.

Parameters:

  • bool $convertAllArrayyElements <p> Convert all Child-"Arrayy" objects also to arrays. </p>

Return:

  • array

toPermutation(string[]|null $items, string[] $helper): static|static[]

Parameters:

  • string[]|null $items [optional]
  • string[] $helper [optional]

Return:

  • static|static[]

toString(string $separator): string

鈫 Implodes array to a string with specified separator.

Parameters:

  • string $separator [optional] <p>The element's separator.</p>

Return:

  • string <p>The string representation of array, separated by ",".</p>

uasort(callable $function): $this

鈫 Sort the entries with a user-defined comparison function and maintain key association.

Parameters:

  • callable $function

Return:

  • $this <p>(Mutable) Return this Arrayy object.</p>

uasortImmutable(callable $function): $this

鈫 Sort the entries with a user-defined comparison function and maintain key association.

Parameters:

  • callable $function

Return:

  • $this <p>(Immutable) Return this Arrayy object.</p>

uksort(callable $function): static

鈫 Sort the entries by keys using a user-defined comparison function.

Parameters:

  • callable $function

Return:

  • static <p>(Mutable) Return this Arrayy object.</p>

uksortImmutable(callable $function): static

鈫 Sort the entries by keys using a user-defined comparison function.

Parameters:

  • callable $function

Return:

  • static <p>(Immutable) Return this Arrayy object.</p>

unique(): static

鈫 alias: for "Arrayy->uniqueNewIndex()"

Parameters: nothing

Return:

  • static <p>(Mutable) Return this Arrayy object, with the appended values.</p>

uniqueKeepIndex(): $this

鈫 Return a duplicate free copy of the current array. (with the old keys)

EXAMPLE: a([2 => 1, 3 => 2, 4 => 2])->uniqueNewIndex(); // Arrayy[2 => 1, 3 => 2]

Parameters: nothing

Return:

  • $this <p>(Mutable)</p>

uniqueNewIndex(): $this

鈫 Return a duplicate free copy of the current array.

EXAMPLE: a([2 => 1, 3 => 2, 4 => 2])->uniqueNewIndex(); // Arrayy[1, 2]

Parameters: nothing

Return:

  • $this <p>(Mutable)</p>

unserialize(string $string): $this

鈫 Unserialize an string and return the instance of the "Arrayy"-class.

EXAMPLE: $serialized = a([1, 4, 7])->serialize(); a()->unserialize($serialized);

Parameters:

  • string $string

Return:

  • $this

unshift(mixed $args): $this

鈫 Prepends one or more values to the beginning of array at once.

Parameters:

  • array<TKey, T> ...$args

Return:

  • $this <p>(Mutable) Return this Arrayy object, with prepended elements to the beginning of array.</p>

validate(\Closure $closure): bool

鈫 Tests whether the given closure return something valid for all elements of this array.

Parameters:

  • \Closure(T = default, TKey = default): bool $closure the predicate

Return:

  • bool <p>TRUE, if the predicate yields TRUE for all elements, FALSE otherwise.</p>

values(): static

鈫 Get all values from a array.

EXAMPLE: $arrayy = a([1 => 'foo', 2 => 'foo2', 3 => 'bar']); $arrayyTmp->values(); // Arrayy[0 => 'foo', 1 => 'foo2', 2 => 'bar']

Parameters: nothing

Return:

  • static <p>(Immutable)</p>

walk(callable $callable, bool $recursive, mixed $userData): $this

鈫 Apply the given function to every element in the array, discarding the results.

EXAMPLE: $callable = function (&$value, $key) { $value = $key; }; $arrayy = a([1, 2, 3]); $arrayy->walk($callable); // Arrayy[0, 1, 2]

Parameters:

  • callable $callable
  • bool $recursive [optional] <p>Whether array will be walked recursively or no</p>
  • mixed $userData [optional] <p> If the optional $userData parameter is supplied, it will be passed as the third parameter to the $callable. </p>

Return:

  • $this <p>(Mutable) Return this Arrayy object, with modified elements.</p>

where(string $keyOrPropertyOrMethod, mixed $value): static

鈫 Returns a collection of matching items.

Parameters:

  • string $keyOrPropertyOrMethod the property or method to evaluate
  • mixed $value the value to match

Return:

  • static

Support

For support and donations please visit Github | Issues | PayPal | Patreon.

For status updates and release announcements please visit Releases | Twitter | Patreon.

For professional support please contact me.

Thanks

  • Thanks to GitHub (Microsoft) for hosting the code and a good infrastructure including Issues-Managment, etc.
  • Thanks to IntelliJ as they make the best IDEs for PHP and they gave me an open source license for PhpStorm!
  • Thanks to Travis CI for being the most awesome, easiest continous integration tool out there!
  • Thanks to StyleCI for the simple but powerfull code style check.
  • Thanks to PHPStan && Psalm for relly great Static analysis tools and for discover bugs in the code!

Tests

From the project directory, tests can be ran using phpunit

License

Released under the MIT License - see LICENSE.txt for details.


*Note that all licence references and agreements mentioned in the Arrayy README section above are relevant to that project's source code only.