php开发技术（PHP 开发工程师基础篇 - PHP 数组）

php教程 菜鸟教程

文章转发自PHP开发者社区，原始链接：https://learnku.com/articles/36866数组 (Array)数组是 PHP 中最重要的数据类型，可以说是掌握数组，教程基本上 PHP 一大半问题都可以解决. PHP 数组与其他编程语言数组概念不一样。

其他编程语言数组是由相同类型的元素（element）的集合所组成的数据结构，而 PHP 数组元素可以为不同类型的元素因教程此说 PHP 数组不是纯粹的数组，而是哈希 (字典) 更为恰当.PHP 数组可以当作真正的数组，或列表（向量），散列表（是映射的一种实现），字典，集合，栈，队列以及更多可能性。

数组分为关联数组 (类似教程字典) 和索引数组 (纯数组，键值从数字开始，一般从 0 开始).PHP 数组底层实现详解 PHP 数组的底层实现：HashTable为了大家能够顺利进阶中高级、架构师，我特地为大家准备了一套精品

PH教程P架构师教程，保证你学了以后保证薪资上升一个台阶需要的请点击加群（→）点击此处语法array$arr = array(1, 2, 3);[]$arr = [1, 2, 3];数组键值注意事项PHP 数教程组的键值仅支持字符串 (string) 和整型 (integer). 其他类型均会转换数字或字符串。

浮点类型会被转换为整型类型的，8.7->8. 布尔类型则会转换为整型类型的，true->1, fal教程se->0. Null 会被转换为空的字符串，数组和对象则不会转换成为字符串类型和整型会抛出一个警告: Illegal offset type.。

注意的是字符串类型假如是有效十进制数字的话，则会转换为教程整型. "8"->8. 若不想转换则在数字前添加 "+" 符号.// 02不是有效十进制数字 $arr = [1 => a, +1 => b, 02 => c]; /*教程* array(3) { [1]=> string(1) "a" ["+1"]=> string(1) "b" 教程 ["02"]=> string(1) "c" } */ var_dump($arr); // 数组的键值可以不用教程有键值, 下面这个数组最大数字是6,所以在它后面的元素,则是在它基础上+1 $array = array( "a", "b", 6 =>教程 "c", "d", ); /** array(4) { [0]=> string(1) "a" 教程 [1]=> string(1) "b" [6]=> string(1) "c" [7]=> string(1)教程 "d" } */ var_dump($array);

数组基本操作 (增删改查)通过在方括号 ([]) 内指定键名来给数组赋值实现的增加和修改元素，也可教程以省略键名.增加数组的元素// 索引数组 $arr = [1, 2, 3]; $arr[] = 4; // [1, 2, 3, 4] // 关联数组 教程 $arr1 = [a => 1, b => 2]; $arr1[c] = 3; // [a => 1, b => 2, c => 3] // 混合数组 教程 $arr3 = [a => 1, b => 2]; $arr3[1] = 3; // [a => 1, b => 2, 1 => 3]

删除数组的元素$arr = [1, 教程2, 3]; // 删除数组中值为3的, 注意的是数组不会被重新索引(索引数组) unset($arr[2]); $arr[] = 3; 教程 /** array(3) { [0]=> int(1) [1]=> int(2) [3]=> 教程 int(3) } */ var_dump($arr);

改变数组的元素$arr = [1, 2, 3]; $arr[0] = a; var_dum教程p($arr); [a, 2, 3]查询数组的元素$arr = [1, 2, 3]; var_dump($arr[0]); // 1

其他类型转换为数组除了对象 (Object) 转换数组外，对于对于任教程意 integer，float，string，boolean 和 resource 类型，如果将一个值转换为数组，将得到一个仅有一个元素的数组，其下标为 0.

(array)$scalarValue 与教程 array ($scalarValue) 一样而对象 (object) 类型转换为 array. 其单元为该对象的属性键名将为成员变量名，不过有几点例外：整数属性不可访问；私有变量前会加上类名作前缀教程；保护变量前会加上一个 * 做前缀。

