Arr 类別

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 方法在陣列搜尋所給值并回傳相應的鍵或預設值。
- 如果 $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