博客列表 >0220 常用数组函数

0220 常用数组函数

曾
原创
2020年03月11日 19:27:24759浏览

常用数组函数

1. 键名相关

array_keys:获取所有键名并组成新数组

  1. <?php
  2. // array_keys,获取所有键名组成的数组
  3. $arr = ['id'=>100,'name'=>'张三','email'=>'zhangsan@admin.cn'];
  4. // 返回值为键组成的数组
  5. print_r(array_keys($arr));



array_key_exists:检查指定键名是否存在,返回值为布尔值

  1. <?php
  2. $arr = ['id'=>100,'name'=>'张三','email'=>'zhangsan@admin.cn'];
  3. // array_key_exists,检查指定键名是否存在,返回值为布尔值
  4. var_dump(array_key_exists('email',$arr));



array_key_last:返回最后一个键名,返回值为字符串

  1. <?php
  2. $arr = ['id'=>100,'name'=>'张三','email'=>'zhangsan@admin.cn'];
  3. // array_key_last,返回最后一个键名,返回值为字符串
  4. echo array_key_last($arr).'<hr>';



array_key_first:返回第一个键名,返回值为字符串

  1. <?php
  2. $arr = ['id'=>100,'name'=>'张三','email'=>'zhangsan@admin.cn'];
  3. // array_key_first,返回第一个键名,返回值为字符串
  4. echo array_key_first($arr);


2. 与值相关

array_values: 取出数组中的值,并以索引数组方式重新排序,位置不变,只改变键名

  1. <?php
  2. // array_values,取出数组中的值,并以索引数组方式重新排序,位置不变,只改变键名
  3. $arr = ['id'=>5,'num'=>10,20,30,30,20,10,5];
  4. print_r($arr);
  5. // 返回值为索引数组重新排列的新数组
  6. print_r(array_values($arr));



in_array:检查数组中是否存在某个值,返回值为布尔值

  1. <?php
  2. $arr = ['id'=>5,'num'=>10,20,30,30,20,10,5];
  3. var_dump(in_array(10,$arr));



array_search:搜索指定的值,返回值所对应的键名

  1. <?php
  2. // array_search,搜索指定的值,返回值所对应的键名
  3. $arr1 = ['id'=>100,'name'=>'张三','email'=>'zhangsan@admin.cn'];
  4. // 返回值为字符串
  5. echo array_search('张三',$arr1);



array_unique: 删除重复的值,返回值为删除重复值后的新数组

  1. <?php
  2. // array_unique,删除数组中重复出现的值
  3. $arr2 = [5,10,20,30,30,20,10,5,1];
  4. print_r($arr2);
  5. // 返回值为删除重复值后的新数组
  6. print_r(array_unique($arr2));


3. 与统计相关

count: 统计元素数量或对象属性数量

  1. <?php
  2. $arr1 = [
  3. ['name','id','email'],
  4. ['BMW','AUDI','VOLVO']
  5. ];
  6. echo '常规计数'. count($arr1).'<hr>';
  7. // 在后面加一个参数'1',就可以查询多维数组下面的所有元素个数
  8. echo '所有数组的元素个数'.count($arr1,1).'<hr>';



array_count_values: 统计所有值的出现频率

  1. <?php
  2. $arr = [5,10,20,30,30,20,10,5,1];
  3. // array_count_values,统计元素出现的次数(频率)
  4. echo '<pre>'. print_r($arr,true) .'</pre>';
  5. echo '<hr>';
  6. echo '返回一个新数组,键为原数组的值,值为它出现的次数';
  7. echo '<pre>'. print_r(array_count_values($arr),true) . '</pre>';


4. 与计算相关

array_sum 对数组中所有值求和

  1. <?php
  2. $arr = [5,10,20,30,30,20,10,5,1];
  3. // 里面有字符串也能相加,但是只相加数字型字符串,(遇到其他类型字符串就越过)
  4. // 返回值为数值型
  5. echo '数值型';
  6. var_dump(array_sum($arr));
  7. echo '<hr>';
  8. $arr1 = ['5a',10,20,30,30,20,10,5,1];
  9. echo '里面有字符串';
  10. var_dump(array_sum($arr1));
  11. $arr2 = ['a5',10,20,30,30,20,10,5,1];
  12. echo '<hr>';
  13. echo '字符串第一个值不是数字';
  14. var_dump(array_sum($arr2));
  15. echo '<hr>';