这些前缀的前后都各有一个 NULL 字符这会导致一些不可预知的行为：class A { private $A; // This will becom教程e \0A\0A } class B extends A { private $A; // This will become \0B\0A 教程 protected $B // This will \0*\0A public $AA; // This will become AA } // 教程会有两个键名为 AA，不过其中一个实际上是 \0A\0A。

/** array(4) { ["BA"]=> NULL ["*B"]=> 教程 NULL ["AA"]=> NULL ["AA"]=> NULL } */ 教程 var_dump((array) new B());。

整数属性数组函数分类创建数组array_combine (array $keys , array $values) : array — 创建一个教程数组，用一个数组的值作为其键名，另一个数组的值作为其值$key = [a, b, c]; $value = [1, 2, 3]; print_r(array_combi教程ne($key, $value)); // [a => 1, b => 2, c => 3]

array_fill_keys (array $keys , mixed $value) : array —教程 使用指定的键和值填充数组$keys=[red,blue,green];var_dump(array_fill_keys($keys,1));// [red => 1, blue => 1, gree教程n => 1]

array_fill (int $start_index , int $num , mixed $value) : array — 用给定的值填充数组var_dump(array_fil教程l(0, 0, 1)); // [] var_dump(array_fill(1, 3, red)); // [1=>red, 2=>red, 3=>red]

array — 新建一个数教程组// array() 是语言结构, 不是常规函数 $a = array(1, 2, 3);compact (mixed $varname1 [, mixed $...] ) : ar教程ray — 建立一个数组，包括变量名和它们的值

$a = apple; $b = banana; $d = lemon; $sweet = [b, d];教程 $result = compact(a, $sweet); // [a => apple, b => banana, d => lemon]

range (mixed $start ,教程 mixed $end [, number $step = 1] ) : array — 根据范围创建数组，包含指定的元素var_dump(range(1, 5)); // [1, 2, 3, 4, 教程5] var_dump(range(0, 100, 10)); // [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

数组分割array_chu教程nk (array $array , int $size [, bool $preserve_keys = FALSE] ) : array — 将一个数组分割成多个$a = [a => 1, B =教程> 2, 3 => c, A => 4, b => 6]; print_r(array_chunk($a, 2)); // [[1, 2], [c, 4], [6]] 教程print_r(array_chunk($a, 2, true)); // [[a => 1, B => 2], [3 => c, A => 4], [b => 6]]

array_slice (arr教程ay $array , int $offset [, int $length = NULL [, bool $preserve_keys = FALSE]] ) : array — 从数组中取出一段

$教程input = [a, b, c, e, f]; var_dump(array_slice($a, 2)); // [c, e, f] var_dump(array_s教程lice($a, 2, 1)); // [c] var_dump(array_slice($a, -1, 1)); // [f] var_dump(array_slic教程e($a, -1, 1, true)); [4 => f] var_dump(array_slice($a, 0, 6)); // [a, b, c, e, f]

数组队列或栈操作arr教程ay_pop (array &$array) : mixed — 弹出数组最后一个单元（出栈）$arr1 = [yellow, green, red] var_dump(array_p教程op($arr1)); // yellow

array_push (array &$array [, mixed $...] ) : int — 将一个或多个单元压入数组的末尾（入栈）var_dump(教程array_push([1, 2, 3], 4, 5)) // 2

array_shift (array &$array) : mixed — 将数组开头的单元移出数组$a [php, c, pytho教程n]; var_dump(array_shift($a));// php

array_unshift (array &$array [, mixed $...] ) : int — 在数教程组开头插入一个或多个单元$queue = [orange, banana]; var_dump(array_unshift($queue, apple)); // 3 教程var_dump($queue);

数组数学运算.array_count_values (array $array): array — 统计数组中所有的值print_r(array_count_valu教程e([1, hello, 1, hello, world])) // [1=>2, hello => 2, world => 1]

array_product (array $array) : numb教程er — 计算数组中所有值的乘积$a = array(2, 4, 6, 8); var_dump(array_product($a));// 384 var_dump(教程array_product([])); // 1

array_reduce ( array $array , callable $callback [, mixed $initial = NULL ] 教程) : mixedfunction sum ($carry, $item) { $carry += $item; return $carry; } 教程 $a = [1, 2, 3, 4, 5]; var_dump(array_reduce($a, sum)); // 15 var_dump(array_re教程duce($a, sum, 10)); // 25

array_sum (array $array) : number — 对数组中所有值求和var_dump(array_sum([1, 2, 3]))教程; // 6 var_dump(array_sum([])); // 0

数组键值操作array_change_key_case (array $array [, int $case =教程 CASE_LOWER] ) : array — 将数组中的所有键名修改为全大写或小写$a = [a => 1, B => 2, 3 => c, A => 4]; print_r(ar教程ray_change_key_case($a)); // [a => 4, b => 2, 3 => c] print_r(array_change_key_case($a, CASE教程_UPPER)); // [A => 4, B => 2, 3 => c]

array_key_exists (mixed $key , array $array) : bool — 检查数组里是否有指教程定的键名或索引var_dump(array_key_exists(first, [first => 1, second => 2])); // true

array_key_first (array $教程array) : mixed — 获取数组第一个键值// php >= 7.3.0 var_dump(array_key_first([a => 1, b => 2])); // a

a教程rray_key_last (array $array) : mixed — 获取数组最后一个键值// php >= 7.3.0 var_dump(array_key_last([a 教程=> 1, b => 2])); // b

array_keys (array $array , mixed $search_value [, bool $strict = FALSE] ) : arr教程ay | array_keys ( array $array ) : array — 返回数组中部分的或所有的键名

$a = [a => 1, b => 2, c => 3]; var_教程dump(array_keys($a)); // [a, b, c] var_dump(array_keys($a, 1)); // a var_dump(array_教程keys($a, 1, true)); // []

key_exists — 别名 array_key_exists数组元素操作array_pad (array $array , int $size ,教程 mixed $value) : array — 以指定长度将一个值填充进数组

$input = [12, 10, 9]; var_dump(array_pad($input, 5, 2教程)); // [12, 10, 9, 2, 2] var_dump(array_pad($input, -5, 2)); // [2, 2, 12, 10, 9] va教程r_dump(array_pad($input, 4, [1])); // [12, 10, 9, [1]]

array_rand (array $array [, int $num = 1] ) : 教程mixed — 从数组中随机取出一个或多个单元var_dump(array_rand([1, 2, 3], 2)); // [1, 3]

array_search (mixed $needle , ar教程ray $haystack [, bool $strict = FALSE] ) : mixed — 在数组中搜索给定的值，如果成功则返回首个相应的键名

$a = [1, blue, red, php,教程 0]; var_dump(array_search(php, $a)); // 2 var_dump(array_search(false, $a)); // 3 教程 var_dump(array_search(false, $a, true)); // false

array_values (array $array) : array — 返回数组中所教程有的值$a = [a => 1, b => 2]; var_dump(array_value($a)); // [1, 2]

in_array (mixed $needle , arra教程y $haystack [, bool $strict = FALSE] ) : bool 检查数组中是否存在某个值// 字符串比较是大小写敏感 $os = [Mac, NT, Iri教程x, Linux, 1]; var_dump(in_array(Linux, $os)); // true var_dump(in_array(1, $os)); //教程true var_dump(in_array(1a, $os)); //true // 开启严格类型比较 var_dump(in_array(1, $o教程s, true)); // false

数组交集与差集，合并array_diff_assoc (array $array1 , array $array2 [, array $...] ) : arra教程y — 带索引检查计算数组的差集$array1 = ["a" => "green", "b" => "brown", "c" => "blue", "red"]; $array2 = 教程["a" => "green", "yellow", "red"]; print_r(array_diff_assoc($array1, $array2)); // ["b" => "教程brown", "c" => "blue", 0 => "red"]

array_diff_key (array $array1 , array $array2 [, array $...] ) : a教程rray — 使用键名比较计算数组的差集$array1 = [blue => 1, red => 2]; $array2 = [green => 2, blue => 1]; 教程 print_r(array_diff_key($array1, $array2)); // [red => 2];

array_diff_uassoc (array $array1 , arra教程y $array2 [, array $...], callable $key_compare_func ) : array — 用用户提供的回调函数做索引检查来计算数组的差集

function key教程_compare_func($a, $b) { if ($a === $b) { return 0; } return 教程($a > $b)? 1:-1; } $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "r教程ed"); $array2 = array("a" => "green", "yellow", "red"); $result = array_diff_uassoc(教程$array1, $array2, "key_compare_func"); print_r($result); // ["b" => "brown", "c" => "blue", 教程"red"]

