README

🗃 Arrayy

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

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

安装
多维 ArrayAccess
PhpDoc @property 检查
面向对象和链式操作
集合
- 预定义类型化集合
- 将 JSON 数据转换为集合
类方法
实例方法
测试
许可

通过 "composer require" 安装

composer require voku/arrayy

多维 ArrayAccess

您可以通过对象、数组或 "Arrayy" 语法访问/更改数组。

通过 "Arrayy" 语法访问： (点符号)

$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" 语法设置值： (点符号)

$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'

PhpDoc @property 检查

该库提供对 @property phpdoc-class-comments 的类型检查，如下所示

/**
 * @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"：激活对类 phpdoc 中所有定义的 @property 的类型检查
"checkPropertiesMismatchInConstructor"：激活属性不匹配检查，因此只能将具有所有必需属性（或空数组）的数组添加到构造函数中

面向对象和链式操作

该库还提供面向对象的链式方法，如下所示

简单示例

echo a(['fòô', 'bàř', 'bàř'])->unique()->reverse()->implode(','); // 'bàř,fòô'

复杂示例

/**
 * @property int    $id
 * @property string $firstName
 * @property string $lastName
 *
 * @extends  \Arrayy\Arrayy<array-key,mixed>
 */
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 实现了 IteratorAggregate 接口，这意味着可以使用类的实例与 foreach 一起使用

$arrayy = a(['fòôbàř', 'foo']);
foreach ($arrayy as $value) {
    echo $value;
}
// 'fòôbàř'
// 'foo'

它实现了 Countable 接口，允许使用 count() 获取数组中的元素数量

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

PHP 5.6 创建

从 PHP 5.6 开始，use function 可用于导入函数。Arrayy 公开了一个命名空间函数 Arrayy\create，其行为与 Arrayy\Arrayy::create() 相同。如果运行 PHP 5.6 或其他支持 use function 语法的运行时，您可以利用更简单的 API，如下所示

use function Arrayy\create as a;

// Instead of: A::create(['fòô', 'bàř'])->reverse()->implode();
a(['fòô', 'bàř'])->reverse()->implode(','); // 'bàř,fòô'

集合

如果您需要将对象分组在一起，使用简单的数组或 Arrayy 对象不是一个好主意。对于这些情况，您可以使用 AbstractCollection 类。

如果您尝试向集合中添加无效的对象，它将抛出 InvalidArgumentException。

例如："YOURCollection.php"（请参阅 GitHub 上的示例 /tests/CollectionTest.php）

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
    }
}

您还可以使用 "点符号" 从您的集合中获取数据，例如 $YOURcollection->get('3123.foo.bar');

预定义类型化集合

简单示例

这将抛出 "TypeError" 异常。

use Arrayy\Type\StringCollection;

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

复杂示例

这不会抛出 "TypeError" 异常。

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]]

将 JSON 数据转换为对象（集合）

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'

类方法

使用 "默认对象"

创建一个 Arrayy 对象。

$arrayy = new Arrayy(array('fòô', 'bàř')); // Arrayy['fòô', 'bàř']

create(array $array) : Arrayy (不可变)

通过静态 "create()" 方法创建一个 Arrayy 对象

$arrayy = A::create(array('fòô', 'bàř')); // Arrayy['fòô', 'bàř']

createByReference(array &$array) : Arrayy (可变)

警告：通过引用创建 Arrayy 对象。

$array = array('fòô', 'bàř');
$arrayy = A::createByReference($array); // Arrayy['fòô', 'bàř']

createFromJson(string $json) : Arrayy (不可变)

通过JSON创建新的Arrayy对象。

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

createFromJsonMapper(string $json) : Arrayy (不可变)

通过JSON创建新的Arrayy对象，并填充子对象是可能的。

<?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 (不可变)

创建一个新的实例，用实现了ArrayAccess的对象的值填充。

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

createFromObjectVars(\object $object) : Arrayy (不可变)

创建一个新的实例，用对象的值填充。

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

createWithRange() : Arrayy (不可变)

创建一个新的实例，包含一系列元素。

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

createFromGeneratorImmutable() : Arrayy (不可变)

创建一个新的实例，用从“Generator”对象中复制的值填充。

警告：需要比"A::createFromGeneratorFunction()"调用更多的内存，因为我们将从Generator中获取并存储所有键和值。

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

createFromGeneratorFunction() : Arrayy (不可变)

从一个将返回Generator的可调用函数中创建一个新的实例。

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

createFromString(string $str) : Arrayy (不可变)

通过字符串创建一个新的Arrayy对象。

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

实例方法

Arrayy：以下所有示例都使用了PHP 5.6函数导入和PHP 5.4简短数组语法。有关详细信息，请参阅上面创建方法的文档，以及PHP 5.6创建的说明。

"设置数组值"

$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 对象的简单循环"

$arrayy = a(['fòô' => 'bàř']);
foreach ($arrayy) as $key => $value) {
  echo $key . ' | ' . $value; // fòô | bàř
}

Arrayy方法

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

↑ 添加新的值（可选使用点符号）。

参数

T $value
TKey $key

static (不可变) 返回附加了值的此Arrayy对象.

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

↑ 将（键）+ 值附加到当前数组。

示例： a(['fòô' => 'bàř'])->append('foo'); // Arrayy['fòô' => 'bàř', 0 => 'foo']

参数

T $value
TKey|null $key

$this (可变) 返回附加了值的此Arrayy对象.

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

↑ 将（键）+ 值附加到当前数组。

示例： a(['fòô' => ['bàř']])->appendArrayValues(['foo1', 'foo2'], 'fòô'); // Arrayy['fòô' => ['bàř', 'foo1', 'foo2']]

参数

array<T> $values
TKey|null $key

$this (可变) 返回附加了值的此Arrayy对象.

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

↑ 将（键）+ 值附加到当前数组。

示例： a(['fòô' => 'bàř'])->appendImmutable('foo')->getArray(); // ['fòô' => 'bàř', 0 => 'foo']

参数

T $value
TKey $key

$this (不可变) 返回附加了值的此Arrayy对象.

appendToEachKey(int|string $prefix): static

↑ 向每个键添加后缀。

参数

int|string $prefix

static (不可变) 返回具有前缀键的Arrayy对象.

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

↑ 向每个值添加前缀。

参数

float|int|string $prefix

static (不可变) 返回具有前缀值的Arrayy对象.

arsort(): $this

↑ 以逆序排序数组并保持索引关联。

参数： 无

$this (可变) 返回此Arrayy对象.

arsortImmutable(): $this

↑ 以逆序排序数组并保持索引关联。

参数： 无

$this (不可变) 返回此Arrayy对象.

asort(int $sort_flags): $this

↑ 按值排序条目。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (可变) 返回此Arrayy对象.

asortImmutable(int $sort_flags): $this

↑ 按值排序条目。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (不可变) 返回此Arrayy对象.

