search

博客列表 >数组排序-合并-成员统计-交差并补

数组排序-合并-成员统计-交差并补

葡萄枝子
葡萄枝子原创
2021年01月31日 21:28:50746浏览

数组排序-合并-成员统计-交差并补

作业内容：数组的排序, 数组的合并, 数组成员的统计, 数组的交差并补等，任意选一个专题，至少10个函数，写出演示案例并提交到博客中。。。 注意： 课堂中讲过的函数在本地练习， 不要提交到作业中了。。。。

1. 数组排序

  1. /* 数组排序 */
  2. $arr = ['b' => 'b', 'c' => 3, 'a' => 'a', 'e' => 5, 'd' => 4];
  3. echo '$arr = ', print_r($arr, true), '<br>';
  4. echo '<br>';

1.1 按键排序

  1. /**
  2.  * 按键排序
  3.  */
  4. echo '1. 按键排序<br>';
  5. // 按键升序
  6. $test = $arr;
  7. ksort($test);
  8. // ksort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  9. echo 'ksort: ', print_r($test, true), '<br>';
  11. // 按键降序
  12. $test = $arr;
  13. krsort($test);
  14. // krsort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  15. echo 'krsort: ', print_r($test, true), '<br>';
  16. echo '<hr>';

按键排序

1.2 按值排序

  1. /**
  2.  * 按值排序
  3.  */
  4. echo '2. 按值排序<br>';
  5. echo '按值升 | 降序，重排索引<br>';
  6. // 按值升序，重排索引
  7. $test = $arr;
  8. sort($test);
  9. // sort: Array ( [0] => a [1] => b [2] => 3 [3] => 4 [4] => 5 )
  10. echo 'sort: ', print_r($test, true), '<br>';
  12. // 按值降序，重排索引
  13. $test = $arr;
  14. rsort($test);
  15. // rsort: Array ( [0] => 5 [1] => 4 [2] => 3 [3] => b [4] => a )
  16. echo 'rsort: ', print_r($test, true), '<br>';
  17. echo '<br>';
  19. echo '按值升 | 降序，键名不变<br>';
  20. $test = $arr;
  21. // 按值升序，键名不变
  22. asort($test);
  23. // asort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  24. echo 'asort: ', print_r($test, true), '<br>';
  26. $test = $arr;
  27. // 按值降序，键名不变
  28. arsort($test);
  29. // arsort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  30. echo 'arsort: ', print_r($test, true), '<br>';
  31. echo '<hr>';

按值排序

1.3 回调排序

  1. /**
  2.  * 回调排序
  3.  */
  4. echo '3. 回调排序<br>';
  5. echo '回调函数按键名升 | 降序<br>';
  6. $test = $arr;
  7. // 回调函数按键名升序
  8. uksort($test, function($a, $b){
  9.     return $a <=> $b;
  10. });
  11. // uksort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  12. echo 'uksort: ', print_r($test, true), '<br>';
  14. $test = $arr;
  15. // 回调函数按键名降序
  16. uksort($test, function($a, $b){
  17.     return $b <=> $a;
  18. });
  19. // uksort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  20. echo 'uksort: ', print_r($test, true), '<br>';
  21. echo '<br>';
  23. echo '回调函数按值升 | 降序，重排索引<br>';
  24. $test = $arr;
  25. // 回调函数按值升序，重排索引
  26. usort($test, function($a, $b){
  27.     return $a <=> $b;
  28. });
  29. // usort: Array ( [0] => a [1] => b [2] => 3 [3] => 4 [4] => 5 )
  30. echo 'usort: ', print_r($test, true), '<br>';
  32. // 回调函数按值降序，重排索引
  33. usort($test, function($a, $b){
  34.     return $b <=> $a;
  35. });
  36. // usort: Array ( [0] => 5 [1] => 4 [2] => 3 [3] => b [4] => a )
  37. echo 'usort: ', print_r($test, true), '<br>';
  38. echo '<br>';
  40. echo '回调函数按值升 | 降序，键名不变<br>';
  41. $test = $arr;
  42. // 回调函数按值升序，键名不变
  43. uasort($test, function($a, $b){
  44.     return $a <=> $b;
  45. });
  46. // uasort: Array ( [a] => a [b] => b [c] => 3 [d] => 4 [e] => 5 )
  47. echo 'uasort: ', print_r($test, true), '<br>';
  49. // 回调函数按值升序，键名不变
  50. uasort($test, function($a, $b){
  51.     return $b <=> $a;
  52. });
  53. // uasort: Array ( [e] => 5 [d] => 4 [c] => 3 [b] => b [a] => a )
  54. echo 'uasort: ', print_r($test, true), '<br>';
  55. echo '<hr>';

回调排序

1.4 自然排序

  1. /**
  2.  * 自然排序
  3.  */
  4. echo '4. 自然排序<br>';
  5. $test = $arr;
  6. // 自然排序，数字在前，字母在后
  7. natsort($test);
  8. // natsort: Array ( [c] => 3 [d] => 4 [e] => 5 [a] => a [b] => b )
  9. echo 'natsort: ', print_r($test, true), '<br>';
  11. $test = $arr;
  12. // 自然排序，数字在前，字母在后
  13. natcasesort($test);
  14. // natcasesort: Array ( [c] => 3 [d] => 4 [e] => 5 [a] => a [b] => b )
  15. echo 'natcasesort: ', print_r($test, true), '<br>';
  16. echo '<hr>';