array_diff_ukey (array $array1 , array $array2 [, array $...], callable $key_compare_func ) : 教程array — 用回调函数对键名比较计算数组的差集

function key_compare_func($key1, $key2) { if ($key1 == $key教程2) { return 0; } else if ($key1 > $key2) { return 1; } else { 教程 return -1; } } $array1 = [blue => 1, red => 2, green => 3]; $array教程2 = [green => 5, blue => 6, yellow => 8]; var_dump(array_diff_ukey($array1, $array2, key_com教程pare_func)); // [red => 2]

array_diff (array $array1 , array $array2 [, array $...] ) : array — 计算数组的教程差集$array1 = [red, blue, green]; $array2 = [red, yellow, hello]; $array3 = [green, wo教程rld]; var_dump(array_diff($array1, $array2, $array3)); // [blue]

array_intersect_assoc (array教程 $array1 , array $array2 [, array $...] ) : array — 带索引检查计算数组的交集$array1 = array("a" => "green", "b" 教程=> "brown", "c" => "blue", "red"); $array2 = array("a" => "green", "b" => "yellow", "blue", 教程"red"); $result_array = array_intersect_assoc($array1, $array2); print_r($result_arr教程ay); // [a => green]

array_intersect_key (array $array1 , array $array2 [, array $...] ) : array — 使用教程键名比较计算数组的交集$array1 = array(blue => 1, red => 2, green => 3, purple => 4); $array2 = array(gr教程een => 5, blue => 6, yellow => 7, cyan => 8); var_dump(array_intersect_key($array1, $array2)教程); // [blue => 1, green=>5]