array_product: 计算数组中所有值的乘积

  1. <?php
  2. $arr3 = [5,6];
  3. echo '数组元素乘积';
  4. var_dump(array_product($arr3));
  5. echo '<hr>';
  6. $arr4 = ['5',6];
  7. echo '数组元素乘积,里面有字符串';
  8. var_dump(array_product($arr4));
  9. echo '<hr>';
  10. $arr4 = ['a5',6];
  11. echo '数组元素乘积,字符串第一个值不是数字';
  12. var_dump(array_product($arr4));

5. 栈与队列

array_push: 从尾部添加一个或多个元素,返回值为当前元素个数,并不是添加了多少个元素

  1. <?php
  2. $arr = [];
  3. // 返回值为当前元素个数,并不是添加了多少个元素
  4. echo '当前元素:'.array_push($arr,'杨过').'<hr>';
  5. echo '当前元素:'.array_push($arr,'小龙女').'<hr>';
  6. echo '当前元素:'.array_push($arr,'郭襄','张三丰').'<hr>';
  7. print_r($arr);



array_pop: 从尾部删除最后一个元素

  1. <?php
  2. // `array_pop`: 从尾部删除最后一个元素
  3. $arr = ['杨过','小龙女','郭襄','张三丰'];
  4. // 返回值为删除的元素
  5. echo array_pop($arr).'<hr>';
  6. print_r($arr);



array_unshift: 从头部添加一个或多个元素

  1. <?php
  2. // `array_unshift`: 从头部添加一个或多个元素
  3. $arr = ['杨过','小龙女','郭襄','张三丰'];
  4. // 返回值为当前元素个数,并不是添加了多少个元素
  5. echo array_unshift($arr,'杨康').'<hr>';
  6. // 添加方式(可以理解为书写方式)从右边开始向左边书写
  7. echo array_unshift($arr,'尹志平').'<hr>';
  8. print_r($arr);



array_shift: 从头部删除一个元素

  1. <?php
  2. // `array_shift`: 从头部删除一个元素
  3. $arr = ['杨过','小龙女','郭襄','张三丰'];
  4. // 返回值为删除的元素
  5. echo array_shift($arr).'<hr>';
  6. print_r($arr);
  7. echo '<hr>';


6. 排序

sort: 按值升序排序, 索引重排

  1. <?php
  2. // `sort`: 按值升序排序, 索引重排
  3. $arr = [7,8,6,10,11,1,3,5,20];
  4. echo '原数组';
  5. echo '<pre>'.print_r($arr,true).'</pre>';
  6. sort($arr);
  7. echo '重新排序后';
  8. echo '<pre>'.print_r($arr,true).'</pre>';



asort: 按值升序排序, 索引保持不变

  1. <?php
  2. $arr = [7,8,6,10,11,1,3,5,20];
  3. echo '原数组';
  4. echo '<pre>'.print_r($arr,true).'</pre>';
  5. echo '重新排序索引不变';
  6. asort($arr);
  7. echo '<pre>'.print_r($arr,true).'</pre>';



rsort: 按值降序排序, 索引重排

  1. <?php
  2. $arr = [7,8,6,10,11,1,3,5,20];
  3. echo '原数组';
  4. echo '<pre>'.print_r($arr,true).'</pre>';
  5. rsort($arr);
  6. echo '按值降序排列';
  7. echo '<pre>'.print_r($arr,true).'</pre>';



arsort: 按值降序排序, 索引保持不变

  1. <?php
  2. $arr = [7,8,6,10,11,1,3,5,20];
  3. echo '原数组';
  4. echo '<pre>'.print_r($arr,true).'</pre>';
  5. arsort($arr);
  6. echo '按值降序排列,索引保持不变';
  7. echo '<pre>'.print_r($arr,true).'</pre>';