at(\Closure $closure): static

↑ 遍历当前数组并执行每个循环的回调。

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

参数

\Closure(T , TKey ): mixed $closure

static (不可变)

average(int $decimals): float|int

↑ 返回当前数组的平均值。

示例： a([-9, -8, -7, 1.32])->average(2); // -5.67

参数

int $decimals 要返回的小数位数.

float|int 平均值.

changeKeyCase(int $case): static

↑ 修改数组中的所有键。

参数

int $case [optional] 可以是 CASE_UPPER 或 CASE_LOWER (默认)

static (不可变)

changeSeparator(string $separator): $this

↑ 修改数组包装器的路径分隔符。

默认分隔符是："."

参数

non-empty-string $separator 要设置的分隔符.

$this (可变) 返回此Arrayy对象.

chunk(int $size, bool $preserveKeys): static|static[]

↑ 创建当前数组的分块版本。

示例： a([-9, -8, -7, 1.32])->chunk(2); // Arrayy[[-9, -8], [-7, 1.32]]

参数

int $size 每个块的大小.
bool $preserveKeys 是否保留数组键.

static|static[] (不可变) 从原始数组中创建的新块数组.

clean(): static

↑ 清除当前数组中的所有假值。

示例： a([-8 => -9, 1, 2 => false])->clean(); // Arrayy[-8 => -9, 1]

参数： 无

static (不可变)

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

↑ 警告!!! -> 清除当前整个数组或其 $key。

示例： a([-8 => -9, 1, 2 => false])->clear(); // Arrayy[]

参数

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

$this (可变) 返回此 Arrayy 对象，为空数组.

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

↑ 检查一个项是否在当前数组中。

示例： a([1, true])->contains(true); // true

参数

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

bool

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

↑ 检查一个(不区分大小写)字符串是否在当前数组中。

示例： a(['E', 'é'])->containsCaseInsensitive('É'); // true

参数

mixed $value
bool $recursive

bool

containsKey(int|string $key): bool

↑ 检查给定的键/索引是否存在于数组中。

示例： a([1 => true])->containsKey(1); // true

参数

int|string $key 要搜索的键/索引.

bool 如果给定的键/索引存在于数组中，则返回 true，否则返回 false.

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

↑ 检查所有给定的 needles 是否作为键/索引存在于数组中。

示例： a([1 => true])->containsKeys(array(1 => 0)); // true

参数

array<TKey> $needles 正在搜索的键.
bool $recursive

bool 如果所有给定的键/索引存在于数组中，则返回 true，否则返回 false.

containsKeysRecursive(array $needles): bool

↑ 检查所有给定的 needles 是否作为键/索引存在于数组中。

参数

array<TKey> $needles 正在搜索的键.

bool 如果所有给定的键/索引存在于数组中，则返回 true，否则返回 false.

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

↑ 检查一个项是否在当前数组中。

示例： a([1, true])->containsOnly(true); // false

参数

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

bool

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

↑ 别名：用于 "Arrayy->contains()"

参数

float|int|string $value

bool

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

↑ 别名：用于 "Arrayy->contains($value, true)"

参数

float|int|string $value

bool

containsValues(array $needles): bool

↑ 检查所有给定的针是否存在于数组中。

示例： a([1, true])->containsValues(array(1, true)); // true

参数

array $needles

bool 如果所有给定的值都存在于数组中，则返回 true，否则返回 false。

count(int $mode): int

↑ 统计数组中的所有元素，或在对象中统计某些内容。

示例： a([-9, -8, -7, 1.32])->count(); // 4

对于对象，如果您安装了SPL，可以通过实现接口 {@see \Countable} 来挂钩到 count()。该接口恰好有一个方法，即 {@see \Countable::count()}，它返回 count() 函数的返回值。请参阅手册中的 {@see \Array} 部分，以获取关于如何在PHP中实现和使用数组的详细说明。

参数

int $mode [可选] 如果可选的模式参数设置为 COUNT_RECURSIVE（或 1），则 count 将递归地计数数组。这对于统计多维数组中的所有元素特别有用。count 不能检测无限递归。

`int
var 中的元素数量，var 通常是一个数组，因为任何其他内容都只有一个元素。

如果 var 不是一个数组或实现了 Countable 接口的对象，则返回 1。有一个例外，如果 var 是 &null;，则返回 0。

注意：count 可能对于未设置的变量返回 0，但也可能对于已初始化为空数组的变量返回 0。使用 isset 来测试变量是否已设置。

countValues(): static

↑ 统计数组中的所有值

参数： 无

`static
(不可变) 从输入值作为键及其计数作为值的关联 Arrayy-object。

create(mixed $data, string $iteratorClass, bool $checkPropertiesInConstructor): static

↑ 创建一个 Arrayy 对象。

参数

mixed $data
class-string<\Arrayy\ArrayyIterator> $iteratorClass
bool $checkPropertiesInConstructor

static (不可变) 返回 Arrayy 对象的新实例。

createByReference(array $array): $this

↑ 注意：通过引用创建 Arrayy 对象。

参数

array $array

$this (可变) 返回此Arrayy对象.

createFromArray(array $array): static

↑ 通过 JSON 创建新的 Arrayy 对象。

参数

array $array

static (不可变) 返回 Arrayy 对象的新实例。

createFromGeneratorFunction(callable $generatorFunction): static

↑ 从返回 Generator 的可调用函数创建新的实例。

参数

callable(): \Generator $generatorFunction

static (不可变) 返回 Arrayy 对象的新实例。

createFromGeneratorImmutable(\Generator $generator): static

↑ 从 "Generator"-对象中复制值创建新的实例。

参数

\Generator $generator

static (不可变) 返回 Arrayy 对象的新实例。

createFromJson(string $json): static

↑ 通过 JSON 创建新的 Arrayy 对象。

参数

string $json

static (不可变) 返回 Arrayy 对象的新实例。

createFromJsonMapper(string $json): static

↑

参数

string $json

static (不可变)

createFromObject(\Traversable $object): static

↑ 从可迭代对象创建新的实例，该对象包含值。

参数

\Traversable $object 可迭代对象

static (不可变) 返回 Arrayy 对象的新实例。

createFromObjectVars(object $object): static

↑ 创建一个新的实例，填充来自对象的值。

参数

对象 $object

static (不可变) 返回 Arrayy 对象的新实例。

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

↑ 通过字符串创建一个新的 Arrayy 对象。

参数

string $str 输入字符串。
非空字符串|null $delimiter 边界字符串。
string|null $regEx 使用 $delimiter 或 $regEx，如果 $pattern 为 null，则使用 $delimiter。

static (不可变) 返回 Arrayy 对象的新实例。

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

↑ 创建一个新的实例，填充来自“Traversable”对象的值的副本。

参数