array_intersect_uassoc ( array $array1 , array $array2 [, array $... ], c教程allable $key_compare_func ) : array

— 带索引检查计算数组的交集，用回调函数比较索引$array1 = ["a" => "green", "b" => "brown"教程, "c" => "blue", "red"]; $array2 = ["a" => "GREEN", "B" => "brown", "yellow", "red"]; 教程 var_dump(array_intersect_uassoc($array1, $array2, strcasecmp)); // [b => brown]

array_intersect_uke教程y (array $array1 , array $array2 [, array $...], callable $key_compare_func ) : array — 用回调函数比较键名来计算教程数组的交集

$array1 = ["a" => "green", "b" => "brown", "c" => "blue", "red"]; $array2 = ["a" => "GR教程EEN", "B" => "brown", "yellow", "red"]; var_dump(array_intersect_ukey($array1, $array2, strc教程asecmp)); // [a => green, b => brown, red]

array_intersect (array $array1 , array $array2 [, array $.教程..] ) : array — 计算数组的交集$a = [a => green, red, blue]; $b = [b => green, yellow, red]; 教程 var_dump(array_intersect($a, $b)); // [a => green, red]

array_merge_recursive ([array $...] ) : arra教程y — 递归地合并一个或多个数组$arr1 = [color => [favorite => red, 5]]; $arr2 = [color => [favorite => gree教程n, 6, 7]]; var_dump(array_merge_recursive($arr1, $arr2)); // [color => [favorite => [red, gr教程een], 5, 6, 7]]

array_merge (array $array1 [, array $...] ) : array — 合并一个或多个数组$arr1 = [color => [fav教程orite => red, 5]]; $arr2 = [color => [favorite => green, 6, 7]]; var_dump(array_merg教程e($arr1, $arr2)); // [color => [favorite => green, 6, 7]]; var_dump($arr1 + $arr2); // [colo教程r => [favorite => red, 5]]

array_udiff_assoc (array $array1 , array $array2 [, array $...], callable 教程$value_compare_func ) : array — 带索引检查计算数组的差集，用回调函数比较数据

// https://segmentfault.com/q/1010000000364758教程/a-1020000000364791 array_udiff_assoc 和 array_diff_uassoc 区别 /** * https://www.reddi教程t.com/r/PHP/comments/1ncqc0/real_difference_between_array_udiff_assoc_and/ */ $item1教程 = [ 1 => "a", "b", "c"]; $item2 = [-1 => a, -2 => b, -3 => c]; $item3 = [1 => [a], 教程[b], [c]]; function compareKey($a, $b) { if(abs($a) == abs($b)) return 0; re教程turn (abs($a) > abs($b)) ? 1 : -1; } function compareValue($a, $b) { $tempA 教程= is_array($a) ? $a[0] : $a; $tempB = is_array($b) ? $b[0] : $b; if($tempA == $tempB教程) return 0; return ($tempA > $tempB) ? 1 : -1; } print_r(array_diff_uassoc($教程item1, $item2, compareKey)); // [] print_r(array_udiff_assoc($item1, $item2, compareKey)); /教程/ [a, b, c] print_r(array_diff_uassoc($item1, $item3, compareValue)); // [a, b, c] p教程rint_r(array_udiff_assoc($item1, $item3, compareValue)); // []

array_udiff_uassoc (array $array1 , ar教程ray $array2 [, array $...], callable $value_compare_func , callable $key_compare_func ) : array — 带索教程引检查计算数组的差集，用回调函数比较数据和索引

$a = [0.1 => 9, 0.5 => 12, 0 => 23, 1 => 4, 2 => -15]; $b = [0.2 => 9教程, 0.5 => 22, 0 => 3, 1 => 4, 2 => -15]; function compareKey($a, $b) { if ($a === $b)教程 return 0; return $a > $b ? 1 : -1; } function compareValue($a, $b) { 教程 if ($a === $b) return 0; return $a > $b ? 1 : -1; } print_r(array_udiff_ua教程ssoc($a, $b, compareValue, compareKey)); // [0.1 => 9, 0.5 => 12, 0 => 23]

array_udiff (array $array1教程 , array $array2 [, array $...], callable $value_compare_func ) : array — 用回调函数比较数据来计算数组的差集