ksort: 按键名升序排序

  1. <?php
  2. // `ksort`: 按键名升序排序,以ascall码做对比
  3. $arr = ['a'=>7,'bd'=>8,'bc'=>6,10,11,1,3,5,20];
  4. echo '原数组';
  5. echo '<pre>'.print_r($arr,true).'</pre>';
  6. ksort($arr);
  7. echo '<pre>'.print_r($arr,true).'</pre>';



krsort: 按键名降序排序

  1. <?php
  2. $arr = ['a'=>7,'bd'=>8,'bc'=>6,10,11,1,3,5,20];
  3. echo '原数组';
  4. echo '<pre>'.print_r($arr,true).'</pre>';
  5. // krsort`: 按键名降序排序
  6. krsort($arr);
  7. echo '<pre>'.print_r($arr,true).'</pre>';



natsort: 支持数字型字符串排序

  1. <?php
  2. $arr = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  3. echo '普通的以值排序';
  4. sort($arr);
  5. echo '<pre>'.print_r($arr,true).'</pre>';
  6. echo '自然排序';
  7. $arr1 = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  8. natsort($arr1);
  9. echo '<pre>'.print_r($arr1,true).'</pre>';



shuffle: 随机打乱一个数组的顺序

  1. <?php
  2. $arr = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  3. sort($arr);
  4. echo '<pre>'.print_r($arr,true).'</pre>';
  5. shuffle($arr);
  6. echo '<pre>'.print_r($arr,true).'</pre>';

图:每次执行都会改变

array_flip: 交换数组中的键和值,返回值为一个新数组

  1. <?php
  2. $arr = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  3. echo '<pre>'.print_r($arr,true).'</pre>';
  4. // `array_flip`: 交换数组中的键和值,返回值为一个新数组
  5. $arr1 = array_flip($arr);
  6. echo '<pre>'.print_r($arr1,true).'</pre>';



array_reverse: 反转一个数组,返回值为一个新数组

  1. <?php
  2. $arr = ['img1.jpg', 'img5.jpg', 'img10.jpg', 'img8.jpg'];
  3. echo '<pre>'.print_r($arr,true).'</pre>';
  4. // `array_reverse`: 反转一个数组,返回值为一个新数组
  5. $arr1 = array_reverse($arr);
  6. echo '<pre>'.print_r($arr1,true).'</pre>';


7. 查询与替换

array_slice: 从数组中取出一部分

  1. <?php
  2. // `array_slice`: 从数组中取出一部分
  3. $arr = ['杨过','小龙女','郭襄','尹志平','杨康'];
  4. //返回值为取出的元素组成的新数组
  5. //参数为数组,从某个位置开始,从开始位置起取几个元素
  6. //从下标2开始,取完
  7. $arr1 = array_slice($arr,2);
  8. echo '从下标2开始,取完';
  9. echo '<pre>'.print_r($arr1,true).'</pre>';
  10. //从下标2开始,取2个
  11. $arr2 = array_slice($arr,2,2);
  12. echo '从下标2开始,取2个';
  13. echo '<pre>'.print_r($arr2,true).'</pre>';
  14. echo '原始数组不会改变';
  15. echo '<pre>'.print_r($arr,true).'</pre>';



array_splice: 去掉数组中一部分并用其它值代替

  1. <?php
  2. $arr = ['杨过','小龙女','郭襄','尹志平','杨康'];
  3. echo '<pre>'.print_r($arr,true).'</pre>';
  4. // `array_splice`: 去掉数组中一部分并用其它值代替,返回值为去掉的元素组成的数组
  5. //参数1为数组,参数2从某个位置开始,参数3从开始位置起取几个元素(不写默认到最后),参数4替换的元素(不写就是删除不替换)替换两个元素用数组,单个元素就用字符串
  6. array_splice($arr,3,2,['丘处机','金轮法王']);
  7. echo '<pre>'.print_r($arr,true).'</pre>';



array_rand: 从数组中随机取出一个或多个元素的键名

  1. <?php
  2. $arr = ['杨过','小龙女','郭襄','尹志平','杨康'];
  3. echo '<pre>'.print_r($arr,true).'</pre>';
  4. // `array_rand`: 从数组中随机取出一个或多个元素的键名
  5. // 参数1为需要取键的数组,参数2为取多少个(默认为1)
  6. // 返回值为键组成的新的数组
  7. // 如果取1个,返回值为字符串
  8. $res = array_rand($arr,3);
  9. echo '<pre>'.print_r($res,true).'</pre>';