\Traversable<(数组键|TKey), T> $traversable
`bool $use_keys [可选]
是否使用迭代器元素的键作为索引。

static (不可变) 返回 Arrayy 对象的新实例。

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

↑ 创建一个包含一系列元素的新实例。

参数

float|int|string $low 序列的第一个值。
float|int|string $high 序列在达到结束值时结束。
float|int $step 用作序列中元素之间的增量。

static (不可变) 返回 Arrayy 对象的新实例。

current(): false|mixed

↑ 获取当前内部迭代位置上的数组元素。

参数： 无

false|mixed

customSortKeys(callable $callable): $this

↑ 通过“uksort”通过索引自定义排序。

示例： $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]

参数

callable $callable

$this (可变) 返回此Arrayy对象.

customSortKeysImmutable(callable $callable): $this

↑ 通过“uksort”通过索引自定义排序。

参数

callable $callable

$this (不可变) 返回此Arrayy对象.

customSortValues(callable $callable): $this

↑ 通过“usort”通过值自定义排序。

示例： $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]

参数

callable $callable

$this (可变) 返回此Arrayy对象.

customSortValuesImmutable(callable $callable): $this

↑ 通过“usort”通过值自定义排序。

参数

callable $callable

$this (不可变) 返回此Arrayy对象.

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

↑ 删除指定的键或键。

参数

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

void

diff(array $array): static

↑ 返回仅在当前数组中存在的值。

示例： a([1 => 1, 2 => 2])->diff([1 => 1]); // Arrayy[2 => 2]

参数

数组 ...$array

static (不可变)

diffKey(array $array): static

↑ 返回仅在当前数组中存在的键。

参数

数组 ...$array

static (不可变)

diffKeyAndValue(array $array): static

↑ 返回仅在当前数组中存在的值和键。

参数

数组 ...$array

static (不可变)

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

↑ 返回仅在当前多维数组中存在的值。

示例： a([1 => [1 => 1], 2 => [2 => 2]])->diffRecursive([1 => [1 => 1]]); // Arrayy[2 => [2 => 2]]

参数

array $array
null|array|Generator $helperVariableForRecursion (仅用于内部使用)

static (不可变)

diffReverse(array $array): static

↑ 返回新 $array 中仅存在的值。

示例： a([1 => 1])->diffReverse([1 => 1, 2 => 2]); // Arrayy[2 => 2]

参数

array $array

static (不可变)

divide(): static

↑ 将数组分为两个数组。一个包含键，另一个包含值。

示例： a(['a' => 1, 'b' => ''])->divide(); // Arrayy[Arrayy['a', 'b'], Arrayy[1, '']]

参数： 无

static (不可变)

each(\Closure $closure): static

↑ 遍历当前数组并修改数组的值。

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

参数

\Closure(T , ?TKey ): T $closure

static (不可变)

end(): false|mixed

↑ 将内部迭代器设置为数组的最后一个元素并返回该元素。

参数： 无

false|mixed

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

↑ 用另一个数组交换数组。

参数

`T|array|self $data 1. 如果是数组，则使用当前数组

如果没有内容，则回退到空数组
在存在 "Arrayy"-对象的情况下，在对象上调用 "getArray()"
在存在 "\Traversable"-对象的情况下，在对象上调用 "createFromObject()"
如果存在该方法，则在对象上调用 "__toArray()"
将字符串或具有 "__toString()" 的对象强制转换为数组
抛出 "InvalidArgumentException"-异常

array

exists(\Closure $closure): bool

↑ 使用闭包检查当前数组中是否存在值。

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

参数

\Closure(T , TKey ): bool $closure

bool 如果给定的值被找到，则返回 true，否则返回 false。

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

↑ 使用 "$default" 值填充数组，直到 "$num"。

示例： a(['bar'])->fillWithDefaults(3, 'foo'); // Arrayy['bar', 'foo', 'foo']

参数

int $num
T $default

static (不可变)

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

↑ 找出通过真值测试的所有数组项。

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

参数

`null|\Closure(T , TKey = default): bool|\Closure(T ): bool|\Closure(TKey ): bool $closure [optional]
要使用的回调函数

如果没有提供回调，则将所有等于 false 的输入条目删除（参见转换为布尔值）

` - `int $flag [optional]

确定传递给回调的参数的标志

ARRAY_FILTER_USE_KEY (1) - 将键作为唯一参数传递给回调而不是值
ARRAY_FILTER_USE_BOTH (2) - 将值和键作为参数传递给回调而不是值

static (不可变)

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

↑ 根据特定属性中的值过滤对象数组（或关联数组的数字数组）。

参数

string $property
array|T $value
`string|null $comparisonOp
'eq' (等于)，
'gt' (大于)，
'gte' 或 'ge' (大于等于),
'lt' (小于),
'lte' 或 'le' (小于等于),
'ne' (不等于),
'contains',
'notContains',
'newer' (通过 strtotime),
'older' (通过 strtotime),

static (不可变)

find(\Closure $closure): false|mixed

↑ 在数组中查找第一个通过真值测试的项，否则返回 false。

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

参数

\Closure(T , TKey ): bool $closure

false|mixed 如果没有找到值，则返回 false.

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

↑ 通过 ... 查找

示例： $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']]

参数

string $property
array|T $value
string $comparisonOp

static (不可变)

first(): mixed|null

↑ 从当前数组中获取第一个值。

示例： a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->first(); // 'foo'

参数： 无

mixed|null 如果没有元素，则返回 null.

firstKey(): mixed|null

↑ 从当前数组中获取第一个键。

参数： 无

mixed|null 如果没有元素，则返回 null.

firstsImmutable(int|null $number): static

↑ 从当前数组中获取第一个值（s）。

如果没有第一个条目，将返回空数组。

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

参数

int|null $number 你将获取多少个值？

static (不可变)

firstsKeys(int|null $number): static

↑ 从当前数组中获取第一个值（s）。

如果没有第一个条目，将返回空数组。

参数

int|null $number 你将获取多少个值？

static (不可变)

firstsMutable(int|null $number): $this

↑ 从当前数组中获取并删除第一个值（s）。

如果没有第一个条目，将返回空数组。

示例： a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->firstsMutable(); // 'foo'

参数

int|null $number 你将获取多少个值？

$this (可变)

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

↑ 使用给定字符作为键分隔符展开数组。

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

参数

string $delimiter
string $prepend
array|null $items

array

flip(): static

↑ 交换数组中的所有键与它们的关联值。

示例： a([0 => 'foo', 1 => 'bar'])->flip(); // Arrayy['foo' => 0, 'bar' => 1]

参数： 无

static (不可变)

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

↑ 从数组中获取值（可选使用点表示法）。

示例： $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

参数

TKey $key 要查找的键。
mixed $fallback 回退值。
array|null $array 要获取的数组，如果设置为 "null"，则使用类当前数组。
bool $useByReference

mixed|static

getAll(): array

↑ 别名：为 "Arrayy->toArray()"

参数： 无

array

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

↑ 从"Arrayy"-对象获取当前数组。