$a = [[1,教程 2], [7, 1], [2, 9]]; $b = [[1, 3], [8, 1], [2, 9]]; function compare($a, $b) { 教程 $areaA = $a[0] * $a[1]; $areaB = $b[0] * $b[1]; if ($areaA == $areaB) return 0; 教程 return $areaA > $areaB ? 1 : -1; } print_r(array_udiff($a, $b, compare)); //教程 [[1, 2], [7, 1]]

array_uintersect_assoc (array $array1 , array $array2 [, array $...], callable $val教程ue_compare_func ) : array — 带索引检查计算数组的交集，用回调函数比较数据

$a = [a => green, b => brown, c => blue, red]; 教程 $b = [a => GREEN, B => brown, yellow, red]; print_r(array_uintersect_assoc($a, $b, strc教程asecmp)); // [a => green]

array_uintersect_uassoc (array $array1 , array $array2 [, array $...], call教程able $value_compare_func , callable $key_compare_func ) : array — 带索引检查计算数组的交集，用单独的回调函数比较数据和索引

$array教程1 = array("a" => "green", "b" => "brown", "c" => "blue", "red"); $array2 = array("a" => "GRE教程EN", "B" => "brown", "yellow", "red"); print_r(array_uintersect_uassoc($array1, $array2, "st教程rcasecmp", "strcasecmp")); // [a => green, b => brown]

array_uintersect (array $array1 , array $array教程2 [, array $...], callable $value_compare_func ) : array — 计算数组的交集，用回调函数比较数据

$a = [[1, 2], [7, 1], [2教程, 9]]; $b = [[1, 3], [8, 1], [2, 9]]; function compare($a, $b) { $areaA = $a教程[0] * $a[1]; $areaB = $b[0] * $b[1]; if ($areaA == $areaB) return 0; return 教程$areaA > $areaB ? 1 : -1; } print_r(array_uintersect($a, $b, compare)); // [[2, 9]]

数教程组排序array_multisort (array &$array1 [, mixed $array1_sort_order = SORT_ASC [, mixed $array1_sort_flag教程s = SORT_REGULAR [, mixed $...]]] ) : bool — 对多个数组或多维数组进行排序

// 更多用法请看 https://www.php.net/manual/en/f教程unction.array-multisort.php $ar1 = [10, 100, 100, 0]; $ar2 = [1, 3, 2, 4]; a教程rray_multisort($ar1, $ar2); // [0, 10, 100, 100] [4, 1, 2, 3] array_multisort($ar1, SORT_DES教程C, SORT_NUMERIC, $ar2, SORT_ASC, SORT_NUMERIC); // [100, 100, 10, 0] [2, 3, 1, 4]

arsort (array &$arr教程ay [, int $sort_flags = SORT_REGULAR] ) : bool — 对数组进行逆向排序并保持索引关系// 排序针对的是值, 而且会保存原先索引 $frui教程ts = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple"); arsort($fruits教程); print_r($fruits); // [a => orange, d => lemon, b => banana, c => apple];

asort (array &$ar教程ray [, int $sort_flags = SORT_REGULAR] ) : bool — 对数组进行排序并保持索引关系$fruits = array("d" => "lemon", "a" 教程=> "orange", "b" => "banana", "c" => "apple"); asort($fruits); print_r($fruits); // 教程[c => apple, b => banana, d => lemon, a => orange];

krsort (array &$array [, int $sort_flags = SORT_R教程EGULAR] ) : bool — 对数组按照键名逆向排序$fruits = [d => lemon, a => orange, b => banana, c => apple]; 教程krsort($fruits);//true var_dump($fruits); // [d => lemon, c => apple, b => banana, a => oran教程ge]

ksort (array &$array [, int $sort_flags = SORT_REGULAR] ) : bool — 对数组按照键名排序$fruits = [d => lemon教程, a => orange, b => banana, c => apple]; ksort($fruits);//true var_dump($fruits); //教程 [a => orange, b => banana, c => apple, d => lemon]

rsort (array &$array [, int $sort_flags = SORT_RE教程GULAR] ) : bool — 对数组逆向排序$fruits = array("lemon", "orange", "banana", "apple"); rsort($fruit教程s); // true var_dump($fruits); // [orange, lemon, banana, apple]