自然排序

1.5 多组排序

  1. /**
  2.  * 多组排序
  3.  */
  4. echo '5. 多组排序<br>';
  5. $test = [
  6.     ['id' => 2, 'name' => 'b-title'],
  7.     ['id' => 1, 'name' => '1-title'],
  8.     ['id' => 3, 'name' => 'c-title'],
  9. ];
  10. echo '排序前二维数组: <pre>', print_r($test, true), '</pre><br>';
  12. // 按 id 升序
  13. array_multisort($test, array_column($test, 'id'));
  14. echo 'array_multisort: id 升序(默认) <pre>', print_r($test, true), '</pre><br>';
  16. // 按 id 降序
  17. array_multisort($test, SORT_DESC, array_column($test, 'id'));
  18. echo 'array_multisort: id 降序<pre>', print_r($test, true), '</pre><br>';
  20. // 按 name 自然排序(数字在前,字母接后)
  21. array_multisort($test, SORT_NATURAL, array_column($test, 'name'));
  22. echo 'array_multisort: name 自然排序<pre>', print_r($test, true), '</pre><br>';

多组排序

多组升降序

多组自然排序

1.6 反转排序

  1. /**
  2.  * 反转排序
  3.  */
  4. echo '6. 反转排序<br>';
  5. // 数组反转排序
  6. $test = array_reverse($arr);
  7. // array_reverse: Array ( [d] => 4 [e] => 5 [a] => a [c] => 3 [b] => b )
  8. echo 'array_reverse: ', print_r($test, true), '<br>';
  10. // 数组反转保留数字键名
  11. $test = array_reverse($arr, true);
  12. // array_reverse: Array ( [d] => 4 [e] => 5 [a] => a [c] => 3 [b] => b )
  13. echo 'array_reverse: ', print_r($test, true), '<br>';
  14. echo '<hr>';

反转排序

1.7 随机排序

  1. /**
  2.  * 随机排序
  3.  */
  4. echo '7. 随机排序<br>';
  5. $test = $arr;
  6. // 乱序排列，重排索引
  7. shuffle($test);
  8. // Array ( [0] => b [1] => 4 [2] => 5 [3] => a [4] => 3 )
  9. echo 'shuffle: ', print_r($test, true), '<br>';
  10. echo '<hr>';

随机排序

2. 数组合并

2.1 键值对合并

  1. /* 数组合并 */
  2. $arr1 = ['a' => 1, 'b' => 2, 3 => 'c'];
  3. $arr2 = [1 => 'a', 'b' => 'b', 3 => 3];
  5. echo '数组合并<br>';
  6. echo '1. 键值对合并<br>';
  7. // arr1 的值作键名,arr2 的值作值组成数组
  8. $test = array_combine($arr1, $arr2);
  9. // array_combine: Array ( [1] => a [2] => b [c] => 3 )
  10. echo 'array_combine: <pre>', print_r($test, true), '</pre><br>';

键值对合并

2.2 数组合并

  1. echo '2. 数组合并<br>';
  2. // 数组合并
  3. $test = array_merge($arr1, $arr2);
  4. // 数字索引重排,相同字符串键名,后值覆盖前值
  5. // array_merge: Array ( [a] => 1 [b] => b [0] => c [1] => a [2] => 3 )
  6. echo 'array_merge: <pre>', print_r($test, true), '</pre><br>';

数组合并

2.3 递归合并

  1. echo '3. 递归合并<br>';
  2. // 数组递归合并,相同字符串键名,值合并
  3. $test = array_merge_recursive($arr1, $arr2);
  4. // array_merge_recursive: Array ( [a] => 1 [b] => Array ( [0] => 2 [1] => b ) [0] => c [1] => a [2] => 3 )
  5. echo 'array_merge_recursive: <pre>', print_r($test, true), '</pre><br>';

递归合并

2.4 自定义函数合并

  1. echo '4. 自定义函数合并<br>';
  2. // 多维数组合并保留键名不变,相同键名或索引,后值覆盖前值
  3. function array_merge_multi(...$args) {
  4.     $array = [];
  5.     foreach ( $args as $arg ) {
  6.         if ( is_array($arg) ) {
  7.             foreach ( $arg as $k => $v ) {
  8.                 if ( is_array($v) ) {
  9.                     $array[$k] = isset( $array[$k] ) ? $array[$k] : [];
  10.                     $array[$k] = array_merge_multi( $array[$k], $v );
  11.                 } else {
  12.                     $array[$k] = $v;
  13.                 }
  14.             }
  15.         }
  16.     }
  17.     return $array;
  18. }
  19. $test = array_merge_multi($arr1, $arr2);
  20. // array_merge_multi: Array ( [a] => 1 [b] => b [3] => 3 [1] => a )
  21. echo 'array_merge_multi: <pre>', print_r($test, true), '</pre><br>';
  22. echo '<hr>';

