1. array()-创建数组

用于创建数组的函数的函数，是一个语言结构，非常规的函数

2. array_change_key_case()-将数组的键名称修改为全大写，或者是全小写

array array_change_key_case ( array $array [, int $case = CASE_LOWER ] ) CASE_UPPER , CASE_LOWER

3. array_chunk()-将一个数组分割成多个，那么最终返回的就至少是二维数组了。

array array_chunk ( array $array , int $size [, bool $preserve_keys = false ] ) 第二个参数是：分割后每个数组的单元数目 第三个参数是：是否保留原有的索引，默认是false，按照 0 1 2 排序

  1. <?php
  2. input_array = array('a', 'b', 'c', 'd', 'e');
  3. print_r(array_chunk($input_array, 2));
  4. print_r(array_chunk($input_array, 2, true));
  6. /*
  7. Array
  8. (
  9.     [0] => Array
  10.         (
  11.             [0] => a
  12.             [1] => b
  13.         )
  15.     [1] => Array
  16.         (
  17.             [0] => c
  18.             [1] => d
  19.         )
  21.     [2] => Array
  22.         (
  23.             [0] => e
  24.         )
  26. )
  27. Array
  28. (
  29.     [0] => Array
  30.         (
  31.             [0] => a
  32.             [1] => b
  33.         )
  35.     [1] => Array
  36.         (
  37.             [2] => c
  38.             [3] => d
  39.         )
  41.     [2] => Array
  42.         (
  43.             [4] => e
  44.         )
  46. )
  47. */

4.array_column-数组中指定的一列

从多维数组中返回单列数组 array array_column ( array $input , mixed $column_key [, mixed $index_key = null ] ) 第二个参数：需要返回的列,值 第三个参数：作为返回数组的索引/键的列

  1. <?php
  2. $records = array(
  3.     array(
  4.         'id' => 2135,
  5.         'first_name' => 'John',
  6.         'last_name' => 'Doe',
  7.     ),
  8.     array(
  9.         'id' => 3245,
  10.         'first_name' => 'Sally',
  11.         'last_name' => 'Smith',
  12.     ),
  13.     array(
  14.         'id' => 5342,
  15.         'first_name' => 'Jane',
  16.         'last_name' => 'Jones',
  17.     ),
  18.     array(
  19.         'id' => 5623,
  20.         'first_name' => 'Peter',
  21.         'last_name' => 'Doe',
  22.     )
  23. );
  25. // [1] 取出所有人的 first_name
  26. $first_names = array_column($records, 'first_name');
  27. print_r($first_names);
  29. /*
  30. Array
  31. (
  32.     [0] => John
  33.     [1] => Sally
  34.     [2] => Jane
  35.     [3] => Peter
  36. )
  37. */
  39. // [2] 以id作为索引，last_name作为值
  40. $last_names = array_column($records, 'last_name', 'id');
  41. print_r($last_names);
  43. /*
  44. Array
  45. (
  46.     [2135] => Doe
  47.     [3245] => Smith
  48.     [5342] => Jones
  49.     [5623] => Doe
  50. )
  51. */
  52. ?>

5. array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值

array array_combine ( array $keys , array $values ) 第一个参数：一个数组，作为键 第二个参数：一个数组，作为值 返回值：组成的新的数组

  1. <?php
  2. $a = array('green', 'red', 'yellow');
  3. $b = array('avocado', 'apple', 'banana');
  4. $c = array_combine($a, $b);
  6. print_r($c);
  8. /*
  9. Array
  10. (
  11.     [green]  => avocado
  12.     [red]    => apple
  13.     [yellow] => banana
  14. )
  15. */

6. array_count_values — 统计数组中所有的值出现的次数

array array_count_values ( array $array )

  1. <?php
  2. $array = array(1, "hello", 1, "world", "hello");
  3. print_r(array_count_values($array));
  5. /*
  6. Array
  7. (
  8.     [1] => 2
  9.     [hello] => 2
  10.     [world] => 1
  11. )
  12. */

7. array_diff — 计算数组的差集

array array_diff ( array $array1 , array $array2 [, array $... ] ) 计算前者对后者的差集 后续参数就是更多相比较的数组

  1. <?php
  2. $arr1 = [1, 2, 3, 4];
  3. $arr2 = [1, 4, 5, 7];
  4. $arr3 = [2, 7];
  6. $result = array_diff($arr1, $arr2);
  7. print_r($result);
  9. /*
  10. Array
  11. (
  12.     [1] => 2
  13.     [2] => 3
  14. )
  15. */
  17. $result2 = array_diff($arr1, $arr2, $arr3);
  18. print_r($result2);
  19. /*
  20. Array
  21. (
  22.     [2] => 3
  23. )
  24. */