sort (array &$array [, int $教程sort_flags = SORT_REGULAR] ) : bool — 对数组排序// https://bettercuicui.github.io/2018/04/01/PHP/php%20so教程rt%E6%8E%92%E5%BA%8F%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86/ $fruits = array("lemon", "orange",教程 "banana", "apple", 1); sort($fruits); var_dump($fruits); // [apple, banana, lemon, 教程orange, 1] // 数字比较项目, a1 转换数字为 0, 所以排序顺序如下 $arr1 = [a1, 0, 2, 1a]; sort($arr教程1, SORT_NUMERIC); var_dump($arr1); // [a1, 0, 1a, 2] // 被作为字符串来比较 $fruits = 教程array("lemon", "orange", "banana", "apple", 1); sort($fruits, SORT_STRING); var_dump教程($fruits); // [1, apple, banana, lemon, orange] // 根据当前的区域（locale）设置来把单元当作字符串比较，可以用 setlocal教程e() 来改变 $fruits = array("lemon", "orange", "banana", "apple", 1); sort($fruits, SORT教程_LOCALE_STRING); var_dump($fruits); // [1, apple, banana, lemon, orange] // 和 natsor教程t() 类似对每个单元以“自然的顺序”对字符串进行排序 $arr = [a1, A1, c2, c3, b4, b5, B1]; sort($arr, SORT_NAT教程URAL); // true var_dump($arr); // [A1, B1, a1, b4, b5, c2, c3] // 能够与 SORT_STRING 或 教程SORT_NATURAL 合并（OR 位运算），不区分大小写排序字符串。

$fruits = array("lemon", "orange", "banana", "apple", "Apple", 1教程); sort($fruits, SORT_FLAG_CASE|SORT_STRING); var_dump($fruits); // [1, "apple", "Ap教程ple", "banana", "lemon", "orange"]。

uasort (array &$array , callable $value_compare_func) : bool — 使用教程用户自定义的比较函数对数组中的值进行排序并保持索引关联// 用户自定义值比较函数, 保持索引不变 function compare($a, $b) { if ($a =教程== $b) { return 0; } return ($a 3, b => 9, c => 4, d => 8, e => -1]; 教程 uasort($arr, compare); // true var_dump($arr); // [e => -1, a => 3, c => 4, d => 8, b => 9]教程

uksort (array &$array , callable $key_compare_func) : bool — 使用用户自定义的比较函数对数组中的键名进行排序// 用户自定义值比较函数, 保教程持索引不变 function keyCompare($a, $b) { if ($a === $b) { return 0; } 教程 return ($a > $b) ? -1 : 1; } $arr = [a => 3, b => 9, c => 4, e => 8, d => -1]; 教程 uksort($arr, compare); // true var_dump($arr); // [a => 3, b => 9, c => 4, d => -1, 教程e => 8]

usort (array &$array , callable $value_compare_func) : bool — 使用用户自定义的比较函数对数组中的值进行排序// 对多维数组排教程序时，$ a和$ b包含对数组第一个索引的引用。

function cmp($a, $b) { return strcmp($a["fruit"], $b["fruit"教程]); } $fruits = [[fruit => lemons], [fruit => apples], [fruit => grapes]]; u教程sort($fruits, "cmp"); var_dump($arr); // [[fruit => apples], [fruit => grapes], [fruit => le教程mons]]。

natcasesort (array &$array) : bool — 用 “自然排序” 算法对数组进行不区分大小写字母的排序// 自然排序, 以人们认知方式排序,不区分大小写 教程 $arr = [a1, A1, c2, c3, b4, b5, B1]; natcasesort($arr); // true var_dump($arr);教程 // [a1, A1, B1, b4, b5, c2, c3]

natsort (array &$array) : bool — 用 “自然排序” 算法对数组排序// 自然排序, 以人们认知方式排序,教程区分大小写 $arr = [a1, A1, c2, c3, b4, b5, B1]; natsort($arr); // true var_dump($教程arr); // [A1, B1, a1, b4, b5, c2, c3]

回调函数处理数组array_filter (array $array [, callable $callback [, int教程 $flag = 0]] ) : array — 用回调函数过滤数组中的单元

// 若没有回调函数, 则筛选值为false $a = [1, 0, false, null, 0, 2, 教程, false]; var_dump(array_filter($a)); // [1, "false", "null", 2] $b = [6, 7, 8, 9, 1教程0, 11, 12]; function odd($var) { return $var & 1; } var_dump教程(array_filter($b, odd)); // [7, 9, 11]

array_map (callable $callback , array $array1 [, array $...] )教程 : array — 为数组的每个元素应用回调函数print_r(array_map(strtoupper, [a, b, c])); // [A, B, C] function de教程mo($n, $m) { return strtoupper($n) . - . strtoupper($m); } print_r(demo, [a,教程 b, c], [d, e, f]); // [A-D, B-E, C-F]

array_walk_recursive (array &$array , callable $callback [, mi教程xed $userdata = NULL] ) : bool — 对数组中的每个成员递归地应用用户函数

