A PHP array manipulation library. Compatible with PHP 8+
\Arrayy\Type\StringCollection::create(['Array', 'Array'])->unique()->append('y')->implode() // Arrayy
- Installation
- Multidimensional ArrayAccess
- PhpDoc array-shape / property checking
- OO and Chaining
- Collections
- Class methods
- Instance methods
- Tests
- License
composer require voku/arrayyYou can access / change the array via Object, Array or with "Arrayy"-syntax.
$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);
$arrayy->get('Lars'); // ['lastname' => 'Moelleken']
$arrayy->get('Lars.lastname'); // 'Moelleken'$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);
$arrayy['Lars']; // ['lastname' => 'Moelleken']
$arrayy['Lars']['lastname']; // 'Moelleken'$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);
$arrayy->Lars; // Arrayy['lastname' => 'Moelleken']
$arrayy->Lars->lastname; // 'Moelleken'$arrayy = new A(['Lars' => ['lastname' => 'Mueller']]);
$arrayy->set('Lars.lastname', 'Moelleken');
$arrayy->get('Lars.lastname'); // 'Moelleken'$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);
$arrayy['Lars'] = array('lastname' => 'MΓΌller');
$arrayy['Lars']['lastname']; // 'MΓΌller'$arrayy = new A(['Lars' => ['lastname' => 'Moelleken']]);
$arrayy->Lars = array('lastname' => 'MΓΌller');
$arrayy->Lars->lastname; // 'MΓΌller'The library offers type checking for phpdoc array-shape annotations, legacy @property phpdoc-class-comments, and native declared properties. Prefer the array-shape form because it can reuse the Arrayy template for IDE autocompletion and static-analysis support. When you want PHPStan to check reads precisely, prefer array-like access with literal keys (for example $user['lastName']) on these array-shape-based models. Do not combine array-shape annotations and @property tags on the same model.
/**
* @template T of array{id: int, firstName: int|string, lastName: string, city?: City|null}
* @extends \Arrayy\Arrayy<key-of<T>,value-of<T>,T>
*/
class User extends \Arrayy\Arrayy
{
protected $checkPropertyTypes = true;
protected $checkPropertiesMismatchInConstructor = true;
}
/**
* @template T of array{plz: string|null, name: string, infos: string[]}
* @extends \Arrayy\Arrayy<key-of<T>,value-of<T>,T>
*/
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' // preferred for PHPStan-checked reads
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ΓΌsseldorfNative typed properties also work with meta() and createFromJsonMapper(), e.g.:
class NativeCity extends \Arrayy\Arrayy
{
protected $checkPropertyTypes = true;
protected ?string $plz;
protected string $name;
/** @var string[] */
protected array $infos;
}
$nativeMeta = NativeCity::meta();
NativeCity::createFromJsonMapper(
'{"name":"DΓΌsseldorf","plz":null,"infos":["foo","bar"]}'
);
var_dump($nativeMeta->infos); // 'infos'- "checkPropertyTypes": activate the type checking for all defined array-shape keys,
@propertytags, and native declared properties - "checkPropertiesMismatchInConstructor": activate the property mismatch check, so you can only add an array with all needed properties (or an empty array) into the constructor
- use a property-level
@varannotation such as/** @var string[] */if a nativearrayproperty needs element-type validation
The library also offers OO method chaining, as seen below:
simple example:
echo a(['fΓ²Γ΄', 'bΓ Ε', 'bΓ Ε'])->unique()->reverse()->implode(','); // 'bΓ Ε,fΓ²Γ΄'complex example:
/**
* @template T of array{id: int, firstName: string, lastName: string}
* @extends \Arrayy\Arrayy<key-of<T>,value-of<T>,T>
*/
class User extends \Arrayy\Arrayy
{
protected $checkPropertyTypes = true;
protected $checkPropertiesMismatchInConstructor = true;
}
/**
* @template TKey of array-key
* @extends AbstractCollection<TKey,User>
*/
class UserCollection extends \Arrayy\Collection\AbstractCollection
{
/**
* The type (FQCN) associated with this collection.
*
* @return string
*/
public function getType()
{
return User::class;
}
}
$m = User::meta();
$data = static function () use ($m) {
yield new User([$m->id => 40, $m->firstName => 'Foo', $m->lastName => 'Moelleken']);
yield new User([$m->id => 30, $m->firstName => 'Sven', $m->lastName => 'Moelleken']);
yield new User([$m->id => 20, $m->firstName => 'Lars', $m->lastName => 'Moelleken']);
yield new User([$m->id => 10, $m->firstName => 'Lea', $m->lastName => 'Moelleken']);
};
$users = UserCollection::createFromGeneratorFunction($data);
$names = $users
->filter(static function (User $user): bool {
return $user->id <= 30;
})
->customSortValuesImmutable(static function (User $a, User $b): int {
return $a->firstName <=> $b->firstName;
})
->map(static function (User $user): string {
return $user->firstName;
})
->implode(';');
static::assertSame('Lars;Lea;Sven', $names);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); // 2On supported PHP 8.0+ versions, use function
can be used to import helper functions. Arrayy exposes the namespaced function
Arrayy\create, which behaves the same as Arrayy\Arrayy::create().
You can alias it to a for a shorter and more readable API:
use function Arrayy\create as a;
// Instead of: A::create(['fΓ²Γ΄', 'bΓ Ε'])->reverse()->implode();
a(['fΓ²Γ΄', 'bΓ Ε'])->reverse()->implode(','); // 'bΓ Ε,fΓ²Γ΄'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.
$YOURcollection->get('3123.foo.bar');
This will throw a "TypeError"-Exception.
use Arrayy\Type\StringCollection;
$collection = new StringCollection(['A', 'B', 'C', 1]);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]]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'Creates an Arrayy object.
$arrayy = new Arrayy(array('fΓ²Γ΄', 'bΓ Ε')); // Arrayy['fΓ²Γ΄', 'bΓ Ε']Creates an Arrayy object, via static "create()"-method
$arrayy = A::create(array('fΓ²Γ΄', 'bΓ Ε')); // Arrayy['fΓ²Γ΄', 'bΓ Ε']WARNING: Creates an Arrayy object by reference.
$array = array('fΓ²Γ΄', 'bΓ Ε');
$arrayy = A::createByReference($array); // Arrayy['fΓ²Γ΄', 'bΓ Ε']Create an new Arrayy object via JSON.
$str = '{"firstName":"John", "lastName":"Doe"}';
$arrayy = A::createFromJson($str); // Arrayy['firstName' => 'John', 'lastName' => 'Doe']Create an new Arrayy object via JSON and fill sub-objects is possible.
<?php
namespace Arrayy\tests;
/**
* @template T of array{id: int, firstName: int|string, lastName: string, city?: \Arrayy\tests\CityData|null}
* @extends \Arrayy\Arrayy<key-of<T>,value-of<T>,T>
*/
class UserData extends \Arrayy\Arrayy
{
protected $checkPropertyTypes = true;
protected $checkForMissingPropertiesInConstructor = true;
}
/**
* @template T of array{plz: string|null, name: string, infos: string[]}
* @extends \Arrayy\Arrayy<key-of<T>,value-of<T>,T>
*/
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'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']Create an new instance filled with values from an object.
$object = new stdClass();
$object->x = 42;
$arrayy = A::createFromObjectVars($object); // Arrayy['x' => 42]Create an new instance containing a range of elements.
$arrayy = A::createWithRange(2, 4); // Arrayy[2, 3, 4]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]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]Create an new Arrayy object via string.
$arrayy = A::createFromString(' foo, bar '); // Arrayy['foo', 'bar']Arrayy: All examples below use the helper-function import shown above together with short array syntax. For further details, see the documentation for the create method above and the notes on the function import shortcut.
$arrayy = a(['fΓ²Γ΄' => 'bΓ Ε']);
$arrayy['foo'] = 'bar';
var_dump($arrayy); // Arrayy['fΓ²Γ΄' => 'bΓ Ε', 'foo' => 'bar']$arrayy = a(['fΓ²Γ΄' => 'bΓ Ε']);
var_dump($arrayy['fΓ²Γ΄']); // 'bΓ Ε'$arrayy = a(['fΓ²Γ΄' => 'bΓ Ε']);
var_dump($arrayy->getArray()); // ['fΓ²Γ΄' => 'bΓ Ε']$arrayy = a(['fΓ²Γ΄' => 'bΓ Ε', 'lall']);
unset($arrayy['fΓ²Γ΄']);
var_dump($arrayy); // Arrayy[0 => 'lall']$arrayy = a(['fΓ²Γ΄' => 'bΓ Ε']);
isset($arrayy['fΓ²Γ΄']); // true$arrayy = a(['fΓ²Γ΄' => 'bΓ Ε']);
foreach ($arrayy) as $key => $value) {
echo $key . ' | ' . $value; // fΓ²Γ΄ | bΓ Ε
}β Add new values (optional using dot-notation).
Parameters:
mixed $valueint|string|null $key
Return:
static <p>(Immutable) Return this Arrayy object, with the appended values.</p>
β Append a (key) + value to the current array.
EXAMPLE:
a(['fΓ²Γ΄' => 'bΓ Ε'])->append('foo'); // Arrayy['fΓ²Γ΄' => 'bΓ Ε', 0 => 'foo']
Parameters:
mixed $valuemixed $key
Return:
$this <p>(Mutable) Return this Arrayy object, with the appended values.</p>
β Append a (key) + values to the current array.
EXAMPLE:
a(['fΓ²Γ΄' => ['bΓ Ε']])->appendArrayValues(['foo1', 'foo2'], 'fΓ²Γ΄'); // Arrayy['fΓ²Γ΄' => ['bΓ Ε', 'foo1', 'foo2']]
Parameters:
array $valuesmixed $key
Return:
$this <p>(Mutable) Return this Arrayy object, with the appended values.</p>
β Append a (key) + value to the current array.
EXAMPLE:
a(['fΓ²Γ΄' => 'bΓ Ε'])->appendImmutable('foo')->getArray(); // ['fΓ²Γ΄' => 'bΓ Ε', 0 => 'foo']
Parameters:
mixed $valuemixed $key
Return:
$this <p>(Immutable) Return this Arrayy object, with the appended values.</p>
β Add a suffix to each key.
Parameters:
int|string $prefix
Return:
static <p>(Immutable) Return an Arrayy object, with the prefixed keys.</p>
β Add a prefix to each value.
Parameters:
float|int|string $prefix
Return:
static <p>(Immutable) Return an Arrayy object, with the prefixed values.</p>
β Sort an array in reverse order and maintain index association.
Parameters: nothing
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Sort an array in reverse order and maintain index association.
Parameters: nothing
Return:
$this <p>(Immutable) Return this Arrayy object.</p>
β 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>
β 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>
β 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>
β 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>
β 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>
β Change the path separator of the array wrapper.
By default, the separator is: "."
Parameters:
non-empty-string $separator <p>Separator to set.</p>
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β 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|static[] <p>(Immutable) A new array of chunks from the original array.</p>
β 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>
β 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>
β Check if an item is in the current array.
EXAMPLE:
a([1, true])->contains(true); // true
Parameters:
float|int|string $valuebool $recursivebool $strict
Return:
bool
β Check if an (case-insensitive) string is in the current array.
EXAMPLE:
a(['E', 'Γ©'])->containsCaseInsensitive('Γ'); // true
Parameters:
mixed $valuebool $recursive
Return:
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>
β Check if all given needles are present in the array as key/index.
EXAMPLE:
a([1 => true])->containsKeys(array(1 => 0)); // true
Parameters:
array $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>
β Check if all given needles are present in the array as key/index.
Parameters:
array $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>
β Check if an item is in the current array.
EXAMPLE:
a([1, true])->containsOnly(true); // false
Parameters:
float|int|string $valuebool $recursivebool $strict
Return:
bool
β alias: for "Arrayy->contains()"
Parameters:
float|int|string $value
Return:
bool
β alias: for "Arrayy->contains($value, true)"
Parameters:
float|int|string $value
Return:
bool
β Check if all given needles are present in the array.
EXAMPLE:
a([1, true])->containsValues(array(1, true)); // true
Parameters:
array $needles
Return:
bool <p>Returns true if all the given values exists in the array, false otherwise.</p>
β 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>
β 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>
β Creates an Arrayy object.
Parameters:
mixed $datastring $iteratorClassbool $checkPropertiesInConstructor
Return:
static <p>(Immutable) Returns an new instance of the Arrayy object.</p>
β WARNING: Creates an Arrayy object by reference.
Parameters:
array $array
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Create an new Arrayy object via JSON.
Parameters:
array $array
Return:
static <p>(Immutable) Returns an new instance of the Arrayy object.</p>
β Create an new instance from a callable function which will return an Generator.
Parameters:
callable $generatorFunction
Return:
static <p>(Immutable) Returns an new instance of the Arrayy object.</p>
β Create an new instance filled with a copy of values from a "Generator"-object.
Parameters:
\Generator $generator
Return:
static <p>(Immutable) Returns an new instance of the Arrayy object.</p>
β Create an new Arrayy object via JSON.
Parameters:
string $json
Return:
static <p>(Immutable) Returns an new instance of the Arrayy object.</p>
β Create an instance from JSON using the built-in mapper.
For Arrayy models with property checks enabled, phpdoc array-shape annotations,
legacy @property definitions, and native declared properties are used for metadata and type checks.
Add a property-level @var annotation if a native array property also needs
element-type validation.
Parameters:
string $json
Return:
static <p>(Immutable)</p>
β Create an new instance filled with values from an object that is iterable.
Parameters:
\Traversable $object <p>iterable object</p>
Return:
static <p>(Immutable) Returns an new instance of the Arrayy object.</p>
β 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>
β Create an new Arrayy object via string.
Parameters:
string $str <p>The input string.</p>non-empty-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>
β Create an new instance filled with a copy of values from a "Traversable"-object.
Parameters:
\Traversable $traversablebool $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>
β 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>
β Gets the element of the array at the current internal iterator position.
Parameters: nothing
Return:
false|mixed
β 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 $callable
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Custom sort by index via "uksort".
Parameters:
callable $callable
Return:
$this <p>(Immutable) Return this Arrayy object.</p>
β 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[1, 2, 3]
Parameters:
callable $callable
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Custom sort by value via "usort".
Parameters:
callable $callable
Return:
$this <p>(Immutable) Return this Arrayy object.</p>
β Delete the given key or keys.
Parameters:
int|int[]|string|string[] $keyOrKeys
Return:
void
β 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 ...$array
Return:
static <p>(Immutable)</p>
β Return elements where the keys are only in the current array.
Parameters:
array ...$array
Return:
static <p>(Immutable)</p>
β Return elements where the values and keys are only in the current array.
Parameters:
array ...$array
Return:
static <p>(Immutable)</p>
β 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 $arrayarray|\Generator|null $helperVariableForRecursion <p>(only for internal usage)</p>
Return:
static <p>(Immutable)</p>
β 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 $array
Return:
static <p>(Immutable)</p>
β 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>
β 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 $closure
Return:
static <p>(Immutable)</p>
β Sets the internal iterator to the last element in the array and returns this element.
Parameters: nothing
Return:
false|mixed
β Exchange the array for another one.
Parameters:
array|mixed|static $data 1. use the current array, if it's a array 2. fallback to empty array, if there is nothing 3. call "getArray()" on object, if there is a "Arrayy"-object 4. call "createFromObject()" on object, if there is a "\Traversable"-object 5. call "__toArray()" on object, if the method exists 6. cast a string or object with "__toString()" into an array 7. throw a "InvalidArgumentException"-Exception
Return:
array
β 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 $closure
Return:
bool <p>Returns true if the given value is found, false otherwise.</p>
β Fill the array until "$num" with "$default" values.
EXAMPLE:
a(['bar'])->fillWithDefaults(3, 'foo'); // Arrayy['bar', 'foo', 'foo']
Parameters:
int $nummixed $default
Return:
static <p>(Immutable)</p>
β 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:
\Closure|null $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>
β Filters an array of objects (or a numeric array of associative arrays) based on the value of a particular property within that.
Parameters:
string $propertymixed $valuestring|null $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 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 $closure
Return:
false|mixed <p>Return false if we did not find the value.</p>
β 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 $propertymixed $valuestring $comparisonOp
Return:
static <p>(Immutable)</p>
β Find the key of 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'])->findKey($closure); // 0
Parameters:
\Closure $closure
Return:
false|int|string <p>Return false if we did not find the key.</p>
β 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>
β Get the first key from the current array.
Parameters: nothing
Return:
mixed|null <p>Return null if there wasn't a element.</p>
β 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>
β 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>
β 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 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 $delimiterstring $prependarray|null $items
Return:
array
β 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 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:
int|string $key <p>The key to look for.</p>mixed $fallback <p>Value to fallback to.</p>array|null $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
β alias: for "Arrayy->toArray()"
Parameters: nothing
Return:
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 than once, so maybe you will ignore the keys. </p>
Return:
array
β Creates a copy of the ArrayyObject.
Parameters: nothing
Return:
array
β Get the current array from the "Arrayy"-object as generator.
Parameters: nothing
Return:
Generator
β 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 $columnKeyint|string|null $indexKey
Return:
static <p>(Immutable)</p>
Parameters: nothing
Return:
TODO: __not_detected__
β Get the current array from the "Arrayy"-object as generator.
Parameters: nothing
Return:
Generator
β Get the current array from the "Arrayy"-object as generator by reference.
Parameters: nothing
Return:
Generator
β Returns a new iterator, thus implementing the \Iterator interface.
EXAMPLE:
a(['foo', 'bar'])->getIterator(); // ArrayyIterator['foo', 'bar']
Parameters: nothing
Return:
Iterator<mixed, mixed>
β Gets the iterator classname for the ArrayObject.
Parameters: nothing
Return:
string
β alias: for "Arrayy->keys()"
Parameters: nothing
Return:
static <p>(Immutable)</p>
β 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
β Get the current array from the "Arrayy"-object as object.
Parameters: nothing
Return:
stdClass
getPhpDocPropertiesFromClass(): array<array-key, \TypeCheckInterface>|\TypeCheckArray<array-key, \TypeCheckInterface>
Parameters: nothing
Return:
array<array-key, \TypeCheckInterface>|\TypeCheckArray<array-key, \TypeCheckInterface>
β alias: for "Arrayy->randomImmutable()"
Parameters: nothing
Return:
static <p>(Immutable)</p>
β alias: for "Arrayy->randomKey()"
Parameters: nothing
Return:
mixed|null <p>Get a key/index or null if there wasn't a key/index.</p>
β alias: for "Arrayy->randomKeys()"
Parameters:
int $number
Return:
static <p>(Immutable)</p>
β alias: for "Arrayy->randomValue()"
Parameters: nothing
Return:
mixed|null <p>Get a random value or null if there wasn't a value.</p>
β alias: for "Arrayy->randomValues()"
Parameters:
int $number
Return:
static <p>(Immutable)</p>
β 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>
β Gets all values via Generator.
Parameters: nothing
Return:
Generator
β Group values from a array according to the results of a closure.
Parameters:
callable|int|string $grouper <p>A callable function name.</p>bool $saveKeys
Return:
static <p>(Immutable)</p>
β Check if an array has a given key.
Parameters:
mixed $key
Return:
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
β Implodes the values of this array.
EXAMPLE:
a([0 => -9, 1, 2])->implode('|'); // '-9|1|2'
Parameters:
string $gluestring $prefix
Return:
string
β Implodes the keys of this array.
Parameters:
string $glue
Return:
string
β 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:
int|string $key
Return:
static <p>(Immutable)</p>
β alias: for "Arrayy->searchIndex()"
Parameters:
mixed $value <p>The value to search for.</p>
Return:
false|int|string
β 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>
β Return an array with all elements found in input array.
EXAMPLE:
a(['foo', 'bar'])->intersection(['bar', 'baz']); // Arrayy['bar']
Parameters:
array $searchbool $keepKeys
Return:
static <p>(Immutable)</p>
β Return an array with all elements found in input array.
Parameters:
array ...$array
Return:
static <p>(Immutable)</p>
β 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 $search
Return:
bool
β Invoke a function on all of an array's values.
Parameters:
callable $callablemixed $arguments
Return:
static <p>(Immutable)</p>
β 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>
β 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>
β Check if the current array is equal to the given "$array" or not.
EXAMPLE:
a(['π©'])->isEqual(['π©']); // true
Parameters:
array $array
Return:
bool
β Check if the current array is a multi-array.
EXAMPLE:
a(['foo' => [1, 2 , 3]])->isMultiArray(); // true
Parameters: nothing
Return:
bool
β Check whether array is numeric or not.
Parameters: nothing
Return:
bool <p>Returns true if numeric, false otherwise.</p>
β 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
Parameters: nothing
Return:
array
β Gets the key/index of the element at the current internal iterator position.
Parameters: nothing
Return:
int|string|null
β 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
β 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>
β 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>
β 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)</p>
β 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>
β 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>
β 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>
β Get the last key from the current array.
Parameters: nothing
Return:
mixed|null <p>Return null if there wasn't a element.</p>
β 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>
β 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>
β Count the values from the current array.
alias: for "Arrayy->count()"
Parameters:
int $mode
Return:
int
β 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 $callablebool $useKeyAsSecondParametermixed ...$arguments
Return:
static <p>(Immutable) Arrayy object with modified elements.</p>
β 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 $closure
Return:
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 $closure
Return:
bool
β 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>
β 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 $arraybool $recursive
Return:
static <p>(Immutable)</p>
β 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 $arraybool $recursive
Return:
static <p>(Immutable)</p>
β 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 $arraybool $recursive
Return:
static <p>(Immutable)</p>
β 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 $arraybool $recursive
Return:
static <p>(Immutable)</p>
β
Return a meta object with property names from phpdoc array-shape annotations,
@property tags, and native declared properties.
Parameters: nothing
Return:
ArrayyMeta|mixed|static
β 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>
β Get the most used value from the array.
Parameters: nothing
Return:
mixed|null <p>(Immutable) Return null if there wasn't an element.</p>
β 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>
β 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 $fromint $to
Return:
static <p>(Immutable)</p>
β 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>
β 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>
β Sort an array using a case insensitive "natural order" algorithm.
Parameters: nothing
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Sort an array using a case insensitive "natural order" algorithm.
Parameters: nothing
Return:
$this <p>(Immutable) Return this Arrayy object.</p>
β Sort entries using a "natural order" algorithm.
Parameters: nothing
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Sort entries using a "natural order" algorithm.
Parameters: nothing
Return:
$this <p>(Immutable) Return this Arrayy object.</p>
β 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>
β Get the next nth keys and values from the array.
Parameters:
int $stepint $offset
Return:
static <p>(Immutable)</p>
β Whether or not an offset exists.
Parameters:
bool|int|string $offset
Return:
bool
β Returns the value at specified offset.
Parameters:
int|string $offset
Return:
mixed <p>Will return null if the offset did not exists.</p>
β Assigns a value to the specified offset + check the type.
Parameters:
int|string|null $offsetmixed $value
Return:
void
β Unset an offset.
Parameters:
int|string $offset
Return:
void <p>(Mutable) Return nothing.</p>
β Get a subset of the items from the given array.
Parameters:
int[]|string[] $keys
Return:
static <p>(Immutable)</p>
β 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>
β Partitions this array in two array according to a predicate.
Keys are preserved in the resulting array.
Parameters:
\Closure $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 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 a (key) + value to the current array.
EXAMPLE:
a(['fΓ²Γ΄' => 'bΓ Ε'])->prepend('foo'); // Arrayy[0 => 'foo', 'fΓ²Γ΄' => 'bΓ Ε']
Parameters:
mixed $valuemixed $key
Return:
$this <p>(Mutable) Return this Arrayy object, with the prepended value.</p>
β Prepend a (key) + value to the current array.
EXAMPLE:
a(['fΓ²Γ΄' => 'bΓ Ε'])->prependImmutable('foo')->getArray(); // [0 => 'foo', 'fΓ²Γ΄' => 'bΓ Ε']
Parameters:
mixed $valuemixed $key
Return:
$this <p>(Immutable) Return this Arrayy object, with the prepended value.</p>
β Add a suffix to each key.
Parameters:
float|int|string $suffix
Return:
static <p>(Immutable) Return an Arrayy object, with the prepended keys.</p>
β Add a suffix to each value.
Parameters:
float|int|string $suffix
Return:
static <p>(Immutable) Return an Arrayy object, with the prepended values.</p>
β Return the value of a given key and delete the key.
Parameters:
int|int[]|string|string[]|null $keyOrKeysmixed $fallback
Return:
mixed
β Push one or more values onto the end of array at once.
Parameters:
mixed ...$args
Return:
$this <p>(Mutable) Return this Arrayy object, with pushed elements to the end of array.</p>
β 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>
β 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|null <p>Get a key/index or null if there wasn't a key/index.</p>
β 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>
β 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>
β 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>
β 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>
β Get a random value from an array, with the ability to skew the results.
EXAMPLE:
a([0 => 3, 1 => 4])->randomWeighted([1 => 4]); // e.g.: Arrayy[4] (has a 66% chance of returning 4)
Parameters:
array $arrayint|null $number <p>How many values you will take?</p>
Return:
static <p>(Immutable)</p>
β 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 $callablemixed $initial
Return:
static <p>(Immutable)</p>
Parameters:
bool $unique
Return:
static <p>(Immutable)</p>
β 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>
β 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 $closure
Return:
static <p>(Immutable)</p>
β Remove a value from the current array (optional using dot-notation).
EXAMPLE:
a([1 => 'bar', 'foo' => 'foo'])->remove(1); // Arrayy['foo' => 'foo']
Parameters:
mixed $key
Return:
static <p>(Mutable)</p>
β alias: for "Arrayy->removeValue()"
Parameters:
mixed $element
Return:
static <p>(Immutable)</p>
β 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>
β 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>
β Removes a particular value from an array (numeric or associative).
EXAMPLE:
a([1 => 'bar', 'foo' => 'foo'])->removeValue('foo'); // Arrayy[1 => 'bar']
Parameters:
mixed $value
Return:
static <p>(Immutable)</p>
β Generate array of repeated arrays.
Parameters:
int $times <p>How many times has to be repeated.</p>
Return:
static <p>(Immutable)</p>
β 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 $oldKeymixed $newKeymixed $newValue
Return:
static <p>(Immutable)</p>
β 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:
int[]|string[] $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>
β 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 <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>
β 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 $keys <p>An array of keys matching the array's size.</p>
Return:
static <p>(Immutable)</p>
β 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>
β 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>
β 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>
β Return the array in the reverse order.
EXAMPLE:
a([1 => 1, 2 => 2, 3 => 3])->reverse(); // self[3, 2, 1]
Parameters: nothing
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Return the array with keys in the reverse order.
EXAMPLE:
a([1 => 1, 2 => 2, 3 => 3])->reverse(); // self[3 => 3, 2 => 2, 1 => 1]
Parameters: nothing
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β 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>
β 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>
β 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|int|string <p>Will return <b>FALSE</b> if the value can't be found.</p>
β 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 the current "Arrayy"-object.
EXAMPLE:
a([1, 4, 7])->serialize();
Parameters: nothing
Return:
string
β 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:
string $key <p>The key to set.</p>mixed $value <p>Its value.</p>
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β 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>
Parameters:
int $flags
Return:
TODO: __not_detected__
β Sets the iterator classname for the current "Arrayy"-object.
Parameters:
string $iteratorClass
Return:
void
β Shifts a specified value off the beginning of array.
Parameters: nothing
Return:
mixed|null <p>(Mutable) A shifted element from the current array.</p>
β 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 | @see https://paragonie.com/b/JvICXzh_jhLyt4y3</p>array|null $array [optional]
Return:
static <p>(Immutable)</p>
β Count the values from the current array.
alias: for "Arrayy->count()"
Parameters:
int $mode
Return:
int
β Checks whether array has exactly $size items.
Parameters:
int $size
Return:
bool
β Checks whether array has between $fromSize to $toSize items. $toSize can be smaller than $fromSize.
Parameters:
int $fromSizeint $toSize
Return:
bool
β Checks whether array has more than $size items.
Parameters:
int $size
Return:
bool
β Checks whether array has less than $size items.
Parameters:
int $size
Return:
bool
β 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>
β 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 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>
β 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>
β 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>
β 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>
β 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>
β 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>
β 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 $sorterint|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>
Parameters:
int $offsetint|null $lengtharray $replacement
Return:
static <p>(Immutable)</p>
β 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 $numberOfPiecesbool $keepKeys
Return:
static <p>(Immutable)</p>
β 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 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>
β 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 than once, so maybe you will ignore the keys. </p>
Return:
array
β 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
β 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
Parameters:
string[]|null $items [optional]string[] $helper [optional]
Return:
static|static[]
β 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>
β Sort the entries with a user-defined comparison function and maintain key association.
Parameters:
callable $callable
Return:
$this <p>(Mutable) Return this Arrayy object.</p>
β Sort the entries with a user-defined comparison function and maintain key association.
Parameters:
callable $callable
Return:
$this <p>(Immutable) Return this Arrayy object.</p>
β Sort the entries by keys using a user-defined comparison function.
Parameters:
callable $callable
Return:
static <p>(Mutable) Return this Arrayy object.</p>
β Sort the entries by keys using a user-defined comparison function.
Parameters:
callable $callable
Return:
static <p>(Immutable) Return this Arrayy object.</p>
β alias: for "Arrayy->uniqueNewIndex()"
Parameters: nothing
Return:
static <p>(Mutable) Return this Arrayy object, with the appended values.</p>
β 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>
β 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 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
β Prepends one or more values to the beginning of array at once.
Parameters:
mixed ...$args
Return:
$this <p>(Mutable) Return this Arrayy object, with prepended elements to the beginning of array.</p>
β Tests whether the given closure return something valid for all elements of this array.
Parameters:
\Closure $closure the predicate
Return:
bool <p>TRUE, if the predicate yields TRUE for all elements, FALSE otherwise.</p>
β 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>
β 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 $callablebool $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>
β Returns a collection of matching items.
Parameters:
string $keyOrPropertyOrMethod <p>The property or method to evaluate.</p>mixed $value <p>The value to match.</p>
Return:
static
Parameters:
null|mixed $value
Return:
TODO: __not_detected__
Parameters:
int $flags
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters:
array|object $array
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters:
int $flags
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters:
null|mixed $key
Return:
TODO: __not_detected__
Parameters:
null|mixed $key
Return:
TODO: __not_detected__
Parameters:
null|mixed $keynull|mixed $value
Return:
TODO: __not_detected__
Parameters:
null|mixed $key
Return:
TODO: __not_detected__
Parameters: nothing
Return:
TODO: __not_detected__
Parameters:
int $flags
Return:
TODO: __not_detected__
Parameters:
string $iteratorClass
Return:
TODO: __not_detected__
Parameters:
callable $callback
Return:
TODO: __not_detected__
Parameters:
callable $callback
Return:
TODO: __not_detected__
Parameters:
string $data
Return:
TODO: __not_detected__
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 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!
From the project directory, tests can be ran using phpunit
Released under the MIT License - see LICENSE.txt for details.
