Community Learn Tools Library Leisure
search
English
Home > List of blog posts > 细说数组及其函数
Blogger Information
Blog 26
fans 0
comment 0
visits 21823
Special Recommendation
More>
Related recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
细说数组及其函数
溪边小树
Original
677 people have browsed it

数组及其函数

  1. <?php
  2. // 数组的概述与分类
  3. // 1. 索引数组
  4. // 索引键名是数值
  5. $students = [0=>'1111', 1=>'zhangsan', 2=>'网络编程', 3=>4400];
  6. printf('<pre>%s</pre>', print_r($students, true));
  7. // 如果索引数组的键名满足从0开递增的正整数,可以省略
  8. $students = ['1111', 'zhangsan', '网络编程', 9999];
  9. // printf('<pre>%s</pre>', print_r($students, true));
  10. // 键名可以不连续, 可以是负数, 还可以是小数
  11. $students = ['1111', 5=>'zhangsan', 6=>'网络编程',7=>4400];
  12. // printf('<pre>%s</pre>', print_r($students, true));
  14. // 2. 关联数组
  15. // 键名用非数字的字符串来表示
  16. $students = ['id'=>'1111', 'name'=>'zhangsan', 'model'=>'网络编程', 'price'=>4400];
  17. printf('<pre>%s</pre>', print_r($students, true));
  19. // 如果采用数字字符串,那么索引数组其实也是关联数组
  20. $students = ['0'=>'1111','1'=>'zhangsan', '2'=>'网络编程', '3'=>4400];
  21. printf('<pre>%s</pre>', print_r($students, true));
  22. echo $students[1], $students['1'];
  24. // 所以, 可以认为索引数组是关联数组的子集, 一个分支
  26. $students = ['3'=>'1111','name'=>'zhangsan', 10=>'网络编程', 'price'=>4400];
  27. printf('<pre>%s</pre>', print_r($students, true));
  31. // 数组的定义与访问
  32. // 索引数组，array()
  33. $students1 = array('1111','zhangsan',[90,80]);
  34. printf('<pre>%s</pre>',print_r($students1,true));
  35. echo '<hr>';
  36. // 使用方括号,逐个创建数组成员/元素
  37. // 使用数组成员的更新/赋值的语法来创建
  38. // 关联数组
  39. $students2 = ['id'=>'1111','name'=>'zhangsan','scores'=>['php'=>90,'js'=>80]];
  40. printf('<pre>%s</pre>',print_r($students2,true));
  41. echo '<hr>';
  43. // 数组成员的访问方式
  44. // 索引数组成员 
  45. // echo "students1[1] 的姓名: students1[2]<br>";
  46. // 关联数组成员 
  47. // echo "{students2['name']} 的成绩: {students2['scores']}<br>";
  48. // 数组成员的类型, 类型不受限制
  49. // 数组的值如果仍然是数组的话, 就创建了一个多维数组,多维数组中最常用的就是二维数组
  50. // 因为从数据表查询的结果, 大多以二维数组的形式呈现
  52. echo $students2['scores']['php'];
  53. echo '<hr>';
  58. // 数组的遍历
  59. // 1. 逐个遍历
  60. // 利用数组内部的指针
  61.  //$stu = ['id'=>'1111', 'name' => 'zhangsan', 'age' => 35, 'course' => 'php', 'grade' => 68];
  62. // 在没有遍历之前,数组指针指向第一个元素
  63. // current(): 当前数组成中的值, key()
  64. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  65. // next($stu);
  66. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  67. // next($stu);
  68. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  69. // next($stu);
  70. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  71. // prev($stu);
  72. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  73. // end($stu);
  74. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  75. // reset($stu);
  76. // printf('[ %s ] => %s<br>', key($stu), current($stu));
  79. // 2. 自动遍历
  80. $stu = ['id'=>'1111', 'name' => 'zhangsan', 'age' => 35, 'course' => 'php', 'grade' => 68];
  81. // reset($stu);
  82. // while (true) {
  83. //     printf('[ %s ] => %s<br>', key($stu), current($stu));
  84. //     if (next($stu)) {
  85. //         continue;
  86. //     } else {
  87. //     break;
  88. //     }
  89. // }
  91. // 只获取数组成员的值
  92. foreach($stu as $value){
  93.     printf('%s***<br>',$value);
  94.     }
  95. echo '<hr>';
  97. // 获取数组成员的键与值
  98. foreach($stu as $key=>$value){
  99.     printf('[%s]=>%s###<br>',$key,$value);
  100. }
  102. echo '<hr>';
  104. $users =null;
  105. $users[0] = ['id'=>'1010', 'name'=>'zhangsan', 'age'=>88];
  106. $users[1] = ['id'=>'1020', 'name'=>'lisi', 'age'=>78];
  107. $users[2] = ['id'=>'1030', 'name'=>'wangwu', 'age'=>68];
  109. // 一般遍历二维数组,我们只关心值
  110. // foreach ($users as $user) {
  111. //     printf('id: %s---name: %s---age: %s<br>', $user['id'], $user['name'], $user['age']); 
  112. // }
  114. echo '<hr>';
  116. // 用list()对数组进行解构来遍历
  118. foreach ($users as list('id'=> $id, 'name'=> $name, 'age'=>$age)) {
  119.     // printf('id: %s******name: %s******age: %s<br>', $id, $name, $age); 
  120. }
  121. echo '<hr>';
  122. $staffs = null;
  123. $staffs[] = ['2020', 'zhangsan', 29, [67, 88]];
  124. $staffs[] = ['2021', 'lisi', 39, [99, 31]];
  125. $staffs[] = ['2022', 'wangwu', 49, [56, 63]];
  127. foreach ($staffs as list($id, $name, $age, list($js, $php) )) {
  128.     printf('id => %s, name => %s, age => %s, js=> %s, php=>%s<br>', $id, $name, $age, $js, $php); 
  129. }
  131. echo '<hr>';
  133. // foreach(): 遍历对象
  134. $obj = new stdClass();
  135. $obj->name = 'admin';
  136. $obj->email = 'admin@php.cn';
  137. $obj->role = 'custom';
  139. foreach ($obj as $prop => $value) {
  140.     printf('[ %s ] => %s<br>', $prop, $value);
  141. }
  146. // 与值相关的函数
  148. // array_values($arr):返回数据中所有成员的值组成的数组,会将键名重置
  149. $arr = [3=>10,  9=> 20, 0 => 'html', 'id' => 'css', 20 => 20, 30];
  150. print_r($arr);
  151. echo '<br>';
  152. print_r(array_values($arr));
  154. echo '<hr>';
  156. // in_array($search, $arr): 检查某个元素是否存在于指定的数组中
  157. echo (in_array('html5', $arr) ? '存在' : '没有') . '<br>';
  159. // array_search($search, $arr): 搜索指定的值, 返回的是键名
  160. echo $key = array_search('css', $arr);
  162. echo $arr[$key];
  164. echo '<hr>';
  166. // array_unique($arr): 删除重复的值, "去重"函数
  167. $newArr = array_unique($arr);
  168. print_r($newArr);
  175. // 与统计相关
  176. // count($arr): 数组成员数量
  177. $arr =  [10, 3, 5, 3, 10, 5, 7, 3, 10, 7, 7];
  178. printf('<pre>%s</pre>', print_r($arr,true));
  179. echo '数组成员的数量: ' .  count($arr);
  181. // array_count_values($arr): 统计数组中某个值的出现的频率
  182. $res = array_count_values($arr);
  183. printf('<pre>%s</pre>', print_r($res,true));
  188. // 与计算相关
  189. $arr = [10,20,'php50', '50php',30];
  190. // '50php': 将开头的数字字符串解析出来,'php50'
  191. // 求和
  192. echo array_sum($arr). '<hr>';
  194. // 计算乘积
  195. $arr = [10,20, '50php',30];
  196. // 'php50'被解析为0
  197. echo array_product($arr);
  199. echo '<hr>';
  203. // 栈与队列
  205. // 栈: 后进先出, 最后进入的最先出来, LIFO, 添加与删除受限,只允许在一端进行
  206. // 队列: 先进先出, 最先插入的数据最先出来, FIFO, 添加与删除允许在二端进行
  208. // 1. 栈操作: 尾部进行添加与删除
  209. $stack = [];
  210. // 进栈: array_push($arr, $data,...): 返回的是当前数组中被添加成功的元素的数量
  211. echo array_push($stack,10) . '<br>';
  212. echo array_push($stack,20, 30) . '<br>';
  213. printf('<pre>%s</pre>', print_r($stack, true));
  214. // echo '<hr>';
  215. // 出栈: array_pop($stack): 返回的是出栈的元素
  216. echo array_pop($stack) . '<br>';
  217. // echo array_pop($stack) . '<br>';
  218. // echo array_pop($stack) . '<br>';
  219. // var_dump(array_pop($stack));
  220. // echo '<hr>';
  222. // 2. 栈操作: 头部进行添加与删除
  223. // 入栈: array_unshift($arr, $data,...)
  224. // echo array_unshift($stack, 'one'). '<br>';
  225. // echo array_unshift($stack, 'three', 'two'). '<br>';
  226. // printf('<pre>%s</pre>', print_r($stack, true));
  227. // echo '<hr>';
  229. // 出栈: array_shift($stack), 返回元素
  230. // echo array_shift($stack) . '<br>';
  231. // echo array_shift($stack) . '<br>';
  232. // echo array_shift($stack) . '<br>';
  233. // var_dump(array_shift($stack));
  234. // echo '<hr>';
  236. // 3. 队列操作: 
  237. // 尾部进队, 头部出队: array_push() + array_shift()
  238. $queue = [];
  239. echo array_push($queue, 10, 20, 30);
  240. printf('<pre>%s</pre>', print_r($queue, true));
  241. echo '<hr>';
  242. echo array_shift($queue) . '<br>';
  243. echo array_shift($queue) . '<br>';
  244. echo array_shift($queue) . '<br>';
  246. // 头部进队, 尾部出队: array_unshift() + array_pop()
  247. echo '<hr>';
  249. echo array_unshift($queue, 'one', 'two', 'three').'ddddd';
  250. printf('<pre>%s</pre>', print_r($queue, true));
  251. echo '<hr>';
  252. echo array_pop($queue) . '<br>';
  253. echo array_pop($queue) . '<br>';
  254. echo array_pop($queue) . '<br>';
  260. // 排序: 参数数组引用传参
  261. // 1. 对值
  262.  $arr = [30, 4, 82, 15, 20, 'abc', 'hello', 2, 46];
  263. // printf('原始数组:<pre>%s</pre><hr>', print_r($arr, true));
  264. // 1.1 升序
  265.  sort($arr);
  266.  printf('升序索引重置:<pre>%s</pre><hr>', print_r($arr, true));
  267. // // 1.2 升序,但索引不变
  268. // $arr = [30, 4, 82, 15, 20, 'abc', 'hello', 2, 46];
  269. // // a: asoc 
  270. // asort($arr);
  271. // printf('升序索引不变:<pre>%s</pre><hr>', print_r($arr, true));
  273. // 1.2 降序
  274. // rsort($arr);
  275. // printf('降序索引重置:<pre>%s</pre><hr>', print_r($arr, true));
  276. // // 2.2 升序,但索引不变
  277. // $arr = [30, 4, 82, 15, 20, 'abc', 'hello', 2, 46];
  278. // // a: asoc 
  279. // arsort($arr);
  280. // printf('降序索引不变:<pre>%s</pre><hr>', print_r($arr, true));
  282. // 2.  对键名排序
  283. // $arr = ['e' => 10, 'a' => 30, 'p' => 50];
  284. // // 按键名升序, k: key
  285. // ksort($arr);
  286. // printf('按键名升序:<pre>%s</pre><hr>', print_r($arr, true));
  287. // // 键名降序
  288. // $arr = ['e' => 10, 'a' => 30, 'p' => 50];
  289. // krsort($arr);
  290. // printf('按键名降序:<pre>%s</pre><hr>', print_r($arr, true));
  292. // 3. 自定义排序
  293. // $arr = [90, 33, 4, 10, 2, 12];
  294. // // 自定义升序:u: user
  295. // usort($arr, function($a, $b) {
  296. //     return $a - $b;
  297. // });
  298. // printf('自定义升序:<pre>%s</pre><hr>', print_r($arr, true));
  300. // // 自定义降序:u: user
  301. // $arr = [90, 33, 4, 10, 2, 12];
  302. // usort($arr, function($a, $b) {
  303. //     return $b - $a;
  304. // });
  305. // printf('自定义降序:<pre>%s</pre><hr>', print_r($arr, true));
  307. // 4. 自然排序
  308. // $arr = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  309. // sort($arr);
  310. // printf('升序:<pre>%s</pre><hr>', print_r($arr, true));
  311. // echo '<hr>';
  313. // // 自然排序
  314. // $arr = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  316. // natsort($arr);
  317. // printf('自然升序:<pre>%s</pre><hr>', print_r($arr, true));
  319. // 5. 乱序反转
  320. $arr = ['id' => 109, 'username' => 'peter', 'age' => 27, 'salary' => 99999];
  321. // 打乱
  322. // shuffle($arr);
  323. // printf('乱序:<pre>%s</pre><hr>', print_r($arr, true));
  325. $arr = array_reverse($arr);
  326. printf('反转:<pre>%s</pre><hr>', print_r($arr, true));
  328. // 交换键值
  329. $arr = ['name' => 'admin', 'age' => 30, 'salary' => 8888];
  330. $arr = ['name' => 'admin', 'age' => 30, 'salary' => false];
  331. $arr=@array_flip($arr);
  332. printf('交换:<pre>%s</pre><hr>', print_r($arr, true));
  335. //10个课堂未讲过的函数
  337. //查询与替换
  338. //从数组中随机取出一个或多个元素
  339. $input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
  340. $rand_keys = array_rand($input, 2);
  341. echo $input[$rand_keys[0]] . '<br>';
  342. echo $input[$rand_keys[1]] . '<br>';
  345. //获取多维数组中一列组成的新数组
  346. $records = array(
  347.     array(
  348.         'id' => 2135,
  349.         'first_name' => 'John',
  350.         'last_name' => 'Doe',
  351.     ),
  352.     array(
  353.         'id' => 3245,
  354.         'first_name' => 'Sally',
  355.         'last_name' => 'Smith',
  356.     ),
  357.     array(
  358.         'id' => 5342,
  359.         'first_name' => 'Jane',
  360.         'last_name' => 'Jones',
  361.     ),
  362.     array(
  363.         'id' => 5623,
  364.         'first_name' => 'Peter',
  365.         'last_name' => 'Doe',
  366.     )
  367. );
  369. $first_names = array_column($records, 'first_name');
  370. print_r($first_names);
  372. echo '<hr>';
  374. //使用后面数组的值替换第一个数组的值
  376. $base = array("orange", "banana", "apple", "raspberry");
  377. $replacements = array(0 => "pineapple", 4 => "cherry");
  378. $replacements2 = array(0 => "grape");
  380. $basket = array_replace($base, $replacements, $replacements2);
  381. print_r($basket);
  383. echo '<hr>';
  386. //使用传递的数组递归替换第一个数组的元素
  387. //array_replace_recursive()
  390. //计算数组的交集
  392. $array1 = array("a" => "green", "red", "blue");
  393. $array2 = array("b" => "green", "yellow", "red");
  394. $result = array_intersect($array1, $array2);
  395. print_r($result);
  396. echo '<hr>';
  398. //返回数组的交集，键名也做比较
  400. $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
  401. $array2 = array("a" => "green", "b" => "yellow", "blue", "red");
  402. $result_array = array_intersect_assoc($array1, $array2);
  403. print_r($result_array);
  404. echo '<hr>';
  406. //计算数组的差集
  407. //对比 array1 和其他一个或者多个数组，返回在 array1 中但是不在其他 array 里的值。 
  408. $array1 = array("a" => "green", "red", "blue", "red");
  409. $array2 = array("b" => "green", "yellow", "red");
  410. $result = array_diff($array1, $array2);
  411. print_r($result);
  412. echo '<hr>';
  415. //返回数组的差集，键名也做比较
  416. //array_diff_assoc()
  419. //分割与合并
  420. //通过合并两个数组来创建一个新数组
  421. //创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值 
  422. $a = array('green', 'red', 'yellow');
  423. $b = array('avocado', 'apple', 'banana');
  424. $c = array_combine($a, $b);
  425. print_r($c);
  426. echo '<hr>';
  429. //把一个或多个数组合并为一个数组
  430. //array_merge() 将一个或多个数组的单元合并起来，一个数组中的值附加在前一个数组的后面。返回作为结果的数组。 
  431. //如果输入的数组中有相同的字符串键名，则该键名后面的值将覆盖前一个值。然而，如果数组包含数字键名，后面的值将不会覆盖原来的值，而是附加到后面。 
  432. //如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。 
  433. $array1 = array("color" => "red", 2, 4);
  434. $array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
  435. $result = array_merge($array1, $array2);
  436. print_r($result);
  437. echo '<hr>';
  440. //将一个数组分割成多个子数组
  441. //array_chunk()参数中preserve_keys
  442. //设为 TRUE，可以使 PHP 保留输入数组中原来的键名。如果你指定了 FALSE，那每个结果数组将用从零开始的新数字索引。默认值是 FALSE。 
  445. $input_array = array('a', 'b', 'c', 'd', 'e');
  446. print_r(array_chunk($input_array, 2));
  447. print_r(array_chunk($input_array, 2, true));
  448. echo '<hr>';
  451. //自动生成
  452. //根据范围创建数据，包含指定的元素
  453. //range ( mixed $start , mixed $end [, number $step = 1 ] ) : array
  454. //建立一个包含指定范围单元的数组。 
  455. //参数:start,序列的第一个值。 end,序列结束于 end 的值。
  456. // step,如果设置了步长 step，会被作为单元之间的步进值。step 应该为正值。不设置step 则默认为 1。 
  457. //返回值,返回的数组中从 start 到 end （含 start 和 end）的单元。 
  458. // array(0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
  460. foreach (range(0, 100, 10) as $number) {
  461.     echo $number;}
  462.     echo '<hr>';
  466. //用给定的值填充数组
  467. //array_fill ( int $start_index , int $num , mixed $value ) : array
  468. //array_fill() 用 value 参数的值将一个数组填充 num 个条目，键名由 start_index 参数指定的开始。 
  469. $a = array_fill(5, 6, 'banana');
  470. $b = array_fill(-2, 4, 'pear');
  471. print_r($a);
  472. print_r($b);
  473. echo '<hr>';
  476. //使用指定的键和值填充数组
  477. //array_fill_keys()
  480. //以指定长度将一个值填充进数组
  481. //array_pad() 返回 array 的一个拷贝，并用 value 将其填补到 size 指定的长度。
  482. //如果 size 为正，则填补到数组的右侧，如果为负则从左侧开始填补。
  483. //如果 size 的绝对值小于或等于 array 数组的长度则没有任何填补。有可能一次最多填补 1048576 个单元。 
  485. $input = array(12, 10, 9);
  487. $result = array_pad($input, 5, 0);
  488. // result is array(12, 10, 9, 0, 0)
  490. $result = array_pad($input, -7, -1);
  491. // result is array(-1, -1, -1, -1, 12, 10, 9)
  493. $result = array_pad($input, 2, "noop");
  494. // not padded
  495. echo '<hr>';
  497. //类型转换
  498. //将数组中的值赋予一组变量（类似解构赋值）
  499. //像 array() 一样，这不是真正的函数，而是语言结构。 list() 可以在单次操作内就为一组变量赋值。 
  500. $info = array('coffee', 'brown', 'caffeine');
  501. // 列出所有变量
  502. list($drink, $color, $power) = $info;
  503. echo "$drink is $color and $power makes it special.\n";
  504. echo '<hr>';
  506. //将数组元素按指定字符拼装成字符串
  507. $array = array('lastname', 'email', 'phone');
  508. $comma_separated = implode(",", $array);
  509. echo $comma_separated;
  510. echo '<hr>';
  512. //将字符串分割为数组
  513. //explode()
  514. $pizza  = "piece1 piece2 piece3 piece4 piece5 piece6";
  515. $pieces = explode(" ", $pizza);
  516. echo $pieces[0]; // piece1
  517. echo $pieces[1]; // piece2
  518. echo '<hr>';
  520. //将关联数组拆分成变量名值对
  522. //假定 $var_array 是 wddx_deserialize 返回的数组
  524. $size = "large";
  525. $var_array = array("color" => "blue",
  526.                    "size"  => "medium",
  527.                    "shape" => "sphere");
  528. extract($var_array, EXTR_PREFIX_SAME, "wddx");
  530. echo "$color, $size, $shape, $wddx_size\n";
  531. echo '<hr>';
  534. //将一直变量名值对拼装成一个关联数组的键值对
  535. //compact() 接受可变的参数数目。
  536. //每个参数可以是一个包括变量名的字符串或者是一个包含变量名的数组，
  537. //该数组中还可以包含其它单元内容为变量名的数组， compact() 可以递归处理。 
  538. $city  = "San Francisco";
  539. $state = "CA";
  540. $event = "SIGGRAPH";
  542. $location_vars = array("city", "state");
  544. $result = compact("event", "nothing_here", $location_vars);
  545. print_r($result);
  547. echo '<hr>';
  551. // 查询与替换
  552. // 1. array_slice($arr, $offset, $length, $flag): 从数组取出一部分
  553. // $stu = ['id' => 101, 'name' => '无忌', 'age' => 20, 'course' => 'php', 'grade' => 80];
  554. // $res = array_slice($stu, 0);
  555. // 获取前2个
  556. // $res = array_slice($stu, 0, 2);
  557. // 从第2个索引开始取3个
  558. // $res = array_slice($stu, 1, 3);
  559. // 第2个参数支持负数, 从倒数第3个,取2个
  560. // $res = array_slice($stu, -3, 2);
  561. // $res = array_slice($stu, 1, -1);
  564. // $res = array_slice(array_values($stu), 1, -1 , false);
  565. // $stu = array_values($stu);
  566. // $res = array_slice($stu, 1, -1 , true);
  567. // printf('<pre>%s</pre><hr>', print_r($res, true));
  569. // 2. array_splice(&$arr, ):删除数组中的一部分并用其它值代替
  570. // 可以实现对数组的: 删除, 替换/更新, 添加
  571. $arr = [10, 28, 9, 33, 56, 21, 82, 47];
  572. printf('原始数组元素: <pre>%s</pre>', print_r($arr, true));
  573. // 删除元素
  574. // array_splice($arr, 起始索引, 删除数量), 返回的是被删除元素组成的数组
  575. // $res=array_splice($arr, 1, 2);
  576. // printf('<pre>%s</pre><hr>', print_r($res, true));
  577. // 替换功能
  578. // $res=array_splice($arr, 1, 2, [888, 999]);
  579. // $res=array_splice($arr, 1, 2, [888]);
  580. // $res=array_splice($arr, 1, 2, 888);
  581. // 添加
  582. // $res=array_splice($arr, 1, 0, [888, 999]);
  583. //  负数
  584. // $res=array_splice($arr, -3, 2, [888, 999]);
  585. $res=array_splice($arr, -4, -2, [888, 999]);
  586. printf('删除的元素: <pre>%s</pre><hr>', print_r($res, true));
  587. printf('当前: <pre>%s</pre><hr>', print_r($arr, true));
  594. // 数组元素回调处理
  595. // 1.array_filter(): 用回调过滤数组中的单元,返回计算结果为true的元素组成的数组
  596. $arr = [150, 'php',true,[4,5,6], (new class {}), [], null, false, '', 0, '0'];
  597. // php自动转为false的值: null, false, 空数组, 空字符串, 0, '0'
  598. // 提示: 空对象不能转为false, 但是空数组是false
  599. $res = array_filter($arr,function($item){
  600.     return $item;
  601. });
  602. $res = array_filter($arr);
  604. $res = array_filter($arr,function($item){
  605.     // 只返回标量的数据
  606.     // 标量: 单值变量(简单类型,string, int,float,boolean), 数组,对象不是,它们是复合
  607.     return is_scalar($item) ;
  608. });
  609. // printf('<pre>%s</pre><hr>', print_r($res, true));
  611. // echo '<hr>';
  613. // 2. array_map(): 为数组中的每个元素应用回调函数进行处理,返回新数组
  614. $arr = ['php',[3,4,5], (new class {public $name='电脑';public $price=8888;}), 15, 20];
  616. $res = array_map(function($item){
  617. // 将对象和数组拉平
  618. switch (gettype($item)) {
  619.     case 'object':
  620.         $item = get_object_vars($item);
  621.     case 'array':
  622.         $item = implode(', ', $item);
  623. }
  624. return $item;
  625. }, $arr);
  627. // printf('<pre>%s</pre><hr>', print_r($res, true));
  629. echo '<hr>';
  631. // array_map(): 同时处理多个数组
  632. $key = ['host', 'username', 'password'];
  633. $values = ['localhost', 'root', '123456'];
  634. // $res = array_combine($key, $values);
  636. $res = array_map(function($value1, $value2) {
  637.     return [$value1 => $value2];
  638. }, $key, $values);
  640. printf('<pre>%s</pre><hr>', print_r($res, true));
  642. echo $res[2]['password'];
  643. echo '<hr>';
  645. // 3. array_reduce(): 迭代处理数组元素
  646. function my_array_reduce($array, $callback, $init=null) {
  647.     // $prev
  648.     $prev = $init;
  649.     foreach ($array as $current) {
  650.         $prev = $callback($prev,$current);
  651.     }
  653.     return $prev;
  654. }
  655. $result=my_array_reduce($res, function($prev, $current){
  656.     // 获取当前元素的键
  657.     $key = key($current);
  658.     // 获取当前元素的值
  659.     $value = current($current);
  660.     // 拼装成键值对
  661.     $prev[$key] = $value;
  662.     return $prev;
  664. });
  666. // printf('自定义迭代:<pre>%s</pre><hr>', print_r($result, true));
  668. echo '<hr>';
  670. $res=array_reduce($res, function($prev, $current){
  671.     // 获取当前元素的键
  672.     $key = key($current);
  673.     // 获取当前元素的值
  674.     $value = current($current);
  675.     // 拼装成键值对
  676.     $prev[$key] = $value;
  677.     return $prev;
  678. });
  680. // printf('内置的数组迭代:<pre>%s</pre><hr>', print_r($res, true));
  682. // 4. array_walk(): 使用自定义回调对数组中成员逐个处理,返回布尔值
  683. // 主要用于数组成员 的格式化, 不受数组指针影响
  684. $res = ['id'=>10, 'name'=>'admin', 'email'=>'admin@php.cn'];
  685. // array_walk(数组, 回调,回调的第三个数组的默认值) 
  687. array_walk($res, function($value, $key, $color) {
  688.     printf('[ %s ] => <span style="color:%s">%s</span><br>',$key,$color, $value );
  689. },'green');

课程学习小结

利用五一假期的时间，对前的学习的数组及函数相关内容进行了较为全面地复习，包括回看视频及讲义代码，对照函数大全，尝试着逐个函数去实现一下，鉴于函数内容众多，部分参考老师授课实例，部分自己举例，部分借鉴技术手册案例，虽然这样全面地复习比较费时费力，但完成后，特别是上课时感觉没怎么听懂的地方，通过复习，基本知识点都能消化了，还是感觉内心很充实。希望将面向对象部分内容也能做这样的总结，但时间有限，也需要从方式方法上做些调整，尽量提高学习效率。

Correcting teacher：天蓬老师天蓬老师

Correction status：qualified

Teacher's comments：编程, 看是学不会的, 必须动动手
Statement of this Website
The copyright of this blog article belongs to the blogger. Please specify the address when reprinting! If there is any infringement or violation of the law, please contact admin@php.cn Report processing!
All comments Speak rationally on civilized internet, please comply with News Comment Service Agreement
0 comments
Author's latest blog post