README

PHP 数组操作库。与 PHP 5.3+、PHP 7 和 HHVM 兼容。

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

实例方法
测试
许可证

通过 "composer require" 安装

composer require voku/arrayy

通过 composer（手动）安装

如果您使用 Composer 管理依赖项，您可以将以下内容包含在您的 composer.json 文件中

"require": {
    "voku/arrayy": "3.*"
}

然后，运行 composer update 或 php composer.phar update 后，您可以使用 Composer 的自动加载来加载类

require 'vendor/autoload.php';

在这种情况下，我建议使用别名。

use Arrayy\Arrayy as A;

多维 ArrayAccess

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

通过 "Arrayy" 语法访问：（点表示法）

-- 推荐 --

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

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

通过 "array" 语法访问

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

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

通过 "object" 语法访问

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

通过 "array" 语法设置值

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

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

通过 "object" 语法设置值

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

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

面向对象和链式操作

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

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

实现接口

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òô'

StaticArrayy

“实例方法”下列出的所有方法都可作为静态包装器的一部分使用。

use Arrayy\StaticArrayy as A;

// Translates to Arrayy::create(['fòô', 'bàř'])->reverse();
// Returns an Arrayy object with the array
A::reverse(['fòô', 'bàř']);

类方法

使用“默认对象”

创建一个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']

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]

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

append(mixed $value) : Arrayy (可变)

将一个值追加到当前数组中。

别名："Arrayy->add()"

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

prepend(mixed $value) : Arrayy (可变)

将一个值预置于当前数组中。

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

at(Closure $closure) : Arrayy (不可变)

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

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

average(int $decimals) : int|double

返回当前数组的平均值。

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

chunk(int $size, bool $preserveKeys) : Arrayy (不可变)

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

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

clean() : Arrayy (不可变)

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

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

clear() : Arrayy (可变)

警告！！！ -> 清除当前数组。

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

customSortKeys($function) : Arrayy (可变)

通过"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]

customSortValues($function) : Arrayy (可变)

通过"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['one' => 1, 'two' => 2, 'three' => 3]

contains(string|int|float $value) : boolean

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

别名："Arrayy->containsValue()"

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

containsValues(array $values) : boolean

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

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

containsKey(string|int|float $key) : boolean

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

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

containsKeys(array $key) : boolean

检查所有给定的“针”是否都存在于数组中作为键/索引。

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

containsCaseInsensitive(string $value) : boolean

检查一个（不区分大小写）的字符串是否在当前数组中。

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

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

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

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

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

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

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

diffRecursive(array $array, null|array $helperVariableForRecursion) : Arrayy (不可变)

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

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

divide() : Arrayy (不可变)

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

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

each(Closure $closure) : Arrayy (不可变)

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

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

exists(Closure $closure) : boolean

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

filter(Closure|null $closure) : Arrayy (不可变)

在数组中找到所有通过真值测试的项。

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

filterBy() : Arrayy (不可变)

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

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

find(Closure $closure) : mixed

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

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

first() : mixed

从当前数组中获取第一个值，如果没有元素则返回null。

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

firstsMutable(null|int $take) : Arrayy (Mutable)

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

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

firstsImmutable(null|int $take) : Arrayy (Immutable)

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

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

flip() : Arrayy (Immutable)

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

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

get(string $key, [null $default], [null $array]) : mixed

从数组中获取一个值（可选使用点符号）。

$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

getColumn(mixed $columnKey, mixed $indexKey) : Arrayy

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

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

getIterator()

返回一个新的ArrayyIterator，从而实现IteratorAggregate接口。

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

implode(string $with) : string

将数组压缩为一个字符串。

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

initial(int $to) : Arrayy (Immutable)

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

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

intersection(array $search) : Arrayy (Immutable)

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

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

intersects(array $search) : boolean

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

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

isAssoc() : boolean

检查当前数组中是否有命名键。

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

isEqual() : boolean

检查当前数组中是否有命名键。

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

isMultiArray() : boolean

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

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

isSequential() : boolean

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

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

keys() : Arrayy (Immutable)

从当前数组中获取所有键。

别名: "Arrayy->getKeys()"

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

last() : mixed

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

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

lastsImmutable(null|int $take) : Arrayy (Immutable)

从当前数组中获取最后一个值（们）。

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

lastsMutable(null|int $take) : Arrayy (Mutable)

从当前数组中获取最后一个值（们）。

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

length() : int

计算当前数组中的值数量。

别名: "Arrayy->count()" 或 "Arrayy->size()"

a([-9, -8, -7, 1.32])->length(); // 4

max() : mixed

从数组中获取最大值。

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

matches(Closure $closure) : boolean

检查数组中的所有项是否通过真值测试。

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

matchesAny(Closure $closure) : boolean

检查数组中的任何项是否通过真值测试。

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

mergeAppendKeepIndex(array $array) : Arrayy (Immutable)

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

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

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

mergePrependKeepIndex(array $array) : Arrayy (Immutable)

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

使用新$array中的键，值，即使索引在当前数组中

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

mergeAppendNewIndex(array $array) : Arrayy (Immutable)

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