更多相关函数： array_diff_assoc — 带索引检查计算数组的差集，索引也会被列入检查范围 array_diff_key — 使用键名比较计算数组的差集，根据键名来比较

8. array_fill — 用给定的值填充数组

array array_fill ( int $start_index , int $num , mixed $value ) 第一个参数：第一个填充元素的数组下标 第二个参数：填充的数量 第三个参数：填充的值

  1. <?php
  2. $a = array_fill(5, 6, 'banana');
  3. $b = array_fill(-2, 4, 'pear');
  4. print_r($a);
  5. print_r($b);
  7. /*
  8. Array
  9. (
  10.     [5]  => banana
  11.     [6]  => banana
  12.     [7]  => banana
  13.     [8]  => banana
  14.     [9]  => banana
  15.     [10] => banana
  16. )
  17. Array
  18. (
  19.     [-2] => pear
  20.     [0] => pear
  21.     [1] => pear
  22.     [2] => pear
  23. )
  24. */

相关函数 array_fill_keys — 使用指定的键和值填充数组。 预计用到的也会较多

  1. <?php
  2. $keys = array('foo', 5, 10, 'bar');
  3. $a = array_fill_keys($keys, 'banana');
  4. print_r($a);
  6. /*
  7. Array
  8. (
  9.     [foo] => banana
  10.     [5] => banana
  11.     [10] => banana
  12.     [bar] => banana
  13. )
  14. */

9. array_filter — 用回调函数过滤数组中的单元

array array_filter ( array $array [, callable $callback [, int $flag = 0 ]] )

  1. <?php
  2. // 奇数
  3. function odd($var)
  4. {
  5.     return($var & 1);
  6. }
  8. // 偶数 
  9. function even($var)
  10. {
  11.     return(!($var & 1));
  12. }
  14. $array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
  15. $array2 = array(6, 7, 8, 9, 10, 11, 12);
  17. echo "Odd :\n";
  18. print_r(array_filter($array1, "odd"));
  19. echo "Even:\n";
  20. print_r(array_filter($array2, "even"));

10. array_flip — 交换数组中的键和值

array array_flip ( array $array )

11. array_intersect — 计算数组的交集

参考 8

12. array_keys — 返回数中某个元素的或所有的键名

这个函数可以从一维数组中获取某个值为xxx的元素的位置，亦可以是获取全部元素的键 可以用于查找某个元素在一维数组中出现的位置，但对于多维数组，不好用。

  1. <?php
  2. $array = array(0 => 100, "color" => "red");
  3. print_r(array_keys($array));
  5. $array = array("blue", "red", "green", "blue", "blue");
  6. print_r(array_keys($array, "blue"));
  8. $array = array("color" => array("blue", "red", "green"),
  9.                "size"  => array("small", "medium", "large")
  10.               );
  11. print_r(array_keys($array));
  13. /*
  15. Array
  16. (
  17.     [0] => 0
  18.     [1] => color
  19. )
  20. Array
  21. (
  22.     [0] => 0
  23.     [1] => 3
  24.     [2] => 4
  25. )
  26. Array
  27. (
  28.     [0] => color
  29.     [1] => size
  30. )
  32. */

13. array_map — 为数组的每个元素应用回调函数

array array_map ( callable $callback , array $array1 [, array $... ] ) callback：回调函数，应用到每个数组里的每个元素。 array1：数组，遍历运行 callback 函数。 数组列表：每个都遍历运行 callback 函数。

  1. <?php
  3. // [1] 第一种写法,php中貌似所有的回调函数参数都支持我这么写
  4. $a = array(1, 2, 3, 4, 5);
  5. $b = array_map(function($n) {
  6.     return ($n * $n * $n);
  7. }, $a);
  9. print_r($b);
  11. /*
  12. Array
  13. (
  14.     [0] => 1
  15.     [1] => 8
  16.     [2] => 27
  17.     [3] => 64
  18.     [4] => 125
  19. ) 
  20. */
  22. // [2] 第二种
  23. function cube($n)
  24. {
  25.     return ($n * $n * $n);
  26. }
  27. $arr1 = [1, 2, 3, 4, 5];
  28. $arr2 = array_map('cube', $arr1);
  30. print_r($arr2);