array_column: 获取多维数组中一列组成的新数组

  1. <?php
  2. // `array_column`: 获取多维数组中一列组成的新数组
  3. $arr1 = [
  4. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  5. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  6. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  7. ];
  8. //参数1提取的原数组,参数2提取的字段,参数3参考字段(可以不写)
  9. $result = array_column($arr1,'name');
  10. echo '<pre>'.print_r($result,true).'</pre><br>';
  11. $result = array_column($arr1,'name','id');
  12. echo '<pre>'.print_r($result,true).'</pre><br>';



array_replace 使用后面数组的值替换第一个数组的值

  1. <?php
  2. // `array_replace` 使用后面数组的值替换第一个数组的值
  3. $arr = ['id'=>10,'name'=>'杨过','email'=>'yangguo@admin.cn'];
  4. echo '<pre>'.print_r($arr,true).'</pre><br>';
  5. $arr1 = ['name'=>'小龙女','email'=>'xiaolongnv@admin.cn'];
  6. // 返回值为替换后的新数组
  7. // 参数1为源数组,参数2为替换数组
  8. $result = array_replace($arr,$arr1);
  9. echo '替换后:';
  10. echo '<pre>'.print_r($result,true).'</pre><br>';



array_intersect: 计算数组元素的交集(相同元素),返回值为相同元素组成的新数组

  1. <?php
  2. $arr = [10,20,30,40];
  3. $arr1 = [20,30,50,60];
  4. // 返回值为相同元素组成的新数组
  5. $res = array_intersect($arr,$arr1);
  6. print_r($res);



array_intersect_assoc: 返回数组交集,键名也做比较,键值对相同才会返回

  1. <?php
  2. // `array_intersect_assoc`: 返回数组交集,键名也做比较,键值对相同才会返回
  3. $arr = ['id'=>10,'name'=>'杨过','email'=>'yangguo@admin.cn'];
  4. $arr1 = ['id'=>10,'name1'=>'杨过','email'=>'xiaolongnv@admin.cn'];
  5. $res = array_intersect_assoc($arr,$arr1);
  6. echo '键与值其中一个不相同就不会返回<br>';
  7. print_r($res);



array_diff:返回数组的差集

  1. <?php
  2. // `array_diff`:返回数组的差集
  3. $arr = ['id'=>10,'name'=>'杨过','email'=>'yangguo@admin.cn'];
  4. $arr1 = ['id'=>10,'name'=>'小龙女','email'=>'xiaolongnv@admin.cn'];
  5. //参数1为源数组,参数2为比较数组,返回值为源数组作为基础与比较数组不相同的元素
  6. $res = array_diff($arr,$arr1);
  7. print_r($res);


8. 分割与合并

array_combine: 通过合并两个数组来创建一个新数组

  1. <?php
  2. $arr = ['id','name','email'];
  3. $arr1 = [100,'杨过','yangguo@admin.cn'];
  4. // 参数1数组为键,参数2数组为值,返回一个新数组
  5. $res = array_combine($arr,$arr1);
  6. print_r($res);



array_merge: 把一个或多个数组合并为一个数组

  1. <?php
  2. // `array_merge`: 把一个或多个数组合并为一个数组
  3. $arr = ['c'=>'cat','d'=>'dog','t'=>'tiger'];
  4. $arr1 = ['c'=>'colt','t'=>'tabby','h'=>'horse'];
  5. // 两个数组合并,同键名的,第二个数组会覆盖掉前一个数组的元素
  6. $res = array_merge($arr,$arr1);
  7. echo '<pre>'.print_r($res,true).'</pre><hr>';
  8. // 如果只是想把第二个数组里面不同键名的元素合并进第一个数组,可以使用'+'号
  9. $res = $arr +$arr1;
  10. echo '这是使用+号合并';
  11. echo '<pre>'.print_r($res,true).'</pre>';