等于"toArray()"的别名

参数

`bool $convertAllArrayyElements
将所有子-"Arrayy"对象也转换为数组。

` - `bool $preserveKeys

例如：生成器可能返回相同的键多次，因此您可能需要忽略键。

array

getArrayCopy(): array

↑ 创建ArrayyObject的副本。

参数： 无

array

getBackwardsGenerator(): Generator

↑ 将"Arrayy"-对象当前数组以生成器形式获取。

参数： 无

\Generator

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

↑ 返回由$columnKey指定的输入数组的单个列的值，可用于从多数组中提取数据列。

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

INFO：您可以提供$indexKey，以便按输入数组中$indexKey列的值索引返回数组中的值。

参数

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

static (不可变)

getFlags()

↑

参数： 无

TODO：__not_detected__

getGenerator(): Generator

↑ 将"Arrayy"-对象当前数组以生成器形式获取。

参数： 无

\Generator

getGeneratorByReference(): Generator

↑ 通过引用从"Arrayy"-对象作为生成器获取当前数组。

参数： 无

\Generator

getIterator(): Iterator

↑ 返回一个新的迭代器，从而实现\Iterator接口。

示例： a(['foo', 'bar'])->getIterator(); // ArrayyIterator['foo', 'bar']

参数： 无

\Iterator 数组的值迭代器。

getIteratorClass(): string

↑ 获取ArrayObject的迭代器类名。

参数： 无

string

getKeys(): static

↑ 等同于"Arrayy->keys()"的别名

参数： 无

static (不可变)

getList(bool $convertAllArrayyElements): array

↑ 以列表形式从"Arrayy"-对象获取当前数组。

等同于"toList()"的别名

参数

`bool $convertAllArrayyElements
将所有子-"Arrayy"对象也转换为数组。

array

getObject(): stdClass

↑ 从"Arrayy"-对象以对象形式获取当前数组。

参数： 无

\stdClass

getPhpDocPropertiesFromClass(): array|TypeCheckArray

↑

参数： 无

array|TypeCheckArray

getRandom(): static

↑ 等同于"Arrayy->randomImmutable()"的别名

参数： 无

static (不可变)

getRandomKey(): mixed|null

↑ 等同于"Arrayy->randomKey()"的别名

参数： 无

mixed|null 获取一个键/索引或如果没有键/索引则返回null。

getRandomKeys(int $number): static

↑ 等同于"Arrayy->randomKeys()"的别名

参数

int $number

static (不可变)

getRandomValue(): mixed|null

↑ 等同于"Arrayy->randomValue()"的别名

参数： 无

mixed|null 获取一个随机值或如果没有值则返回null。

getRandomValues(int $number): static

↑ 等同于"Arrayy->randomValues()"的别名

参数

int $number

static (不可变)

getValues(): static

↑ 获取所有值。

参数： 无

static 此数组中所有元素的值，按照在数组中出现的顺序排列.

getValuesYield(): 生成器

↑ 通过生成器获取所有值。

参数： 无

\Generator 此数组中所有元素的值，按照在数组中出现的顺序排列，作为生成器.

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

↑ 根据闭包的结果对数组的值进行分组。

参数

\Closure(T , TKey ): TKey|TKey $grouper 一个可调用的函数名.
bool $saveKeys

static (不可变)

has(mixed $key): bool

↑ 检查数组是否包含指定的键。

参数

null|TKey|TKey[] $key

bool

hasValue(mixed $value): bool

↑ 检查数组是否包含指定的值。

INFO: 如果需要递归搜索，请使用 contains($value, true)。

参数

T $value

bool

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

↑ 将数组的值连接成字符串。

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

参数

string $glue
string $prefix

string

implodeKeys(string $glue): string

↑ 将数组的键连接成字符串。

参数

string $glue

string

indexBy(int|string $key): static

↑ 给定一个列表和一个迭代函数，该函数为列表中的每个元素返回一个键（或属性名），返回一个包含每个项索引的对象。

参数

array- $key

static (不可变)

indexOf(mixed $value): false|int|string

↑ 别名：对于 "Arrayy->searchIndex()"

参数

T $value 要搜索的值.

false|int|string

initial(int $to): static

↑ 获取除了最后..$to个元素之外的所有内容。

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

参数

int $to

static (不可变)

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

↑ 返回一个包含在输入数组中找到的所有元素的数组。

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

参数

array<TKey, T> $search
bool $keepKeys

static (不可变)

intersectionMulti(array $array): static

↑ 返回一个包含在输入数组中找到的所有元素的数组。

参数

数组 ...$array

static (不可变)

intersects(array $search): bool

↑ 返回一个布尔标志，指示两个输入数组是否有任何共同元素。

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

参数

array<TKey, T> $search

bool

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

↑ 在数组的所有值上调用一个函数。

参数

callable $callable
mixed $arguments

static (不可变)

isAssoc(bool $recursive): bool

↑ 检查数组是否是关联数组。

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

参数

bool $recursive

bool 如果是关联数组返回 true，否则返回 false.

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

↑ 检查给定的键或键是否为空。

参数

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

bool 如果是空返回 true，否则返回 false.

isEqual(array $array): bool

↑ 检查当前数组是否与给定的 "$array" 相等。

示例： a(['💩'])->isEqual(['💩']); // true

参数

array $array

bool

isMultiArray(): bool

↑ 检查当前数组是否是多维数组。

示例： a(['foo' => [1, 2 , 3]])->isMultiArray(); // true

参数： 无

bool

isNumeric(): bool

↑ 检查数组是否为数字。

参数： 无

bool 如果是数字返回 true，否则返回 false.

isSequential(bool $recursive): bool

↑ 检查当前数组是否为顺序数组 [0, 1, 2, 3, 4, 5 ...]。

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

INFO: 如果数组为空，则将其视为非顺序数组。

参数

bool $recursive

bool

jsonSerialize(): array

↑

参数： 无

array

key(): int|string|null

↑ 获取当前内部迭代器位置的元素的键/索引。

参数： 无

int|string|null

keyExists(int|string $key): bool

↑ 检查给定的键是否存在于提供的数组中。

INFO: 此方法仅使用 "array_key_exists()"，如果您想使用 "点" 表示法，则需要使用 "Arrayy->offsetExists()"。

参数

int|string $key 要查找的键

bool

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

↑ 获取当前数组的所有键。

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

参数

