登录
目录
当前位置： 首页 > 文档资料 > FuelPHP 中文文档 >

Arr - 类別

优质
小牛编辑
117浏览
2023-12-01

Arr 类别是一系列与阵列协作的辅助函式。

is_multi($arr, $all_keys = false)

is_multi 方法检查传递的阵列是否是多维阵列。

静态是
参数
参数预设描述
$arr必要要检查的阵列。
$all_keys
false
检查所有元素都是阵列。
回传布林
範例
// 单一阵列
$arr = array('one' => 1, 'two' => 2);
echo Arr::is_multi($arr);
// 结果：false

// 多维阵列
$arr = array('one' => array('test' => 1), 'two' => array('test' => 2), 'three' => array('test' => 3));
echo Arr::is_multi($arr);
// 结果：true

// 多维阵列并检查元素
$arr = array('one' => array('test' => 1), 'two' => array('test' => 2), 'three' => 3);

echo Arr::is_multi($arr, false); // 结果：true
echo Arr::is_multi($arr, true);  // 结果：false

is_assoc($arr)

is_assoc 方法检查传递的阵列是否是关联阵列。

静态是
参数
参数预设描述
$arr必要要检查的阵列。
回传布林
範例
$arr = array('foo', 'bar', 'baz', 'yay');
echo Arr::is_assoc($arr);
// 结果：false

$arr = array('foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz', 'yay' => 'yay');
echo Arr::is_assoc($arr);
// 结果：true

/*
 * 请注意，即使 '2' 是定义做为一个字串，PHP 将在内部储存它
 * 做为一个整数，因此这「不」被认为是一个关联阵列！
 */
$arr = array(0 => 'foo', 1 => 'bar', '2' => 'baz', 3 => 'yay');
echo Arr::is_assoc($arr);
// 结果：false！

to_assoc($arr)

to_assoc 方法转换一个非关联阵列成为一个关联阵列如果它有偶数片段。

静态是
参数
参数预设描述
$arr必要要转换的阵列。
回传阵列｜null
抛出BadMethodCallException 当所给阵列的值数非偶数时
範例
$arr = array('foo', 'bar', 'baz', 'yay');
print_r(Arr::to_assoc($arr));

// 结果：
Array
(
	["foo"] => 'bar'
	["baz"] => 'yay'
)

$arr = array('foo', 'bar', 'baz');
echo Arr::to_assoc($arr);
// 结果：null

assoc_to_keyval($assoc, $key_field, $val_field)

assoc_to_keyval 方法转换一个多维阵列成为一个键 => 值阵列。

静态是
参数
参数预设描述
$assoc必要要转化的阵列。
$key_field必要要对映为键的关联阵列栏位。
$val_field必要要对映为值的关联阵列栏位。
回传阵列
抛出InvalidArgumentException 当第一个变数不是一个阵列， 或没有实现 Iterator 介面。
範例
$people = array(
	array(
		"name" => "Jack",
		"age" => 21
	),
	array(
		"name" => "Jill",
		"age" => 23
	)
);

print_r(Arr::assoc_to_keyval($people, 'name', 'age'));

// 结果：
Array
(
	["Jack"] => 21
	["Jill"] => 23
)

keyval_to_assoc($array, $key_field, $val_field)

keyval_to_assoc 方法用提供的栏位名称转换一个键 => 值阵列成为一个多维阵列。

静态是
参数
参数预设描述
$array必要要转化的阵列。
$key_field必要要对映为键的关联阵列栏位。
$val_field必要要对映为值的关联阵列栏位。
回传阵列
抛出InvalidArgumentException 当第一个变数不是一个阵列， 或没有实现 Iterator 介面。
範例
$people = array(
	"Jack" => 21,
	"Jill" => 23
);

print_r(Arr::keyval_to_assoc($people, 'name', 'age'));

// 结果：
Array
(
	[0] => Array
	(
		["name"] => "Jack"
		["age"] => 21
	)
	[1] => Array
	(
		["name"] => "Jill"
		["age"] => 23
	)
)

average($array)

average 方法取所有值并回传平均值。

静态是
参数
参数预设描述
$array必要要平均的值阵列。
回传阵列
範例
echo Arr::average(array('1', 2, 4, '8'));
// 结果：3.75

flatten($array, $glue = ':', $reset = true)

flatten 方法扁平化一个多维阵列（关联和索引）成为一个一维阵列。