array_chunk: 将一个数组分割成多个子数组

  1. <?php
  2. // `array_chunk`: 将一个数组分割成多个子数组
  3. // 可以理解成分成几份来显示
  4. $arr = [7,8,6,10,11,1,3,5,20];
  5. // 返回值为分割后的多为数组
  6. echo '<pre>'.print_r(array_chunk($arr,3),true).'</pre>';


9. 数组指针

current: 获取当前元素的值

  1. <?php
  2. // `current`: 获取当前元素的值
  3. $arr1 = [
  4. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  5. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  6. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  7. ];
  8. print_r(current($arr1));



key: 获取当前元素的键名

  1. <?php
  2. // `current`: 获取当前元素的值
  3. $arr1 = [
  4. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  5. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  6. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  7. ];
  8. //返回值为当前指针指向的元素的键名
  9. echo key($arr1);

图:指针未移动当前元素的键为0

next: 将数组中的内部指针向前移动一位

  1. <?php
  2. $arr1 = [
  3. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  4. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  5. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  6. ];
  7. // `next`: 将数组中的内部指针向前移动一位
  8. echo '当前指针指向的键:'. key($arr1) . '<br>当前指向的元素:';
  9. print_r(current($arr1));
  10. echo '<hr>';
  11. //指针下移
  12. next($arr1);
  13. echo '下移后指针指向的键:'. key($arr1) . '<br>下移后指向的元素:';
  14. print_r(current($arr1));



prev: 将数组的内部指针倒回一位

  1. <?php
  2. $arr1 = [
  3. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  4. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  5. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  6. ];
  7. next($arr1);
  8. echo '当前指针指向的键:'. key($arr1) . '<br>当前指向的元素:';
  9. print_r(current($arr1));
  10. echo '<hr>';
  11. prev($arr1);
  12. echo '后退后指针指向的键:'. key($arr1) . '<br>后退后指向的元素:';
  13. print_r(current($arr1));



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

  1. <?php
  2. $arr1 = [
  3. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  4. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  5. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  6. ];
  7. echo '当前指针指向的键:'. key($arr1) . '<br>当前指向的元素:';
  8. print_r(current($arr1));
  9. echo '<hr>';
  10. end($arr1);
  11. echo '指针指向最后一个键:'. key($arr1) . '<br>指针指向最后一个元素:';
  12. print_r(current($arr1));



reset: 将数组的内部指针指向第一个单元

  1. <?php
  2. $arr1 = [
  3. ['id'=>101,'name'=>'杨过','email'=>'yangguo@admin.cn'],
  4. ['id'=>102,'name'=>'小龙女','email'=>'小龙女@admin.cn'],
  5. ['id'=>103,'name'=>'尹志平','email'=>'尹志平@admin.cn'],
  6. ];
  7. end($arr1);
  8. echo '指针指向最后一个键:'. key($arr1) . '<br>指针指向最后一个元素:';
  9. print_r(current($arr1));
  10. echo '<hr>';
  11. reset($arr1);
  12. echo '复位后指向的键:'. key($arr1) . '<br>复位后指向的元素:';
  13. print_r(current($arr1));


10. 自动生成

array_fill: 用给定的值填充数组

  1. <?php
  2. // `array_fill`: 用给定的值填充数组
  3. // 参数1键名开始的位置,参数2表示需要几条数据,参数3为值
  4. $res = array_fill(2,5,'computer');
  5. echo '<pre>'. print_r($res,true) . '</pre>';



array_fill_keys: 使用指定的键和值填充数组

  1. <?php
  2. $arr = ['car','bus','egg'];
  3. // 参数1为指定的数组其中的值作为新数组的键,参数2为新数组的值
  4. // 返回值为一个新数组
  5. $result = array_fill_keys($arr,'computer');
  6. echo '<pre>'. print_r($result,true) . '</pre>';



array_pad: 以指定长度将一个值填充进数组

  1. <?php
  2. $arr = ['car','bus','egg'];
  3. // `array_pad`: 以指定长度将一个值填充进数组
  4. // 参数1为数组,参数2为长度,参数3为填充的值
  5. // 参数2为正数 则填补到数组的右侧,如果为负则从左侧开始填补
  6. $result = array_pad($arr,5,0);
  7. echo '<pre>'. print_r($result,true) . '</pre>';
  8. // 参数2为正数 则填补到数组的右侧,如果为负则从左侧开始填补
  9. $result = array_pad($arr,-5,-1);
  10. echo '<pre>'. print_r($result,true) . '</pre>';