`bool $recursive [可选]
获取所有键，包括所有多维数组中的子数组中的键。

` - `null|T|T[] $search_values [可选]

如果指定，则仅返回包含这些值的键。

` - `bool $strict [可选]

确定在搜索期间是否使用严格比较 (===)。

static (不可变) 输入中所有键的数组.

krsort(int $sort_flags): $this

↑ 按键逆序排序数组。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (可变) 返回此Arrayy对象.

krsortImmutable(int $sort_flags): $this

↑ 按键逆序排序数组。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (不可变)

ksort(int $sort_flags): $this

↑ 按键排序条目。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (可变) 返回此Arrayy对象.

ksortImmutable(int $sort_flags): $this

↑ 按键排序条目。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (不可变) 返回此Arrayy对象.

last(): mixed|null

↑ 获取当前数组中的最后一个值。

示例： a([2 => 'foo', 3 => 'bar', 4 => 'lall'])->last(); // 'lall'

参数： 无

mixed|null 如果没有元素，则返回 null.

lastKey(): mixed|null

↑ 获取当前数组中的最后一个键。

参数： 无

mixed|null 如果没有元素，则返回 null.

lastsImmutable(int|null $number): static

↑ 获取当前数组中的最后一个值。

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

参数

int|null $number

static (不可变)

lastsMutable(int|null $number): $this

↑ 获取当前数组中的最后一个值。

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

参数

int|null $number

$this (可变)

length(int $mode): int

↑ 计算当前数组中的值。

别名：对于 "Arrayy->count()"

参数

int $mode

int

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

↑ 将给定的函数应用于数组的每个元素，收集结果。

示例： a(['foo', 'Foo'])->map('mb_strtoupper'); // Arrayy['FOO', 'FOO']

参数

callable $callable
bool $useKeyAsSecondParameter
mixed ...$arguments

static (不可变)包含修改后元素的 Arrayy 对象.

matches(\Closure $closure): bool

↑ 检查当前数组中所有项目是否通过真值测试。

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

参数

\Closure(T , TKey ): bool $closure

bool

matchesAny(\Closure $closure): bool

↑ 检查当前数组中是否有任何项目通过真值测试。

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

参数

\Closure(T , TKey ): bool $closure

bool

max(): false|float|int|string

↑ 从数组中获取最大值。

示例： a([-9, -8, -7, 1.32])->max(); // 1.32

参数： 无

false|float|int|string 如果没有值，将返回 false.

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

↑ 将新数组 $array 合并到当前数组中。

保留当前数组中的键值，即使索引在新数组中

示例： $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']

参数

array $array
bool $recursive

static (不可变)

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

↑ 将新数组 $array 合并到当前数组中。

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

示例： $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']

参数

array $array
bool $recursive

static (不可变)

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

↑ 将当前数组合并到 $array 中。

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

示例： $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']

参数

array $array
bool $recursive

static (不可变)

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

↑ 将当前数组合并到新数组 $array 中。

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

示例： $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']

参数

array $array
bool $recursive

static (不可变)

meta(): ArrayyMeta|mixed|static

↑

参数： 无

\ArrayyMeta|mixed|static

min(): false|mixed

↑ 从数组中获取最小值。

示例： a([-9, -8, -7, 1.32])->min(); // -9

参数： 无

返回值：false|mixed 如果没有值，将返回false。

mostUsedValue(): mixed|null

↑ 从数组中获取最常使用的值。

参数： 无

mixed|null (不可变) 如果没有元素，则返回null。

mostUsedValues(int|null $number): static

↑ 从数组中获取最常使用的值。

参数

int|null $number 你将获取多少个值？

static (不可变)

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

↑ 将数组元素移动到新索引。

示例： $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']

参数

int|string $from
int $to

static (不可变)

moveElementToFirstPlace(int|string $key): static

↑ 将数组元素移动到第一个位置。

INFO：与 "Arrayy->moveElement()" 不同，此方法不会丢失索引数组的键。

参数

int|string $key

static (不可变)

moveElementToLastPlace(int|string $key): static

↑ 将数组元素移动到最后一个位置。

INFO：与 "Arrayy->moveElement()" 不同，此方法不会丢失索引数组的键。

参数

int|string $key

static (不可变)

natcasesort(): $this

↑ 使用不区分大小写的“自然顺序”算法对数组进行排序。

参数： 无

$this (可变) 返回此Arrayy对象.

natcasesortImmutable(): $this

↑ 使用不区分大小写的“自然顺序”算法对数组进行排序。

参数： 无

$this (不可变) 返回此Arrayy对象.

natsort(): $this

↑ 使用“自然顺序”算法对条目进行排序。

参数： 无

$this (可变) 返回此Arrayy对象.

natsortImmutable(): $this

↑ 使用“自然顺序”算法对条目进行排序。

参数： 无

$this (不可变) 返回此Arrayy对象.

next(): false|mixed

↑ 将内部迭代器位置移动到下一个元素并返回此元素。

参数： 无

false|mixed (可变) 如果没有值，将返回false。

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

↑ 从数组中获取下一个第n个键和值。

参数

int $step
int $offset

static (不可变)

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

↑ 检查偏移量是否存在。

参数

bool|int|string $offset

bool

offsetGet(int|string $offset): mixed

↑ 返回指定偏移量的值。

参数

TKey $offset

mixed 如果偏移量不存在，则返回null。

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

↑ 将值分配给指定的偏移量 + 检查类型。

参数

int|string|null $offset
mixed $value

void

offsetUnset(int|string $offset): void

↑ 删除偏移量。

参数

int|string $offset

void (可变) 不返回任何内容。

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

↑ 从给定的数组中获取子集。

参数

array-key[] $keys

static (不可变)

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

↑ 使用给定的值填充数组到指定的大小。

参数

int $size 结果数组的大小。
mixed $value 默认为空值。

static (不可变) 使用 $value 填充到 $size 大小的 Arrayy 对象。

partition(\Closure $closure): array<int,static>

↑ 根据谓词将此数组分成两个数组。

结果数组中保留键。

参数

\Closure(T , TKey ): bool $closure 用于分区的谓词。

数组 包含两个元素的数组。第一个元素包含谓词返回 TRUE 的元素数组，第二个元素包含谓词返回 FALSE 的元素数组。

pop(): mixed|null

↑ 从当前数组末尾弹出指定值。

参数： 无

mixed|null (可变) 当前数组中弹出的元素或 null（如果数组为空等）。

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

↑ 将（键）+ 值添加到当前数组中。

示例： a(['fòô' => 'bàř'])->prepend('foo'); // Arrayy[0 => 'foo', 'fòô' => 'bàř']

参数

T $value
TKey|null $key

$this (可变) 返回带有附加值的 Arrayy 对象。

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

↑ 将（键）+ 值添加到当前数组中。

示例： a(['fòô' => 'bàř'])->prependImmutable('foo')->getArray(); // [0 => 'foo', 'fòô' => 'bàř']

参数

T $value
TKey $key

$this (不可变) 返回带有附加值的 Arrayy 对象。

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

↑ 向每个键添加后缀。

参数

float|int|string $suffix

static (不可变) 返回带有附加键的 Arrayy 对象。

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

↑ 为每个值添加后缀。

参数

float|int|string $suffix

static (不可变) 返回带有附加值的 Arrayy 对象。

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

↑ 返回给定键的值并删除该键。

参数

int|int[]|string|string[]|null $keyOrKeys
TFallback $fallback

mixed

push(mixed $args): $this

↑ 一次性将一个或多个值推送到数组末尾。

参数

array<TKey, T> ...$args

$this (可变) 返回带有推送到数组末尾的元素的 Arrayy 对象。

randomImmutable(int|null $number): static

↑ 从当前数组中获取随机值。

示例： a([1, 2, 3, 4])->randomImmutable(2); // 例如：Arrayy[1, 4]

参数

int|null $number 你将获取多少个值？

static (不可变)

randomKey(): mixed|null

↑ 从此数组的键中选择一个随机键/索引。

示例： $arrayy = A::create([1 => 'one', 2 => 'two']); $arrayy->randomKey(); // 例如：2

参数： 无

mixed|null 获取一个键/索引或如果没有键/索引则返回null。

randomKeys(int $number): static

↑ 从此数组中选择指定数量的随机键/索引。

示例： a([1 => 'one', 2 => 'two'])->randomKeys(); // 例如：Arrayy[1, 2]

参数

int $number 键/索引的数量（应小于等于 \count($this->array))

static (不可变)

randomMutable(int|null $number): $this

↑ 从当前数组中获取随机值。

示例： a([1, 2, 3, 4])->randomMutable(2); // 例如：Arrayy[1, 4]

参数

int|null $number 你将获取多少个值？

$this (可变) 返回此Arrayy对象.

randomValue(): mixed

↑ 从此数组的值中选择一个随机值。

示例： a([1 => 'one', 2 => 'two'])->randomValue(); // 例如：'one'

参数： 无

mixed 获取一个随机值或 null（如果没有值）。

randomValues(int $number): static

↑ 从此数组中选择指定数量的随机值。

示例： a([1 => 'one', 2 => 'two'])->randomValues(); // 例如：Arrayy['one', 'two']

参数

int $number

static (可变)

randomWeighted(array $array, int $number)

↑

参数

array $array
int $number

self

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

↑ 通过可调用的函数（例如匿名函数）减少当前数组并返回最终结果。

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

参数

callable $callable
T2 $initial

static (不可变)

reduce_dimension(bool $unique): 静态

↑

参数

bool $unique

static (不可变)

reindex(): $this

↑ 创建一个数值重新索引的 Arrayy 对象。

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

参数： 无

$this (可变) 返回重新索引数组元素的 Arrayy 对象。

reject(\Closure $closure): 静态

↑ 返回所有未通过真值测试的项。

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

参数

\Closure(T , TKey ): bool $closure

static (不可变)

remove(mixed $key): 静态

↑ 从当前数组中移除一个值（可选使用点符号）。

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

参数

TKey|TKey[] $key

static (可变)

removeElement(mixed $element): 静态

↑ 别名：为 "Arrayy->removeValue()"

参数

T $element

static (不可变)

removeFirst(): 静态

↑ 从当前数组中移除第一个值。

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

参数： 无

static (不可变)

removeLast(): 静态

↑ 从当前数组中移除最后一个值。

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

参数： 无

static (不可变)

removeValue(mixed $value): 静态

↑ 从数组中移除特定的值（数值或关联数组）。

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

参数

T $value

static (不可变)

repeat(int $times): 静态

↑ 生成重复数组的数组。

参数

int $times 需要重复的次数。

static (不可变)

replace(mixed $oldKey, mixed $newKey, mixed $newValue): 静态

↑ 用新的键/值对替换一个键。

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

参数

TKey $oldKey
TKey $newKey
T $newValue

static (不可变)

replaceAllKeys(int[]|string[] $keys): 静态

↑ 使用当前数组作为值，另一个数组作为键创建一个数组。

示例: $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"]

参数

array<TKey> $keys 键数组。

`static
(不可变) 包含来自另一个数组的键的 Arrayy 对象，如果每个数组的元素数量不相等或数组为空，则为空 Arrayy 对象。