用新$array中的键，值替换当前数组中的重复关联键
创建新的索引

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

mergePrependNewIndex(array $array) : Arrayy (Immutable)

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

用当前数组中的键，值替换新$array中的重复关联键
创建新的索引

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

min() : mixed

从数组中获取最小值。

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

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

将数组元素移动到新的索引位置。

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

randomKey() : mixed

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

别名: "Arrayy->getRandomKey()"

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

randomKeys() : Arrayy (Immutable)

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

别名: "Arrayy->getRandomKeys()"

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

randomValue() : mixed

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

别名: "Arrayy->getRandomValue()"

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

randomValues() : Arrayy (Immutable)

从数组中随机选择给定数量的值。

别名: "Arrayy->getRandomValues()"

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

randomImmutable(int|null $take) : Arrayy (Immutable)

从数组中获取一个随机字符串。

别名: "Arrayy->getRandom()"

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

randomMutable(int|null $take) : Arrayy (可变)

从数组中获取一个随机字符串。

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

randomWeighted(array $array, int|null $take) : Arrayy (不可变)

从数组中获取一个随机值，具有调整结果的能力。

a([0 => 3, 1 => 4])->randomWeighted([1 => 4]); // e.g.: Arrayy[4] (has a 66% chance of returning 4)

reduce(callable $predicate, array $init) : Arrayy (不可变)

通过可调用函数（例如匿名函数）减少当前数组。

function myReducer($resultArray, $value) {
  if ($value == 'foo') {
    $resultArray[] = $value;
  }
  return $resultArray;
};
a(['foo', 'bar'])->reduce('myReducer'); // Arrayy['foo']

reindex() : Arrayy (可变)

创建一个按数字重新索引的Arrayy对象。

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

reject(Closure $closure) : Arrayy (不可变)

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

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

remove(mixed $key) : (不可变)

从当前数组中删除一个值（可选使用点表示法）。

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

removeFirst() : Arrayy (不可变)

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

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

removeLast() : Arrayy (不可变)

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

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

removeValue(mixed $value) : Arrayy (不可变)

从数组中删除特定值（数字或关联数组）。

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

replace(array $keys) : Arrayy (不可变)

用新的键/值对替换键。

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

replaceAllKeys(array $keys) : Arrayy (不可变)

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

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

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

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

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

replaceKeys(array $keys) : Arrayy (不可变)

用另一个集合替换数组中的键。

警告：键数组必须与数组的大小和顺序匹配！

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

replaceOneValue(mixed $search, mixed $replacement) : Arrayy (不可变)

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

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

replaceValues(string $search, string $replacement) : Arrayy (不可变)

在当前数组中替换值。

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

rest(int $from) : Arrayy (不可变)

从索引$from到最后一个元素获取最后一个元素。

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

reverse() : Arrayy (可变)

以相反的顺序返回数组。

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

searchIndex(mixed $value) : mixed

通过$value搜索当前数组的第一个索引。

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

searchValue(mixed $index) : Arrayy (不可变)

通过$index搜索当前数组的值。

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

set(mixed $key, mixed $value) : Arrayy (不可变)

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

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

setAndGet()

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

警告：此方法仅在该$key尚未设置时设置值

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

serialize() : string

序列化当前arrayy对象。

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

unserialize(string $string) : Arrayy (可变)

反序列化字符串并返回此对象。

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

sort(string|int(SORT_ASC) $direction, int(SORT_REGULAR) $strategy, bool(false) $keepKeys) : Arrayy (可变)

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

$direction 例如：[SORT_ASC, SORT_DESC, 'ASC', 'asc', 'DESC', 'desc']
$strategy 例如：[SORT_REGULAR, SORT_NATURAL, ...]

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

sorter(null|callable $sorter, string|int(SORT_ASC) $direction, int(SORT_REGULAR) $strategy) : Arrayy (不可变)

按值、闭包或属性对数组进行排序。

如果sorter为null（默认），则数组按自然顺序排序。
关联（字符串）键将保持不变，但数字键将被重新索引。
$direction 例如：[SORT_ASC, SORT_DESC, 'ASC', 'asc', 'DESC', 'desc']
$strategy 例如：[SORT_REGULAR, SORT_NATURAL, ...]

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

sortKeys(string|int(SORT_ASC) $direction) : Arrayy (可变)

按$direction = 'asc'或$direction = 'desc'对当前数组进行排序。

$direction 例如：[SORT_ASC, SORT_DESC, 'ASC', 'asc', 'DESC', 'desc']

a([1 => 2, 0 => 1])->sortKeys('asc'); // Arrayy[0 => 1, 1 => 2]

sortValueNewIndex(string|int(SORT_ASC) $direction, int(SORT_REGULAR) $strategy) : Arrayy (不可变)

按值排序当前数组。

$direction 例如：[SORT_ASC, SORT_DESC, 'ASC', 'asc', 'DESC', 'desc']
$strategy 例如：[SORT_REGULAR, SORT_NATURAL, ...]

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

sortValueKeepIndex(string|int(SORT_ASC) $direction, int(SORT_REGULAR) $strategy) : Arrayy (不可变)