14. array_merge — 合并一个或多个数组

array array_merge ( array $array1 [, array $... ] ) 返回合并后的数组

  1. <?php
  2. // [1] 常规方式
  3. $arr1 = [1, 2, 3];
  4. $arr2 = [4, 5, 6];
  5. $res1 = array_merge($arr1, $arr2);
  6. print_r($res1);
  7. /*
  8. Array
  9. (
  10.     [0] => 1
  11.     [1] => 2
  12.     [2] => 3
  13.     [3] => 4
  14.     [4] => 5
  15.     [5] => 6
  16. ) 
  17. */

当合并的是关联数组时,前面一个索引的值会被后面的值覆盖

  1. <?php
  2. $arr1 = ['a' => 1, 'b' => 2, 'c' => 3];
  3. $arr2 = ['a' => 4, 'e' => 5, 'c' => 6];
  4. $res1 = array_merge($arr1, $arr2);
  5. print_r($res1);
  7. /*
  8. Array
  9. (
  10.     [a] => 4
  11.     [b] => 2
  12.     [c] => 6
  13.     [e] => 5
  14. )
  15. */

如果想要完全的保留第一个数组中的元素，附带添加第二个数组中的元素。可是使用 + 后面的元素只要出现有相同的键名称都会被统统忽略。

  1. <?php
  2. $arr1 = ['a' => 1, 'b' => 2, 'c' => 3];
  3. $arr2 = ['a' => 4, 'e' => 5, 'c' => 6];
  4. $res1 = $arr1 + $arr2;
  5. print_r($res1);
  7. /*
  8. Array
  9. (
  10.     [a] => 1
  11.     [b] => 2
  12.     [c] => 3
  13.     [e] => 5
  14. )
  15. */

对于合成变量和数组 我们可以先将变量强制转换成数组

  1. <?php
  2. $name = 'xs';
  3. $arr = [1, 2, 3];
  5. print_r(array_merge((array) $name, $arr));
  7. /*
  8. Array
  9. (
  10.     [0] => xs
  11.     [1] => 1
  12.     [2] => 2
  13.     [3] => 3
  14. )
  15. */

相关函数 array_merge_recursive — 递归地合并一个或多个数组

15. array_multisort — 对多个数组或多维数组进行排序

16. array_pad — 以指定长度将一个值填充进数组

可以参考一下 第8个函数 array_fill，这二者的区别如下所示：

array_fill : 用给定的值填充成数组，是变量值像数组转换

  • 第一个参数：开始填充的位置
  • 第二个参数：填充的数量
  • 第三个参数：填充的值

array_pad：向数组中填充变量值

  • 第一个参数：原油的数组
  • 第二个参数：新数组的长度
    • size > 0 , 右侧填充
    • size < 0 , 左侧填充
    • 如果 |size| < count(原数组) ，不会发生填充
  • 第三个参数：被填充的值
  • 返回值：填充后的数组
  1. <?php
  2. $input = array(12, 10, 9);
  4. $result = array_pad($input, 5, 0);
  5. // result is array(12, 10, 9, 0, 0)
  7. $result = array_pad($input, -7, -1);
  8. // result is array(-1, -1, -1, -1, 12, 10, 9)
  10. $result = array_pad($input, 2, "noop");
  11. // not padded

17. array_pop — 弹出数组最后一个单元（出栈）

返回数组的最后一个元素，并将数组的长度 -1 。 如果 array 是空（如果不是一个数组），将会返回 NULL

18. array_product — 计算数组中所有值的乘积

这就要求我们的数组，最好是一个数值组成的数组。

  • 如果数组是空数组，返回1，PHP 5.3.6以前返回的是0
  • 如果是一个混合的数组呢，返回0
  • 如果是多维数组呢，抱歉根本就不好用。
  1. <?php
  2. // [1] 混合数组返回了 0
  3. $arr = [1, 2, 3, 'a'];
  4. print_r(array_product($arr). '<br>') ; // 0
  6. // [2] 空数组
  7. $arr2 = [];
  8. print_r(array_product($arr2). '<br>'); // 1
  10. // [3] 正常纯数字数组, 返回正常的值
  11. $arr3 = [1, 2, 3];
  12. print_r(array_product($arr3). '<br>'); // 6
  14. // [4] 多维数组呢？
  15. $arr4 = [
  16.     'first' => [1, 2, 3],
  17.     'second' => [4, 5, 6],
  18. ];
  19. print_r(array_product($arr4). '<br>'); // 1
  21. // [5]
  22. $arr4 = [
  23.     1 => [1, 2, 3],
  24.     2 => [4, 5, 6],
  25. ];
  26. print_r(array_product($arr4). '<br>'); // 1