replaceAllValues(array $array): 静态

↑ 使用当前数组作为键，另一个数组作为值创建一个数组。

示例: $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]

参数

array $array 值数组。

`static
(不可变) 包含其他数组值的 Arrayy 对象，如果每个数组的元素数量不相等或数组为空，则返回空 Arrayy 对象。

replaceKeys(array $keys): 静态

↑ 用另一组键替换数组中的键。

示例： a([1 => 'bar', 'foo' => 'foo'])->replaceKeys([1 => 2, 'foo' => 'replaced']); // Arrayy[2 => 'bar', 'replaced' => 'foo']

参数

array<TKey> $keys 与数组大小匹配的键数组。

static (不可变)

replaceOneValue(mixed $search, mixed $replacement): 静态

↑ 替换数组中的第一个匹配值。

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

参数

T $search 要替换的值。
T $replacement 替换的值。

static (不可变)

replaceValues(string $search, string $replacement): 静态

↑ 替换当前数组中的值。

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

参数

string $search 要替换的值。
string $replacement 替换的内容。

static (不可变)

rest(int $from): 静态

↑ 从索引 $from 开始获取数组中的最后一个元素直到数组末尾。

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

参数

int $from

static (不可变)

reverse(): $this

↑ 返回倒序的数组。

示例： a([1 => 1, 2 => 2, 3 => 3])->reverse(); // self[3, 2, 1]

参数： 无

$this (可变) 返回此Arrayy对象.

reverseKeepIndex(): $this

↑ 返回键倒序的数组。

示例： a([1 => 1, 2 => 2, 3 => 3])->reverse(); // self[3 => 3, 2 => 2, 1 => 1]

参数： 无

$this (可变) 返回此Arrayy对象.

rsort(int $sort_flags): $this

↑ 以倒序对数组进行排序。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (可变) 返回此Arrayy对象.

rsortImmutable(int $sort_flags): $this

↑ 以倒序对数组进行排序。

参数

`int $sort_flags [可选]
您可以使用可选参数sort_flags修改排序行为，有关详细信息，请参阅sort。

$this (不可变) 返回此Arrayy对象.

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

↑ 通过 $value 在当前数组中搜索第一个索引。

示例： a(['fòô' => 'bàř', 'lall' => 'bàř'])->searchIndex('bàř'); // Arrayy[0 => 'fòô']

参数

T $value

false|int|string 如果找不到值，则返回 FALSE。

searchValue(mixed $index): 静态

↑ 通过 $index 在当前数组中搜索值。

示例： a(['fòô' => 'bàř'])->searchValue('fòô'); // Arrayy[0 => 'bàř']

参数

TKey $index

static 如果找不到值，则返回空 Arrayy。

serialize(): string

↑ 序列化当前的 "Arrayy" 对象。

示例： a([1, 4, 7])->serialize();

参数： 无

string

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

↑ 为当前数组设置值（可选使用点表示法）。

示例： $arrayy = a(['Lars' => ['lastname' => 'Moelleken']]); $arrayy->set('Lars.lastname', 'Müller'); // Arrayy['Lars', ['lastname' => 'Müller']]]