$sweet = [a => apple, b => banana]; $frui教程ts = [sweet => $sweet, sour => lemon]; function testPrint($item, $key) { echo "$key 教程holds $item\n"; } /** * a holds apple * b holds banana * sou教程r holds lemon */ array_walk_recursive($fruits, testPrint); function testPrin教程t2($item, $key, $userData) { $item = strtoupper($item); echo "$key holds $item and $教程userData\n"; } /** * a holds apple and php * b holds banana and php 教程 * sour holds lemon and php */ array_walk_recursive($fruits, testPrint2, php)教程;

array_walk (array &$array , callable $callback [, mixed $userdata = NULL] ) : bool — 使用用户自定义函数对数组中的教程每个元素做回调处理

$sweet = [a => apple, b => banana]; function testPrint($item, $key) { echo 教程"$key holds $item\n"; } /** * a holds apple * b holds banana 教程 */ array_walk($sweet, testPrint); function testPrint($item, $key, $userData) { 教程 echo "$key holds $item and $userData\n"; } /** * a holds apple and php 教程 * b holds banana and php * sour holds lemon and php */ array_walk_rec教程ursive($fruits, testPrint2, php);

数组替换array_replace_recursive (array $array1 [, array $...] ) : array教程 — 使用传递的数组递归替换第一个数组的元素$base = [citrus => [orange], berries => [blackberry, raspberry]]; $rep教程lacements = [citrus => [pineapple], berries => [blueberry]]; var_dump(array_replace_recursiv教程e($base, $replacements));// [citrus => [pineapple], berries => [blueberry, raspberry]]

array_replace 教程(array $array1 [, array $...] ) : array — 使用传递的数组替换第一个数组的元素$base = [citrus => [orange], berries => [教程blackberry, raspberry]]; $replacements = [citrus => [pineapple], berries => [blueberry]]; 教程 var_dump(array_replace($base, $replacements));// [citrus => [pineapple], berries => [blueberry教程]]

array_splice (array & $input , int $offset [, int $length = count ($input) [, mixed $replacement =教程 array () ]] ) : array — 去掉数组中的某一部分并用其它值取代

$a = [a, b, c]; array_splice($a, 1, 2, [B, C]); 教程 var_dump($a); // [a, B, C] array_splice($a, -2, 2, [b, c]); var_dump($a);// [a教程, b, c] array_splice($a, 3, 0, [d, e]); var_dump($a); // [a, b, c, d, e]

数组指针操作curren教程t (array $array) : mixed — 返回数组中的当前单元$a = [1, 2, 3]; var_dump(current($a)); // 1end (array &教程$array) : mixed — 将数组的内部指针指向最后一个单元

$a = [1, 2, 3]; var_dump(end($a)); // 3key (array $array) 教程: mixed — 从关联数组中取得键名$arr = [color => red]; var_dump(key($arr)); // color

next (array &$array)教程 : mixed — 将数组中的内部指针向前移动一位$arr = [1, 2, 3]; var_dump(next($arr)); // 2pos — current 的别名

prev 教程(array &$array) : mixed — 将数组的内部指针倒回一位$arr = [1, 2, 3]; next($arr); // 2 var_dump(pr教程ev($arr)); // 1

reset (array &$array) : mixed — 将数组的内部指针指向第一个单元$arr = [1, 2, 3]; next($arr); 教程// 2 next($arr); // 3 var_dump(reset($arr)); // 1

其他array_column (array $input , mixe教程d $column_key [, mixed $index_key = NULL] ) : array — 返回数组中指定的一列$a = [[id => 1, first_name => John, 教程last_name => Doe], [id => 2, first_name => Wythe, last_name => Huang]]; print_r(array_column教程($a, first_name)); // [John, Wythe] print_r(array_column($a, first_name, id)); // [1=> John,教程 2 => Wythe]

array_flip (array $array) : array — 交换数组中的键和值$a = [a => 1, b => 2, c => 3]; var_教程dump(array_filp($a)); // [1 => a, 2 => b, 3 => c]

array_reverse (array $array [, bool $preserve_keys 教程= FALSE] ) : array — 返回单元顺序相反的数组$a = [php, 4.0, [green, red]]; var_dump(array_reverse($a)); 教程// [[green, red], 7.1, php] var_dump(array_reverse($a, true)); // [2 => [green, red], 1 => 7教程.1, 0 => php]

array_unique (array $array [, int $sort_flags = SORT_STRING] ) : array — 移除数组中重复的值$a = 教程[4, 1, 4, 1, 2]; var_dump(array_unique($a)); // [0 => 4, 1 => 1, 4 => 2] var_dump(ar教程ray_unique($a, SORT_NUMERIC));// [0 => 4, 1 => 1, 4 => 2]