19. array_push — 将一个或多个单元压入数组的末尾（入栈）

和array_pop() 相反，但是这个函数不仅可以让单个变量值入栈，也可以让数组入栈。 功能比较强，而且用的地方也比较多 需要注意的是：它的返回值是处理后元素的个数，而不是处理后的数组！！！

  1. <?php
  2. // [1] 常规操作
  3. $arr1 = [1, 2, 3];
  4. $name = 'xs';
  5. array_push($arr1, $name);
  6. print_r($arr1);
  7. // 1, 2, 3,'xs'
  9. // [2] 入栈多个值
  10. $arr1 = [1, 2, 3];
  11. array_push($arr1, 'xs', '19960118', '男');
  12. print_r($arr1);
  13. /*
  14. Array
  15. (
  16.     [0] => 1
  17.     [1] => 2
  18.     [2] => 3
  19.     [3] => xs
  20.     [4] => 19960118
  21.     [5] => 男
  22. )
  23. // [3] 入栈一个数组
  24. $infoArr = ['name' => '向上', 'sex' => '男',];
  25. $other =['salary' => '8000', 'girfirend' => 'lxm'];
  26. array_push($infoArr, $other);
  27. print_r($infoArr);
  29. /*
  30. Array
  31. (
  32.     [name] => 向上
  33.     [sex] => 男
  34.     [0] => Array
  35.         (
  36.             [salary] => 8000
  37.             [girfirend] => lxm
  38.         )
  40. )
  41. */
  42. */

20. array_replace — 使用传递的数组替换第一个数组的元素

array array_replace ( array $array1 , array $array2 [, array $... ] )

  • 作用除了修改还可以插入
  • 参数：
    • 第一个参数为原数组
    • 后面的参数为替换数组
  • 返回值：
    • 替换好返回替换后的数组
    • 发生错误，返回NULL
  1. <?php
  2. $base = array("orange", "banana", "apple", "raspberry");
  3. $replacements = array(0 => "pineapple", 4 => "cherry");
  4. $basket = array_replace($base, $replacements);
  5. print_r($basket);
  7. /*
  8. Array
  9. (
  10.     [0] => pineapple
  11.     [1] => banana
  12.     [2] => apple
  13.     [3] => raspberry
  14.     [4] => cherry
  15. )
  16. /*

21. array_reverse — 返回单元顺序相反的数组

array array_reverse ( array $array [, bool $preserve_keys = false ] )

  • 参数：
    • 第一个参数原数组
    • 第二个参数是一个bool值
    • 设置为 TRUE 会保留数字的键。 非数字的键则不受这个设置的影响，总是会被保留。
  • 返回值：返回反转后的数组。
  1. <?php
  2. // [1] 只使用第一个参数，数字索引
  3. $arr = [1, 2, 3, 4];
  4. print_r(array_reverse($arr));
  6. /*
  7. Array
  8. (
  9.     [0] => 4
  10.     [1] => 3
  11.     [2] => 2
  12.     [3] => 1
  13. )
  14. */
  16. // [2] 第二个参数设置为 TRUE 会保留数字的键
  17. print_r(array_reverse($arr, true));
  18. /*
  19. Array
  20. (
  21.     [3] => 4
  22.     [2] => 3
  23.     [1] => 2
  24.     [0] => 1
  25. )
  26. */

22. array_search — 在数组中搜索给定的值，如果成功则返回首个相应的键名

mixed array_search ( mixed $needle , array $haystack [, bool $strict = false ] )

  • 参数：
    • 第一个参数：要找的值
    • 第二个参数：原数组
    • 第三个参数：，可选参数，布尔值默认 false
      • 如果设置为 true ，会严格比较
  • 返回值：
    • 找到了返回该元素的键，如果出现了不止一次，则返回第一个出现的键。要返回所有匹配值的键，应该用 array_keys() 加上可选参数 search_value 来代替。
    • 没找到返回false
  1. <?php
  2. // [1] 简单使用
  3. $arr = [1, 2, 3];
  4. if (array_search('1', $arr)) {
  5.     echo 'Found <br>';
  6. }else {
  7.     echo 'Not found! <br>';
  8. }
  9. // Not found! 
  11. // [2] 如果设置第二个参数，还必须为同一个对象的实例子
  12. $arr = [1, 2, 3];
  13. if (array_search(1, $arr, true)) {
  14.     echo 'Found <br>';
  15. } else {
  16.     echo 'Not found! <br>';
  17. }
  18. // Not found!