静态是
参数
参数预设描述
$array必要要扁平化的阵列。
$glue
:
要用来把键黏合在一起的字串
$reset
true
我们应该建立一个新值的阵列而非合併它们进入由 flatten 所建立最后的阵列？
回传阵列
範例
$indexed = array(
	array("a"),
	array("b"),
	array("c"),
);

print_r(Arr::flatten($indexed, '_'));

// 结果：
Array
(
	[0_0] => a
	[0_1] => b
	[0_2] => c
)

flatten_assoc($array, $glue = ':', $reset = true)

flatten_assoc 方法扁平化一个多维关联阵列成为一个一维阵列。

静态是
参数
参数预设描述
$array必要要扁平化的阵列。
$glue
:
要用来把键黏合在一起的字串
$reset
true
我们应该建立一个新值的阵列而非合併它们进入由 flatten_assoc 所建立最后的阵列？
回传阵列
範例
$people = array(
	array(
		"name" => "Jack",
		"age"  => 21
	),
	array(
		"name" => "Jill",
		"age"  => 23
	)
);

print_r(Arr::flatten_assoc($people));

// 结果：
Array
(
	[0:name] => Jack
	[0:age]  => 21
	[1:name] => Jill
	[1:age]  => 23
)

// 让我们扁平化上面的另一个阵列
print_r(Arr::flatten_assoc(array(array("name" => "Humpty", "age" => 11)), ":", false));

// 结果：
Array
(
	[0:name] => Humpty
	[0:age]  => 11
	[1:name] => Jill
	[1:age]  => 23
)

reverse_flatten($array, $glue = ':')

reverse_flatten 方法反转一个已扁平化的多维阵列（关联和索引）成为它的原始形式。

静态是
参数
参数预设描述
$array必要要反扁平化的阵列。
$glue
:
要用来把键黏合在一起的字串
回传阵列
範例
$flattened = array(
	'0_name' => 'James',
	'0_age'  => 24,
	'1_name' => 'John',
	'1_age'  => 34,
);

print_r(Arr::reverse_flatten($flattened, '_'));

// 结果：
Array
(
	[0] => Array
		(
[name] => James
[age]  => 24
		)

	[1] => Array
		(
[name] => John
[age]  => 34
		)
)

filter_prefixed($array, $prefix, $remove_prefix = true)

filter_prefixed 方法以前缀过滤阵列。它回传一个开头是指定前缀的键的阵列。

静态是
参数
参数预设描述
$array必要要过滤的阵列。
$prefix必要用于过滤的字串
$remove_prefix
true
移除或保留在该阵列中键的前缀？
回传阵列
範例
$arr = array(
	"user_name" => "John",
	"user_surname" => "Lastname",
	"project_name" => "Fuel",
	"project_type" => "Framework",
);

print_r(Arr::filter_prefixed($arr, "user_"));

// 结果：
Array
(
	[name] => John
	[surname] => Lastname
)