自定义函数合并

3. 数组成员统计

3.1 统计成员数目

  1. /* 数组成员的统计 */
  2. $test = $arr1 + $arr2;
  3. echo '$test = ', print_r($test, true), '<br>';
  4. echo '1. 统计成员数目<br>';
  5. // 统计数组中项目个数
  6. // count($test) : 4
  7. echo 'count($test) : ', count($test), '<br>';

3.2 统计值出现的次数数组

  1. echo '2. 统计值出现的次数数组<br>';
  2. // 数组由值组成键名,值出现的次数为值
  3. // array_count_values($test) : Array ( [1] => 1 [2] => 1 [c] => 1 [a] => 1 )
  4. echo 'array_count_values($test) : <pre>', print_r(array_count_values($test), true), '</pre><br>';
  5. echo '<hr>';

数组成员统计

4. 数组的交差并补

4.1 数组交集

  1. /* 数组的交差并补 */
  2. $arr1 = ['a' => 'b', 'b' => 'a', 1 => 'a', 2 => 'b'];
  3. $arr2 = [1 => 'a', 'a' => 'b', 'b' => 1];
  5. echo '数组的交差并补<br>';
  6. echo "\$$arr1 = ['a' => 'b', 'b' => 'a', 1 => 'a', 2 => 'b'];<br>";
  7. echo "\$$arr2 = [1 => 'a', 'a' => 'b', 'b' => 1];<br>";
  8. echo '<br>';
  10. echo '数组交集<br>';
  11. echo '1. 数组交集值相等型<br>';
  12. // 数组交集，只需值相等（主从数组键名不同时，保留主数组的键名）
  13. // array_intersect : Array ( [a] => b [b] => a [1] => a [2] => b )
  14. echo 'array_intersect : ', print_r(array_intersect($arr1, $arr2), true), '<br>';
  16. echo '2. 数组交集键值严格相等型<br>';
  17. // 数组交集，键值严格相等
  18. // array_intersect_assoc : Array ( [a] => b [1] => a )
  19. echo 'array_intersect_assoc : ', print_r(array_intersect_assoc($arr1, $arr2), true), '<br>';
  21. echo '3. 数组交集键相等型<br>';
  22. // 数组交集，键相等（主从数组值不同时，保留主数组的值）
  23. // array_intersect_key : Array ( [a] => b [b] => a [1] => a )
  24. echo 'array_intersect_key : ', print_r(array_intersect_key($arr1, $arr2), true), '<br>';
  25. echo '<br>';

数组交集

4.2 数组差集

  1. echo '数组差集<br>';
  2. echo '1. 数组差集值相等型<br>';
  3. // 数组差集，只需值相等（主从数组键名diff不同时，保留主数组的键名）
  4. // array_diff : Array ( )
  5. echo 'array_diff : ', print_r(array_diff($arr1, $arr2), true), '<br>';
  7. echo '2. 数组差集键值严格相等型<br>';
  8. // 数组差集，键值严格相等
  9. // array_diff_assoc : Array ( [b] => a [2] => b )
  10. echo 'array_diff_assoc : ', print_r(array_diff_assoc($arr1, $arr2), true), '<br>';
  12. echo '3. 数组差集键相等型<br>';
  13. // 数组差集，键相等（主从数组值不同时，保留主数组的值）
  14. // array_diff_key : Array ( [2] => b )
  15. echo 'array_diff_key : ', print_r(array_diff_key($arr1, $arr2), true), '<br>';
  16. echo '<br>';

数组差集

4.3 数组并集

  1. echo '数组并集<br>';
  2. echo '1. 数组并集前值覆盖后值型<br>';
  3. // $arr1 + $arr2 : Array ( [a] => b [b] => a [1] => a [2] => b )
  4. echo '$arr1 + $arr2 : ', print_r($arr1 + $arr2, true), '<br>';
  5. echo '<br>';
  7. echo '2. 数组并集后值覆盖前值型<br>';
  8. // 数字索引重排,相同字符串键名,后值覆盖前值
  9. // array_merge : Array ( [a] => b [b] => 1 [0] => a [1] => b [2] => a )
  10. echo 'array_merge : ', print_r(array_merge($arr1, $arr2), true), '<br>';
  11. echo '<br>';
  13. echo '3. 数组并集递归合并<br>';
  14. // 数组递归合并,相同字符串键名,值合并
  15. /* array_merge_recursive : 
  16.     Array ( 
  17.         [a] => Array ( [0] => b [1] => b ) 
  18.         [b] => Array ( [0] => a [1] => 1 ) 
  19.         [0] => a 
  20.         [1] => b 
  21.         [2] => a 
  22.     )
  23. */
  24. echo 'array_merge_recursive : <pre>', print_r(array_merge_recursive($arr1, $arr2), true), '</pre><br>';
  25. echo '<br>';

数组并集

4.4 数组补集
…

上一条：运算符与分支和循环结构的替代语句,以及文件包含的本质的描述下一条：函数的定义和调用，函数的参数，函数的返回值，匿名函数（闭包）的申明和调用
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多