23. array_shift — 将数组开头的单元移出数组

24. array_slice — 从数组中取出一段

array array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] )

  • 参数：
    • 1️⃣：原数组
    • 2️⃣：截取的偏移量

      • 0 左侧开始

      • < 0 右侧开始
    • 3️⃣：可选参数 截取的长度
    • 4️⃣：可选参数 重置数字索引，默认会重置。默认值是false。
  • 返回值：返回其中一段。 如果 offset 参数大于 array 尺寸，就会返回空的 array。
  1. <?php
  2. // [1] 简单的用法
  3. $input = array("a", "b", "c", "d", "e");
  4. print_r(array_slice($input, 2));
  6. /*
  7. Array
  8. (
  9.     [0] => c
  10.     [1] => d
  11.     [2] => e
  12. )
  13. */
  14. // [2] 设置最后一个参数为 true 则保留原数组中的索引
  15. $input = array("a", "b", "c", "d", "e");
  16. print_r(array_slice($input, 2, 3, true));
  18. /*
  19. Array
  20. (
  21.     [2] => c
  22.     [3] => d
  23.     [4] => e
  24. )
  25. */

25. array_splice — 去掉数组中的某一部分并用其它值取代

array array_splice ( array &$input , int $offset [, int $length = count($input) [, mixed $replacement = array() ]] )

  • 参数：
    • 1️⃣：原数组
    • 2️⃣：偏移量
    • 3️⃣：可选参数，长度
    • 4️⃣：可选参数， 如果给出了 replacement 数组，则被移除的单元被此数组中的单元替代。
  • 返回值：返回一个包含有被移除单元的数组。
  1. <?php
  2. // [1] 只保留前两个元素
  3. $input = array("red", "green", "blue", "yellow");
  4. array_splice($input, 2);
  5. // $input is now array("red", "green")
  7. ... ...

26. array_sum — 对数组中所有值求和

27. array_unique — 移除数组中重复的值

array array_unique ( array $array [, int $sort_flags = SORT_STRING ] )

  • 参数：
    • 1️⃣：原数组
    • 2️⃣：可选参数，用于排列
      • SORT_REGULAR - 按照通常方法比较（不修改类型）
      • SORT_NUMERIC - 按照数字形式比较
      • SORT_STRING - 按照字符串形式比较
      • SORT_LOCALE_STRING - 根据当前的本地化设置，按照字符串比较。
  • 返回值：返回过滤后的数组。
  • 注意：array_unique() 不能应用于多维数组。
  1. <?php
  2. // [1] 错误的用法
  3. $arr = array(
  4.     'name' => 'xs',
  5.     'pad' => 'xs',
  6.     'other' => 'xs',
  7.     'age' => 24,
  8.     'sex' => '男'
  9. );
  10. array_unique($arr);
  11. print_r($arr);
  13. /*
  14. Array
  15. (
  16.     [name] => xs
  17.     [pad] => xs
  18.     [other] => xs
  19.     [age] => 24
  20.     [sex] => 男
  21. )
  22. */
  24. // [1] 正确的用法
  25. $arr2 = array(
  26.     'name' => 'xs',
  27.     'pad' => 'xs',
  28.     'other' => 'xs',
  29.     'age' => 24,
  30.     'sex' => '男'
  31. );
  32. print_r(array_unique($arr2));
  33. /*
  34. Array
  35. (
  36.     [name] => xs
  37.     [age] => 24
  38.     [sex] => 男
  39. )
  40. */

28. array_unshift — 在数组开头插入一个或多个单元

29. array_values — 返回数组中所有的值

30. 数组指针偏移

1. next()

将数组中的内部指针向前移动一位 mixed next ( array &$array ) 返回数组内部指针指向的下一个单元的值，或当没有更多单元时返回 FALSE。 next()指针在返回前移动，所以它返回的是下一个元素的值

2. current — 返回数组中的当前单元

3. reset — 将数组的内部指针指向第一个单元

4. each — 返回数组中当前的键／值对并将数组指针向前移动一步

5. prev — 将数组的内部指针倒回一位

6. end — 将数组的内部指针指向最后一个单元