// 让我们保留前缀
print_r(Arr::filter_prefixed($arr, "project_", false);

// 结果：
Array
(
	[project_name] => Fuel
	[project_type] => Framework
)

remove_prefixed($array, $prefix)

remove_prefixed 方法从一个阵列移除值如果它们与所给前缀相符。

静态是
参数
参数预设描述
$array必要要移除的来源阵列。
$prefix必要用于过滤的字串
回传阵列
範例
$arr = array(
	"user_name" => "John",
	"user_surname" => "Lastname",
	"project_name" => "Fuel",
	"project_type" => "Framework",
);

print_r(Arr::remove_prefixed($arr, "project"));

// 结果：
Array
(
	[user_name] => John
	[user_surname] => Lastname
)

filter_suffixed($array, $suffix, $remove_suffix = true)

filter_suffixed 方法以后缀过滤阵列。它回传一个结尾是指定后缀的键的阵列。

静态是
参数
参数预设描述
$array必要要过滤的阵列。
$suffix必要要用来过滤的字串
$remove_suffix
true
移除或保留在该阵列中键的后缀？
回传阵列
範例
$arr = array(
	"name_1" => "John",
	"surname_1" => "Lastname",
	"name_2" => "Ted",
	"surname_2" => "Surname",
);

print_r(Arr::filter_suffixed($arr, "_1"));

// 结果：
Array
(
	[name] => John
	[surname] => Lastname
)

// 让我们保留后缀
print_r(Arr::filter_suffixed($arr, "_1", false);

// 结果：
Array
(
	[name_1] => John
	[surname_1] => Lastname
)

remove_suffixed($array, $suffix)

remove_suffixed 方法从一个阵列移除值如果它们与所给后缀相符。

静态是
参数
参数预设描述
$array必要要移除的来源阵列。
$suffix必要要用来过滤的字串
回传阵列
範例
$arr = array(
	"name_1" => "John",
	"surname_1" => "Lastname",
	"name_2" => "Ted",
	"surname_2" => "Bear",
);

print_r(Arr::remove_suffixed($arr, "_1"));

// 结果：
Array
(
	[name_2] => Ted
	[surname_2] => Surname
)

filter_keys($array, $keys, $remove = false)

filter_keys 方法过滤一个所给阵列成一组键。它回传一个只包含在 $keys 阵列中项目的键的阵列。也可以从一个阵列移除指定的 $keys。

静态是
参数
参数预设描述
$array必要要过滤的阵列。
$keys必要要对以上阵列过滤的键阵列。
$remove
false
如果为 true，从 $array 移除 $keys 而非取回它们。
回传阵列
範例
$arr = array(
	"user_name" => "John",
	"user_surname" => "Lastname",
	"project_name" => "Fuel",
	"project_type" => "Framework",
);

print_r(Arr::filter_keys($arr, array('project_name', 'user_name')));

// 结果：
Array
(
	[project_name] => Fuel
	[user_name] => John
)

// 让我们移除一些键
print_r(Arr::filter_keys($arr, array('user_name', 'user_surname'), true));

// 结果：
Array
(
	[project_name] => Fuel
	[project_type] => Framework
)

filter_recursive($array, $callback = null)

filter_recursive 方法提供一个递迴版本的 PHP array_filter() 函式。就像它的对应，你可以选择性地传递一个回呼（callback）函式来决定什幺应该被过滤。

静态是
参数
参数预设描述
$array必要要过滤的阵列。
$callback
null
一个有效的回呼（callback）回传一个布林。
回传阵列
範例
$arr = array(
	"user_name" => "John",
	"user_surname" => "Lastname",
	"info" => array(
		0 => array(
"data" = "a value",
		),
		1 => array(
"data" = "",
		),
		2 => array(
"data" = 0,
		),
	),
);

print_r(Arr::filter_recursive($arr));

// 结果：
Array
(
	[project_name] => Fuel
	[user_name] => John
	[info] => Array
	(
		[0] => Array
		(
[data] => a value
		)
	)
)

// 让我们使用一个回呼（callback）
print_r(Arr::filter_recursive($arr, function($item){ return $item !== ""; });

// 结果：
Array
(
	[project_name] => Fuel
	[user_name] => John
	[info] => Array
	(
		[0] => Array
		(
[data] => a value
		)
		[2] => Array
		(
[data] => 0
		)
	)
)

subset($array, $keys, $default = null)

与 filter_keys 相似，subset 方法使用 $keys 中的值来存取此阵列并回传关联的值。不同的地方是 subset 回传所有请求的键，为任何缺少的键提供 $default。

这个方法内部使用 get 和 set，所以 $keys 可以包含句点表示法。

静态是
参数
参数预设描述
$array必要要筛选的阵列。
$keys必要要筛选上面阵列的键的阵列。
$default
null
在 $array 中找不到的键会给这个值来代替。
回传阵列
範例
$arr = array(
	"user" => array(
		"name" => "John",
		"surname" => "Lastname",
	),
	"project" => array(
		"name" => "Fuel",
		"type" => "Framework",
	),
);

print_r(Arr::subset($arr, array('project.name', 'user.name')));

// 结果：
Array
(
 	[project] => Array
         (
 [name] => Fuel
		 )
	[user] => Array
         (
 [name] => John
		 )
)

print_r(Arr::subset($arr, array('project.name', 'project.manager')));

// 结果：
Array
(
 	[project] => Array
         (
 [name] => Fuel
 [manager] =>
		 )
)

print_r(Arr::subset($arr, array('project.name', 'project.manager', 'user', 'not_provided'), 'Not Provided'));

// 结果：
Array
(
 	[project] => Array
         (
 [name] => Fuel
 [manager] => Not Provided
		 )
 	[user] => Array
         (
 [name] => John
 [surname] => Lastname
		 )
	[not_provided] => Not Provided
)

get($array, $key, $default = false)

get 方法回传所给使用句点表示法阵列的一个元素，或预设值如果它没被设定的话。

静态是
参数
参数预设描述
$array必要要存取的阵列
$key必要在 $array 中请求的键。如果 null 被传递做为键，整个阵列会被回传。
$default
false
如果请求的键不存在时要被回传的值
回传混合。如果你传递一个键的阵列，回传值将会是一个有所有请求删除结果的阵列。
範例
$person = array(
	"name" => "Jack",
	"age" => "21",
	"location" => array(
		"city" => "Pittsburgh",
		"state" => "PA",
		"country" => "US"
	)
);

echo Arr::get($person, "name", "Unknown Name");
// 结果："Jack"

echo Arr::get($person, "job", "Unknown job");
// 结果："Unknown job"

// 这个方法也可以透过使用一个点来分隔键与键之间，来深入到阵列
echo Arr::get($person, "location.city", "Unknown City");
// 结果："Pittsburgh"

set(&$array, $key, $value = null)

set 方法设定所给使用句点表示法阵列的元素。

警告：原始阵列透过参照被编辑

静态是
参数
参数预设描述
$array必要要存取的阵列
$key必要在 $array 中请求的键。如果没有传递键，或 null 被传递做为键，该阵列会取消设定。如果你传递一个键 - 值配对的阵列，所有阵列中的值将被设定。
$value
null
要被设定的值。如果 $key 是一个阵列会被忽略。
回传空
範例
$person = array(
	"name" => "Jack",
	"age" => "21",
	"location" => array(
		"city" => "Pittsburgh",
		"state" => "PA",
		"country" => "US"
	)
);

Arr::set($person, "name", "John");
// $person['name'] 设为 "John"

// 这个方法也可以透过使用一个点来分隔键与键之间，来深入到阵列
Arr::set($person, "location.city", "Philadelphia");
// $person['location']['city'] 设为 "Philadelphia"

// 或一次设定多个值
Arr::set($person, array("name" => "John", "location.city" => "Philadelphia"));

pluck($array, $key, $index = null)

pluck 方法从一个阵列的集合或物件採集值。

静态是
参数
参数预设描述
$array必要要採集的来源阵列
$key必要要採集来源阵列的键。
$index
null
选择性的回传阵列索引。
回传空
範例
$collection = array(
	array(
		'id' => 2,
		'name' => 'Bill',
		'surname' => 'Cosby',
	),
	array(
		'id' => 5,
		'name' => 'Chris',
		'surname' => 'Rock',
	),
	array(
		'id' => 7,
		'name' => 'Bert',
		'surname' => 'Visser',
	),
);

// 取得一个 ID 的阵列
$ids = \Arr::pluck($collection, 'id');
// array(2, 5, 7);

// 取得一个名称以 ID 为索引的阵列
$names = \Arr::pluck($collection, 'name', 'id');
// array(2 => 'Bill', 5 => 'Chris', 7 => 'Bert');

delete(&$array, $key)

delete 方法删除所给使用句点表示法阵列的元素。
警告：原始阵列透过参照被编辑，只有回传成功的布林值

静态是
参数
参数预设描述
$array必要要存取的阵列
$key必要请求在 $array 中的键。如果没有传递键，或传递 null 做为键值，该阵列会取消设定。
回传混合，true 如果该键被删除，false 如果该键不存在。如果你传递一个键的阵列，回传值将会是一个有所有请求删除结果的阵列。
範例
$person = array(
	"name" => "Jack",
	"age" => "21",
	"location" => array(
		"city" => "Pittsburgh",
		"state" => "PA",
		"country" => "US"
	)
);

$result = Arr::delete($person, "name");
// 从该阵列删除 $person['name']，回传 true

// 这个方法也可以透过使用一个点来分隔键与键之间，来深入到阵列
$result = Arr::delete($person, "location.city");
// 从该阵列删除 $person['location']['city']，回传 true

// 或一次删除多个值
$result = Arr::delete($person, array("name", "location.doesnotexist"));
// 删除 $person['name']，回传 array('name' => true, 'location.doesnotexist' => false)

insert(Array &$original, $value, $pos)

insert 方法主要是一个 array_splice 的别名，添加了错误检查
警告：原始阵列透过参照被编辑，只有回传成功的布林值

静态是
参数
参数预设描述
$original必要要使用的阵列
$value必要要新增的（多个）值
$pos必要要插入的数字位置，负数会从结尾向后算
回传布林
範例
$people = array("Jack", "Jill");

// 添加一个值
Arr::insert($people, "Humpty", 0);
print_r($people);
// 结果：
Array
(
	[0] => Humpty
	[1] => Jack
	[2] => Jill
)

// 添加多个值
Arr::insert($people, array("Hansel", "Gretel"), 1);
print_r($people);
// 结果：
Array
(
	[0] => Humpty
	[1] => Hansel
	[2] => Gretel
	[3] => Jack
	[4] => Jill
)

// 添加一个阵列
Arr::insert($people, array( array("name" => "Wolf", "teeth" => "sharp")), 0);
print_r($people);

// 结果：
Array
(
	[0] => Array
		(
[name] => Wolf
[teeth] => sharp
		)

	[1] => Humpty
	[2] => Hansel
	[3] => Gretel
	[4] => Jack
	[5] => Jill
)

insert_assoc(array &$original, array $values, $pos)

insert_assoc 方法新增元素进入一个关联阵列的指定位置。
警告：原始阵列透过参照被编辑，只有回传成功的布林值。

静态是
参数
参数预设描述
$original必要要使用的阵列
$values必要要新增的（多个）值
$pos必要新值应该被新增到原始阵列的位置。 如果给了一个负值，位置会从阵列后面算起。
回传布林，成功时为 true，如果 $pos 超出界限为 false。
範例
$character = array("name" => "Jack", "surname" => "Reacher");

Arr::insert_assoc($people, array("initial" => "P.");
print_r($people);

// 结果：
Array
(
	[name] => Jack
	[initial] => P.
	[surname] => Reacher
)

insert_before_key(Array &$original, $value, $key)

insert_before_key 方法添加一个元素到一个阵列在指定键之前
警告：原始阵列透过参照被编辑，只有回传成功的布林值

静态是
参数
参数预设描述
$original必要要使用的阵列
$value必要要新增的（多个）值
$key必要要在哪个键之前新增
回传布林
範例
$people = array("Jack", "Jill");

Arr::insert_before_key($people, "Humpty", 1);
print_r($people);

// 结果：
Array
(
	[0] => Jack
	[1] => Humpty
	[2] => Jill
)

insert_after_key(Array &$original, $value, $key, $is_assoc = false)

insert_after_key 方法添加一个元素到一个阵列在指定键之后。
警告：原始阵列透过参照被编辑，只有回传成功的布林值。

静态是
参数
参数预设描述
$original必要要使用的阵列
$value必要要新增的（多个）值
$key必要要在哪个键之后新增
$is_assoc
false
该阵列是否为关联
回传布林
範例
$people = array("Jack", "Jill");

Arr::insert_after_key($people, "Humpty", 1);
print_r($people);

// 结果：
Array
(
	[0] => Jack
	[1] => Jill
	[2] => Humpty
)

insert_after_value(Array &$original, $value, $search, $is_assoc = false)

insert_after_value 方法添加一个元素到一个阵列在指定值之后
警告：原始阵列透过参照被编辑，只有回传成功的布林值

静态是
参数
参数预设描述
$original必要要使用的阵列
$value必要要新增的（多个）值
$search必要要在哪个值之后新增
$is_assoc
false
该阵列是否为关联
回传布林
範例
$people = array("Jack", "Jill");

Arr::insert_after_value($people, "Humpty", "Jack");
print_r($people);

// 结果：
Array
(
	[0] => Jack
	[1] => Humpty
	[2] => Jill
)

sort($array, $key, $order = 'asc', $sort_flags = SORT_REGULAR)

sort 方法透过它自己的值来排序一个多维阵列。

静态是
参数
参数预设描述
$array必要要排序的阵列
$key必要在 $array 中要用来请求排序的键。
$order
'asc'
排序（asc 或 desc）。
$sort_flags
SORT_REGULAR
PHP 排序类型标誌（http://php.net/manual/en/function.sort.php）
回传混合
範例
$data = array(
	array(
		'info' => array(
'pet' => array(
	'type' => 'dog'
)
		),
	),
	array(
		'info' => array(
'pet' => array(
	'type' => 'fish'
)
		),
	),
	array(
		'info' => array(
'pet' => array(
	'type' => 'cat'
)
		),
	),
);

$data = Arr::sort($data, 'info.pet.type');
// 结果：
array(
	array(
		'info' => array(
'pet' => array(
	'type' => 'cat'
)
		),
	),
	array(
		'info' => array(
'pet' => array(
	'type' => 'dog'
)
		),
	),
	array(
		'info' => array(
'pet' => array(
	'type' => 'fish'
)
		),
	),
);

multisort($array, $conditions, $ignore_case = false)

sort 方法透过多个值来排序一个多维阵列。

静态是
参数
参数预设描述
$array必要要排序的阵列
$conditions必要阵列的排序条件。
$ornire_case
false
是否不区分大小写排序。
回传阵列
範例
$collection = array(
	'i5' => array(
		'name' => 'Carl',
		'age' => 17,
		'points' => 30,
		'arr' => array(
'key' => 10,
		),
	),
	'i7' => array(
		'name' => 'carl',
		'age' => 17,
		'points' => 20,
		'arr' => array(
'key' => 10,
		),
	),
	'i2' => array(
		'name' => 'Bert',
		'age' => 20,
		'points' => 30,
		'arr' => array(
'key' => 10,
		),
	),
);

$collection = \Arr::multisort($collection, array(
	'name' => SORT_ASC,
	'points' => array(SORT_ASC, SORT_NUMERIC),
	'age' => array(SORT_ASC, SORT_NUMERIC),
), true);
print_r($collection);

// 结果
Array
(
	[i2] => Array
		(
[name] => Bert
[age] => 20
[points] => 30
[arr] => Array
	(
		[key] => 10
	)

		)

	[i7] => Array
		(
[name] => carl
[age] => 17
[points] => 20
[arr] => Array
	(
		[key] => 10
	)

		)

	[i5] => Array
		(
[name] => Carl
[age] => 17
[points] => 30
[arr] => Array
	(
		[key] => 10
	)

		)
)

in_array_recursive($needle, $haystack, $strict = false)

in_array_recursive 方法以递迴方式检查一个值是否在阵列中。

静态是
参数
参数预设描述
$needle必要要搜寻的值
$haystack必要要搜寻的阵列。
$strict
false
是否使用 == 或 ===。
回传布林
範例
$arr = array('one' => 1, 2, 3, array(56), 87);

echo Arr::in_array_recursive('56', $arr);
// 结果：true

echo Arr::in_array_recursive('87', $arr, true);
// 结果：false

echo Arr::in_array_recursive(87, $arr, true);
// 结果：true

merge($array)

merge 方法递迴地合併两个阵列，与 array_merge_recursive() 有两个不同的重要方式：
- 当有两个不同值且都不是阵列时，后者的值将覆写前者， 而非将两者合併到一个阵列中
- 数字键不冲突就不会改变， 只有当数字键已存在且使用 array_push() 添加值时。

静态是
参数
参数类型预设描述
$array阵列必要必须都是阵列的多个变数
回传阵列
抛出InvalidArgumentException 当传递的参数之一不是阵列。
範例
$arr1 = array(
	'one' => 1,
	2,
	3,
	array(
		56
		),
	87
);

$arr2 = array(
	27,
	90,
	array(
		'give_me' => 'bandwidth'
		),
	'90',
	'php',
);

print_r( Arr::merge($arr1, $arr2) );
// 结果：
Array
(
	[one] => 1
	[0] => 2
	[1] => 3
	[2] => Array (
[0] => 56
	)
	[3] => 87
	[4] => 27
	[5] => 90
	[6] => Array (
[give_me] => bandwidth
	)
	[7] => 90
	[8] => php
)

merge_assoc($array)

merge_assoc 方法递迴地合併两个以上的阵列，与 array_merge_recursive() 有两个不同的重要方式：
- 当有两个不同值且都不是阵列时，后者的值将覆写前者， 而非将两者合併到一个阵列中
- 数字键不会改变

静态是
参数
参数类型预设描述
$array阵列必要多个都必须是阵列的变数
回传阵列
抛出InvalidArgumentException 在传递的参数之一不是阵列时。
範例
$arr1 = array(
	'one' => 1,
	2 => 2,
	3 => 3,
	4 => array(
		56
	),
	5=> 87
);

$arr2 = array(
	1 => 27,
	2 => 90,
	4 => array(
		'give_me' => 'bandwidth'
	),
	6 => '90',
	7 => 'php',
);

print_r( Arr::merge_assoc($arr1, $arr2) );
// 结果：
Array
(
	[one] => 1
	[2] => 90
	[3] => 3
	[4] => Array (
		[0] => 56
		[give_me] => bandwidth
	)
	[5] => 87
	[1] => 27
	[6] => 90
	[7] => php
)

search($array, $value, $default = null, $recursive = true, $delimiter = '.', $strict = false)

search 方法在阵列搜寻所给值并回传相应的键或预设值。
- 如果 $recursive 设为 true，那幺 search 方法将回传一个使用 $delimiter 的分隔符表示的键。

静态是
参数
参数类型预设描述
$array阵列必要要搜寻的阵列
$value混合必要搜寻的值
$default字串
null
如果请求值不存在要被回传的键
$recursive布林
true
是否递迴地取得键
$delimiter字串
'.'
当 $recursive 为 true 的分隔符
$strict布林
false
对键值做严格比对
回传整数｜字串｜null
抛出InvalidArgumentException 当第一变数不是阵列。 InvalidArgumentException $default 变数不是字串或整数或 null。 InvalidArgumentException $delimiter 变数不是字串。
範例
$arr = array(
	'one' => 1,
	'two' => 2,
	'three' => array(
		'a' => 4,
		'b' => 'foo'
	),
	'four',
	array(
null,
array(
	null,
	null,
	null,
	array(
		'deep'
	)
)
		),
);

echo Arr::search($arr, 1);
// one

echo Arr::search($arr, 'four');
// 0

var_dump(Arr::search($arr, 5));
// NULL

echo Arr::search($arr, 4, null, true);
// three.a

var_dump(Arr::search($arr, '4', null, true, '.', true));
// NULL

echo Arr::search($arr, 'deep', null, true);
// 1.1.3.0

unique($array)

unique 回传一个来源阵列中所有唯一值的阵列。 第一个符合的值将被保留，重複的会被丢弃，键将被保留。 此方法的运作像 array_unique()，但不先排序阵列， 并能让你去掉包含物件或闭包（closure）阵列的重複资料。

参数
参数类型预设描述
$array阵列必要要去重複的阵列
回传阵列
範例
$array = array(
	'val1' => 'hello', 'val2' => 'hello', 'val3' => 'bye',
);

// 结果：array('val1' => 'hello', 'val3' => 'bye')
$result = Arr::unique($array);

sum($array, $key)

sum 方法计算一个透过 $key 採集阵列中值的总和。

静态是
参数
参数类型预设描述
$array阵列必要包含值的阵列
$key字串必要要从阵列採集的键
回传整数
抛出InvalidArgumentException 当传递的变数之一不是阵列。
範例
$collection = array(
	array(
		'age' => 20,
		'name' => 'Bill',
		'scores' => array(
'math' => 10,
		),
	),
	array(
		'age' => 25,
		'name' => 'Chris',
		'scores' => array(
'math' => 15,
		),
	),
	array(
		'age' => 38,
		'name' => 'Bert',
		'scores' => array(
'math' => 5,
		),
	),
);

// 计算一个阵列 age 的总和。
$total_age = Arr::sum($collection, 'age'); // 83

// 计算一个透过 'scores.math' 採集的阵列的总和
$total_score = Arr::sum($collection, 'scores.math'); // 30

reindex($array)

reindex 方法递迴地重新索引一个阵列的数字键。它不会改变字串键。

静态是
参数
参数类型预设描述
$array阵列必要要重新索引的阵列
回传阵列
範例
$array = array(
	2 => 2,
	'three' => 3,
	5 => array(
		2 => 2,
		'three' => 3,
		5 => 5
	),
	7 => 7
);

// 重新索引阵列
print_r( Arr::reindex($array) );
// 结果：
Array
(
    [0] => 2
    [three] => 3
    [1] => Array
        (
            [0] => 2
            [three] => 3
            [1] => 5
        )

    [2] => 7
)

previous_by_key($array, $key, $get_value = false, $strict = false)

previous_by_key 方法能让你透过所给现有的键， 来取回阵列前一个元素的键或值。

静态是
参数
参数预设描述
$array必要要使用的阵列
$key必要目前要用做查找参考的键
$get_value
false
如果为 false，回传前一个阵列键，如果为 true，回传自身值
$strict
false
对键做严格比对
回传混合，回传的值、null 如果没有前一个阵列元素、或 false 如果目前键不存在。
範例
// 要查找的阵列
$arr = array(2 => 'A', 4 => '2', 6 => 'C');

// 回传 false，没有键 1 在该阵列
$result = Arr::previous_by_key($arr, 1);

// 回传 null，没有前一个键
$result = Arr::previous_by_key($arr, 2);

// 回传 false，没有键 2 在该阵列
$result = Arr::previous_by_key($arr, '2', false, true);

// 回传 2，在该阵列中它是键 4 之前的键
$result = Arr::previous_by_key($arr, 4);

// 回传 'A'，在该阵列中它是指向前一个键的值
$result = Arr::previous_by_key($arr, 4, true);

next_by_key($array, $key, $get_value = false, $strict = false)

next_by_key 方法能让你透过所给现有的键， 来取回阵列下一个元素的键或值。

静态是
参数
参数预设描述
$array必要要使用的阵列
$key必要目前要用做查找参考的键
$get_value
false
如果为 false，回传下一个阵列键，如果为 true，回传自身值
$strict
false
对键做严格比对
回传混合，回传的值、null 如果没有下一个阵列元素、或 false 如果目前键不存在。
範例
// 要查找的阵列
$arr = array(2 => 'A', 4 => '2', 6 => 'C');

// 回传 false，没有键 1 在该阵列
$result = Arr::next_by_key($arr, 1);

// 回传 null，没有下一个键
$result = Arr::next_by_key($arr, 6);

// 回传 false，没有键 2 在该阵列
$result = Arr::next_by_key($arr, '2', false, true);

// 回传 6，在该阵列中它是键 4 之后的键
$result = Arr::next_by_key($arr, 4);

// 回传 'C'，在该阵列中它是指向下一个键的值
$result = Arr::next_by_key($arr, 4, true);

previous_by_value($array, $value, $get_value = true, $strict = false)

previous_by_value 方法能让你透过所给现有的元素值， 来取回阵列前一个元素的键或值。

静态是
参数
参数预设描述
$array必要要使用的阵列
$value必要目前要用做查找参考的元素值
$get_value
true
如果为 false，回传前一个阵列键，如果为 true，回传自身值
$strict
false
对元素值做严格比对
回传混合，回传的值、null 如果没有前一个阵列元素、或 false 如果找不到目前值。
範例
// 要查找的阵列
$arr = array(2 => 'A', 4 => '2', 6 => 'C');

// 回传 false，没有值 'Z' 在该阵列
$result = Arr::previous_by_value($arr, 'Z');

// 回传 null，没有前一个键
$result = Arr::previous_by_value($arr, 'A');

// 回传 false，没有值 2 在该阵列，只有 '2'
$result = Arr::previous_by_value($arr, 2, false, true);

// 回传 'A'，在该阵列中它是指向前一个键的值
$result = Arr::previous_by_value($arr, '2');

// 回传 2，它是前一个阵列元素的键
$result = Arr::previous_by_value($arr, '2', false);

next_by_value($array, $value, $get_value = true, $strict = false)

next_by_value 方法能让你透过所给现有的元素值， 来取回阵列下一个元素的键或值。

静态是
参数
参数预设描述
$array必要要使用的阵列
$value必要目前要用做查找参考的元素值
$get_value
true
如果为 false，回传下一个阵列键，如果为 true，回传自身值
$strict
false
对元素值做严格比对
回传混合，回传的值、null 如果没有下一个阵列元素、或 false 如果找不到目前值。
範例
// 要查找的阵列
$arr = array(2 => 'A', 4 => '2', 6 => 'C');

// 回传 false，没有值 'Z' 在该阵列
$result = Arr::next_by_value($arr, 'Z');

// 回传 null，没有下一个键
$result = Arr::next_by_value($arr, 'C');

// 回传 false，没有值 2 在该阵列，只有 '2'
$result = Arr::next_by_value($arr, 2, false, true);

// 回传 'C'，在该阵列中它是指向下一个键的值
$result = Arr::next_by_value($arr, '2');

// 回传 6，它是下一个阵列元素的键
$result = Arr::next_by_value($arr, '2', false);

请注意，'by_key' 和 'by_value' 方法使用回传值 null 和 false 来标记错误条件。 因此，传递的阵列不得包含 null 或 false 的键或值。

程序助手

in_arrayi($needle, $haystack)

in_arrayi 函式是一个不区分大小写版本的 in_array。

参数
参数类型预设描述
$needle字串必要要搜寻的值
$haystrack阵列必要要搜寻的阵列
回传布林
範例
echo in_arrayi('This', array('something','tHis'));
// 结果：true

echo in_arrayi('Thi', array('something','tHis'));
// 结果：false
免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
@小牛知识库 xnip.cn