11. 类型转换

list: 将数组中的值赋予一组变量(类似解构赋值)

  1. <?php
  2. // `list`: 将数组中的值赋予一组变量(类似解构赋值)
  3. $arr = [100,'杨过','yangguo@admin.cn'];
  4. // 把数组里面的值,分别赋值给list里面的变量,如果list里面的变量多出来的会赋值为空
  5. list($id,$name,$email) = $arr;
  6. echo "\$id={$id},\$name={$name},\$email={$email}";



implode: 将数组元素按指定字符拼装成字符串

  1. <?php
  2. // `implode`: 将数组元素按指定字符拼装成字符串
  3. $arr1 = ['apple','huawei','xiaomi'];
  4. $res = implode('+',$arr1);
  5. echo $res;



explode: 将字符串分割为数组

  1. <?php
  2. $arr1 = ['apple','huawei','xiaomi'];
  3. $res = implode('+',$arr1);
  4. echo $res.'<hr>';
  5. // `explode`: 将字符串分割为数组 implode的逆操作
  6. $arr2 = explode(',',$res);
  7. print_r($arr2);



extract: 将关联数组拆分成变量名值对

  1. <?php
  2. // `extract`: 将关联数组拆分成变量名值对
  3. $arr = ['id'=>10,'name'=>'杨过','email'=>'yangguo@admin.cn'];
  4. extract($arr);
  5. echo "id={$id},name={$name},email={$email}";



compact: 将一组变量名值对拼装成一个关联数组键值对

  1. <?php
  2. $arr = ['id'=>10,'name'=>'杨过','email'=>'yangguo@admin.cn'];
  3. extract($arr);
  4. echo "id={$id},name={$name},email={$email}.<hr>";
  5. // `compact`: 将一组变量名值对拼装成一个关联数组键值对
  6. // 返回值为关联数组
  7. $res = compact('id','name','email');
  8. print_r($res);


12. 回调处理

array_filter: 用回调函数过滤数组中的单元

  1. <?php
  2. // `array_filter`: 用回调函数过滤数组中的单元
  3. $arr = [null,10,5,'',0,false,20,'-1'];
  4. // 它会过滤掉,值为空,null,0,false的元素,并返回过滤后的元素
  5. $res = array_filter($arr);
  6. print_r($res);
  7. echo '<hr>';
  8. // 也可以加入回调函数,来设置符合条件的元素返回
  9. $res = array_filter($arr,function ($value) {return $value > 5;});
  10. print_r($res);



array_map: 为数组的每个元素应用回调函数

  1. <?php
  2. // `array_map`: 为数组的每个元素应用回调函数
  3. $arr = [2,5,7,10];
  4. // 参数1为回调函数,参数2及2以上都是数组
  5. // 参数1可以是闭包
  6. $res = array_map(function ($value) {
  7. return $value * $value;
  8. },$arr);
  9. print_r($res);
  10. echo '<hr>';
  11. //创建一个闭包
  12. $sum = function ($value) {return $value * 2;};
  13. //参数1为闭包
  14. $res = array_map($sum,$arr);
  15. print_r($res);
  16. echo '<hr>';
  17. $keys = ['id','name','email'];
  18. $value = [100,'杨过','yangguo@admin.cn'];
  19. //处理2个数组
  20. $res = array_map(function ($key,$value) { return [$key=>$value];},$keys,$value);
  21. print_r($res);


最后,感觉回调处理很重要啊,以前的很多实例都有用到,今天又写了一遍,但是感觉回调处理,还是有那么一点点懵,案例看少了,应用场景想不出来太多

声明:本文内容转载自脚本之家,由网友自发贡献,版权归原作者所有,如您发现涉嫌抄袭侵权,请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言,请遵守新闻评论服务协议
涵璐2020-03-12 13:27:182楼
123dd看看看看看
1232020-03-11 23:37:051楼
看看看看看看看看</body>