参数

TKey $key 要设置的键。
T $value 其值。

$this (可变) 返回此Arrayy对象.

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

从数组中获取值并设置它（如果尚未设置）。

警告：此方法仅设置值，如果$key尚未设置

示例：$arrayy = a([1 => 1, 2 => 2, 3 => 3]); $arrayy->setAndGet(1, 4); // 1 $arrayy->setAndGet(0, 4); // 4

参数

TKey $key 键
T $fallback 如果不存在则设置的默认值

mixed (可变)

setFlags(int $flags)

↑

参数

int $flags

TODO：__not_detected__

setIteratorClass(string $iteratorClass): void

设置当前"Arrayy"-对象的迭代器类名。

参数

class-string<\Arrayy\ArrayyIterator> $iteratorClass

void

shift(): mixed|null

移除数组开头的指定值。

参数： 无

mixed|null (可变) 从当前数组中移除的元素

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

对当前数组进行洗牌。

示例：a([1 => 'bar', 'foo' => 'foo'])>shuffle(); // 例如：Arrayy[['foo' => 'foo', 1 => 'bar']]

参数

bool $secure 使用CSPRNG | @see https://paragonie.com/b/JvICXzh_jhLyt4y3
array|null $array [可选]

static (不可变)

size(int $mode): int

↑ 计算当前数组中的值。

别名：对于 "Arrayy->count()"

参数

int $mode

int

sizeIs(int $size): bool

检查数组是否恰好有$size个项。

参数

int $size

bool

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

检查数组是否有介于$fromSize到$toSize个项。$toSize可以小于$fromSize。

参数

int $fromSize
int $toSize

bool

sizeIsGreaterThan(int $size): bool

检查数组是否有超过$size个项。

参数

int $size

bool

sizeIsLessThan(int $size): bool

检查数组是否有少于$size个项。

参数

int $size

bool

sizeRecursive(): int

↑ 统计数组中的所有元素，或在对象中统计某些内容。

参数： 无

`int
var 中的元素数量，var 通常是一个数组，因为任何其他内容都只有一个元素。

如果 var 不是一个数组或实现了 Countable 接口的对象，则返回 1。有一个例外，如果 var 是 &null;，则返回 0。

注意：count 可能对于未设置的变量返回 0，但也可能对于已初始化为空数组的变量返回 0。使用 isset 来测试变量是否已设置。

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

提取数组的切片。

参数

int $offset 切片开始索引
int|null $length 切片长度
bool $preserveKeys 是否保留数组键.

static (不可变) 长度为$length的原数组切片

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

对当前数组进行排序，并且可以选择保留键。

示例：a(3 => 'd', 2 => 'f', 0 => 'a')>sort(SORT_ASC, SORT_NATURAL, false); // Arrayy[0 => 'a', 1 => 'd', 2 => 'f']

参数

int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 排序标志 => 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL
bool $keepKeys

static (可变) 返回此Arrayy对象

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

对当前数组进行排序，并且可以选择保留键。

参数

int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 排序标志 => 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL
bool $keepKeys

static (不可变) 返回此Arrayy对象

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

按键对当前数组进行排序。

示例：a([1 => 2, 0 => 1])->sortKeys(\SORT_ASC); // Arrayy[0 => 1, 1 => 2]

参数

int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL

$this (可变) 返回此Arrayy对象.

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

按键对当前数组进行排序。

参数

int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL

$this (不可变) 返回此Arrayy对象.

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

按值对当前数组进行排序。

示例： a(3 => 'd', 2 => 'f', 0 => 'a')->sortValueKeepIndex(SORT_ASC, SORT_REGULAR); // 数组[0 => 'a', 3 => 'd', 2 => 'f']

参数

int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL

static (可变)

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

按值对当前数组进行排序。

示例： a(3 => 'd', 2 => 'f', 0 => 'a')->sortValueNewIndex(SORT_ASC, SORT_NATURAL); // 数组[0 => 'a', 1 => 'd', 2 => 'f']

参数

int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL

static (可变)

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

↑ 按值或闭包对数组进行排序。

如果排序器为null，则数组将按自然顺序排序。
将保留关联（字符串）键，但将重新索引数字键。

示例： $testArray = range(1, 5); $under = a($testArray)->sorter( function ($value) { return $value % 2 === 0; } ); var_dump($under); // 数组[1, 3, 5, 2, 4]

参数

callable|mixed|null $sorter
int|string $direction 使用 SORT_ASC（默认）或 SORT_DESC
int $strategy 使用例如： SORT_REGULAR（默认）或 SORT_NATURAL

static (不可变)

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

↑

参数

int $offset
int|null $length
array $replacement

static (不可变)

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

↑ 将数组分割成指定数量的块。

示例： a(['a' => 1, 'b' => 2])->split(2, true); // 数组[['a' => 1], ['b' => 2]]

参数

int $numberOfPieces
bool $keepKeys

static (不可变)

stripEmpty(): static

↑ 从当前数组中移除所有空项。

示例： a(['a' => 1, 'b' => ''])->stripEmpty(); // 数组[['a' => 1]]

参数： 无

static (不可变)

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

↑ 通过键交换两个位置的值。

示例： a(['a' => 1, 'b' => ''])->swap('a', 'b'); // 数组[['a' => '', 'b' => 1]]

参数

int|string $swapA 数组中的键
int|string $swapB 数组中的键

static (不可变)

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

↑ 从"Arrayy"-对象获取当前数组。

alias for "getArray()"

参数

`bool $convertAllArrayyElements
将所有子-"Arrayy"对象也转换为数组。

` - `bool $preserveKeys

例如：生成器可能返回相同的键多次，因此您可能需要忽略键。

array

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

↑ 将当前数组转换为JSON。

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

参数

int $options [optional] 例如 JSON_PRETTY_PRINT
int $depth [optional] 设置最大深度。必须大于零.

string

toList(bool $convertAllArrayyElements): array

↑ 以列表形式从"Arrayy"-对象获取当前数组。

参数