count (mixed $array_or_countable [, int $mo教程de = COUNT_NORMAL] ) : int — 计算数组中的单元数目，或对象中的属性个数$a = [1, 2, 3]; echo count($a); // 3 教程 $b = [$a, 4, 5, 6]; echo count($b, COUNT_RECURSIVE) // 7

extract (array &$array [, int $fla教程gs = EXTR_OVERWRITE [, string $prefix = NULL]] ) : int — 从数组中将变量导入到当前的符号表

$size = 1; $varArra教程y = [color => blue, size => 2, shape => sphere]; var_dump(extract($varArray)); // 3 若存在, 则覆教程盖 echo "$color, $size, $shape\n"; // blue, 2, sphere extract($varArray, EXTR_SKIP);教程 // 若存在, 则不覆盖 echo "$color, $size, $shape\n"; // blue, 1, sphere extract($varArray,教程 EXTR_PREFIX_SAME, prefix); // 若存在, 则在变量名使用前缀 echo "$color, $size, $shape, $prefix_size\n"; 教程// blue, 1, sphere, 2 extract($varArray, EXTR_PREFIX_ALL, prefix); // 若存在, 则在变量名使用前缀 教程 echo "$prefix_color, $size, $prefix_shape, $prefix_size\n"; // blue, 1, sphere, 2 var_dum教程p(extract($varArray, EXTR_IF_EXISTS)); // 1 若存在, 则只覆盖已有变量 /** * Notice: Undefined va教程riable: color * Notice: Undefined variable: shape */ echo "$color, $size, $s教程hape\n"; // , 2, extract($varArray, EXTR_PREFIX_IF_EXISTS, prefix); // 仅当当前符号表中存在相同变量的非前缀版本教程时，才创建带前缀的变量名称。

/** * Notice: Undefined variable: color * Notice: Undefined variable: 教程shape */ echo "$color, $size, $shape, $prefix_size\n"; // , 1, , 2 var_dump教程(extract($varArray, EXTR_REFS)); // 3 变量作为引用。

这实际上意味着导入的变量的值仍在引用数组参数的值, 可以与其他参数结合 echo "$colo教程r, $size, $shape\n"; // blue, 2, sphere $color = red; var_dump($varArray); // [color教程 => red, size => 2, shape => sphere]; // 变量作为引用。

这实际上意味着导入的变量的值仍在引用数组参数的值, 可以与其他参数结合, 若解析变量前教程缀的, 则修改前缀变量, 数组变量则修改. $size = 1; $varArray = [color => blue, size => 2, shape => sph教程ere]; var_dump(extract($varArray, EXTR_REFS|EXTR_PREFIX_SAME, prefix)); // 3 echo "$教程color, $size, $shape, $prefix_size\n"; // blue, 1, sphere, 2 $color = red; $prefix_s教程ize = 4; var_dump($size); // 1 var_dump($varArray); // [color => red, size => 4, sha教程pe => sphere]; $a = [1, 2, 3]; extract($a, EXTR_PREFIX_INVALID, prefix); ec教程ho "$prefix_0, $prefix_1, $prefix_2\n"; // 1, 2, 3。

list (mixed $var1 [, mixed $...] ) : array — 把数组中教程的值赋给一组变量// 语言结构, 并非函数 $info = [coffee, brown, caffeine]; list($drink, $color, $power教程) = $info; echo "$drink, $color, $power"; // coffee, brown, caffeine // 可以省略不想取的 教程 list($drink, , $power) = $info; echo "$drink, $power"; // coffee, caffeine // 7教程.0 以上是从左到右赋值, 7.0以下是从右到左赋值 list($a[0], $a[1], $a[2]) = $info; // 7.0 以上 var_教程dump($a); // [coffee, brown, caffeine] // 7.0 以下 var_dump($a); // [caffeine, brown, 教程coffee] // 7.1 支持索引数组 $info = [a => coffee, b => brown, c => caffeine]; list教程(a => $drink, c => $power) = $info; echo "$drink, $power"; // coffee, caffeine

shuffle (array教程 &$array) : bool — 打乱数组$arr = [1, 2, 3, 4]; shuffle($arr); // 洗牌算法, 打乱数组sizeof 等同于 count

为了大家教程能够顺利进阶中高级、架构师，我特地为大家准备了一套精品PHP架构师教程，保证你学了以后保证薪资上升一个台阶。需要的请点击加群（→）点击此处

亲爱的读者们，感谢您花时间阅读本文。如果您对本文有任何疑问或建教程议，请随时联系我。我非常乐意与您交流。