`bool $convertAllArrayyElements
将所有子-"Arrayy"对象也转换为数组。

array

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

↑

参数

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

static|static[]

toString(string $separator): string

↑ 使用指定的分隔符将数组转换为字符串。

参数

string $separator [optional] 元素的分隔符.

string 数组的字符串表示，用逗号分隔.

uasort(callable $callable): $this

↑ 使用用户定义的比较函数对条目进行排序并保持键关联。

参数

callable $callable

$this (可变) 返回此Arrayy对象.

uasortImmutable(callable $callable): $this

↑ 使用用户定义的比较函数对条目进行排序并保持键关联。

参数

callable $callable

$this (不可变) 返回此Arrayy对象.

uksort(callable $callable): static

↑ 使用用户定义的比较函数按键排序条目。

参数

callable $callable

static (可变) 返回此Arrayy对象

uksortImmutable(callable $callable): static

↑ 使用用户定义的比较函数按键排序条目。

参数

callable $callable

static (不可变) 返回此Arrayy对象

unique(): static

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

参数： 无

static (可变) 返回具有附加值的此Arrayy对象.

uniqueKeepIndex(): $this

↑ 返回当前数组的无重复副本。（带有旧键）

示例： a([2 => 1, 3 => 2, 4 => 2])->uniqueNewIndex(); // 数组[2 => 1, 3 => 2]

参数： 无

$this (可变)

uniqueNewIndex(): $this

↑ 返回当前数组的无重复副本。

示例： a([2 => 1, 3 => 2, 4 => 2])->uniqueNewIndex(); // Arrayy[1, 2]

参数： 无

$this (可变)

unserialize(string $string): $this

↑ 反序列化字符串并返回 "Arrayy"-类的实例。

示例： $serialized = a([1, 4, 7])->serialize(); a()->unserialize($serialized);

参数

string $string

$this

unshift(mixed $args): $this

↑ 一次性将一个或多个值添加到数组的开头。

参数

array<TKey, T> ...$args

$this (可变) 返回带有添加元素到数组开头的 Arrayy 对象.

validate(\Closure $closure): bool

↑ 测试给定的闭包是否对所有数组元素返回有效的值。

参数

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

bool 如果谓词对所有元素返回 TRUE，则为 TRUE，否则为 FALSE.

values(): static

↑ 从数组中获取所有值。

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

参数： 无

static (不可变)

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

↑ 将给定的函数应用于数组中的每个元素，忽略结果。

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

参数

callable $callable
bool $recursive [optional] 是否递归遍历数组或否
`mixed $userData [optional]
如果提供了可选的 $userData 参数，它将被传递为 $callable 的第三个参数。

$this (可变) 返回经过修改的元素的这个 Arrayy 对象.

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

↑ 返回匹配项的集合。

参数

string $keyOrPropertyOrMethod 要评估的属性或方法.
mixed $value 要匹配的值.

static

append(null|mixed $value)

↑

参数

null|mixed $value

TODO：__not_detected__

asort(int $flags)

↑

参数

int $flags

TODO：__not_detected__

count()

↑

参数： 无

TODO：__not_detected__

exchangeArray(array|object $array)

↑

参数

array|object $array

TODO：__not_detected__

getArrayCopy()

↑

参数： 无

TODO：__not_detected__

getFlags()

↑

参数： 无

TODO：__not_detected__

getIterator()

↑

参数： 无

TODO：__not_detected__

getIteratorClass()

↑

参数： 无

TODO：__not_detected__

ksort(int $flags)

↑

参数

int $flags

TODO：__not_detected__

natcasesort()

↑

参数： 无

TODO：__not_detected__

natsort()

↑

参数： 无

TODO：__not_detected__

offsetExists(null|mixed $key)

↑

参数

null|mixed $key

TODO：__not_detected__

offsetGet(null|mixed $key)

↑

参数

null|mixed $key

TODO：__not_detected__

offsetSet(null|mixed $key, null|mixed $value)

↑

参数

null|mixed $key
null|mixed $value

TODO：__not_detected__

offsetUnset(null|mixed $key)

↑

参数

null|mixed $key

TODO：__not_detected__

serialize()

↑

参数： 无

TODO：__not_detected__

setFlags(int $flags)

↑

参数

int $flags

TODO：__not_detected__

setIteratorClass(string $iteratorClass)

↑

参数

string $iteratorClass

TODO：__not_detected__

uasort(callable $callback)

↑

参数

callable $callback

TODO：__not_detected__

uksort(callable $callback)

↑

参数

callable $callback

TODO：__not_detected__

unserialize(string $data)

↑

参数

string $data

TODO：__not_detected__

支持

有关支持和捐款，请访问 Github | 问题 | PayPal | Patreon。

有关状态更新和发布公告，请访问发布 | Twitter | Patreon。

有关专业支持，请联系我。

感谢

感谢 GitHub (Microsoft) 为代码托管和良好的基础设施提供服务，包括问题管理等。
感谢IntelliJ，因为他们为PHP提供了最好的IDE，并且为我提供了PhpStorm的开源许可证！
感谢Travis CI，它是最棒、最简单的持续集成工具！
感谢StyleCI提供的简单但强大的代码风格检查。
感谢PHPStan和Psalm提供的真正出色的静态分析工具，并且能够发现代码中的bug！

测试

从项目目录中，可以使用phpunit运行测试。

许可

本软件采用MIT许可证发布 - 详细信息请参阅LICENSE.txt文件。

voku / arrayy

维护者

详细信息

README

🗃 Arrayy

通过 "composer require" 安装

多维 ArrayAccess

通过 "Arrayy" 语法访问： (点符号)

通过 "数组" 语法访问

通过 "对象" 语法访问

通过 "Arrayy" 语法设置值： (点符号)

通过 "数组" 语法设置值

通过 "对象" 语法设置值

PhpDoc @property 检查

面向对象和链式操作

实现接口

PHP 5.6 创建

集合

预定义类型化集合

简单示例

复杂示例

将 JSON 数据转换为对象（集合）

类方法

使用 "默认对象"

create(array $array) : Arrayy (不可变)

createByReference(array &$array) : Arrayy (可变)

createFromJson(string $json) : Arrayy (不可变)

createFromJsonMapper(string $json) : Arrayy (不可变)

createFromObject(ArrayAccess $object) : Arrayy (不可变)

createFromObjectVars(\object $object) : Arrayy (不可变)

createWithRange() : Arrayy (不可变)

createFromGeneratorImmutable() : Arrayy (不可变)

createFromGeneratorFunction() : Arrayy (不可变)

createFromString(string $str) : Arrayy (不可变)

实例方法

"设置数组值"

"获取数组值"

"获取数组"

"删除数组值"

"检查数组值是否已设置"

"使用 Arrayy 对象的简单循环"

Arrayy方法

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

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

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

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

appendToEachKey(int|string $prefix): static

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

arsort(): $this

arsortImmutable(): $this

asort(int $sort_flags): $this

asortImmutable(int $sort_flags): $this

at(\Closure $closure): static

average(int $decimals): float|int

changeKeyCase(int $case): static

changeSeparator(string $separator): $this

chunk(int $size, bool $preserveKeys): static|static[]

clean(): static

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

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

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

containsKey(int|string $key): bool

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

containsKeysRecursive(array $needles): bool

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

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

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

containsValues(array $needles): bool

count(int $mode): int

countValues(): static

create(mixed $data, string $iteratorClass, bool $checkPropertiesInConstructor): static

createByReference(array $array): $this

createFromArray(array $array): static

createFromGeneratorFunction(callable $generatorFunction): static

createFromGeneratorImmutable(\Generator $generator): static

createFromJson(string $json): static

createFromJsonMapper(string $json): static

createFromObject(\Traversable $object): static

createFromObjectVars(object $object): static

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