foreach() | list() | extract | array_map() | array_walk() | array_walk_recursive | array_filter() | array_rand() | array_product | array_sum | array_reduce |
foreach() 遍历数组传递键名和键值操作，键值能够做引用传递修改；
list() 遍历数组，把数组的值赋值给变量；不能引用产地，不会修改原数组，返回原数组；
foreach()
遍历数组的键名和键值操作；没有返回值；
语法结构汇总：
fearch(array $array as $val){} 操作键值；不会修改原数组；
fearch(array $array as &$val){} 引用变量 操作数组的键值，能够修改键值
fearch(array $array as $key => $val){} 操作数组的键值和键名；不会修改原数组；
fearch(array $multi_array as list($a....) ){} 操作多维数组，而且第二层次的数组必须是索引数组；
fearch(array $multi_array as $key => list($a....)){} 操作多维数组，，而且第二层次的数组必须是索引数组；
语法结构1：
foreach(array $array as $val){
$val ;
}
传递 键值 操作；不会修改原键值；
实例：
$a_name = ['bill','tom','jack']
foreach($a_name as $val){
echo $val.' ';
}
output : bill tom jack;
语法结构2：
foreach($array as &$val){
$val
}
传递 引用传递；操作会修改原数组；
实例：
$a_age = ['bill_age'=>33,'tom_age'=>20,'jack_age'=>40];
foreach($a_name as &$val){
$val +=10;
}
修改后 $a_age = ['bill_age'=>43,'tom_age'=>30,'jack_age'=>50];
结构语法3：
foreach($array as list($a....)){
$a
}
搭配 list() 直接操作二维数组，
实例：
$a_persional_info = array(
'bill'=>array('bill','gates',30),
'thomas=>array('thomas','jefferson',40)
)
foreach($a_personal_info as list($str_first_name,$str_last_name,$int_age)){
echo $str_first_name.' . '.$str_last_name.' is '.$int_age.' years old ! <br/>';
}
output : bill.gates is 30 years old!
thomas.jefferson is 40 years old!
结构语法4：
foreach($array as $key => $val){
$key ;
$val;
}
操作键名和键值；
实例：
$a_personal_info = array('name'=>'bill','job'=>'worker','age'=>33)
foreach($a_personal_info as $key => $val){
echo $key.'=>'.$val.'<br/>';
}
output : name => bill
job => worker
age => 33
结构语法5：
foreach($array as $key => list($a..)){
$key;
$a;
}
实例：
$a_persional_info = array(
'bill'=>array('bill','gates',30),
'thomas=>array('thomas','jefferson',40)
)
foreach($a_personal_info as $key => list($str_f_name,$str_l_name,$int_age)){
echo $key.' 的年纪是'. $int_age.' 岁!';
}
output : bill 的年纪是30岁！
thomas的年纪是40岁！
list()
把索引数组的键值赋值给变量；
返回原数组；
语法结构1：
list(mixed $name_1,......) = array $array;
把 索引数组 里面的键值，赋值给变量；
PHP 7 赋值的顺序从左到右；
实例：
list($name,$age,$job) = array('bill',33,'worker');
echo $name => bill
$age => 33
$job => worker
语法结构2：
list(mixed $name_1, , mixed $name_2) = array $array;
只获取数组中指定部分，跳过不需要的部分；
实例：
list($name , ,$job) = array('bill',33,'worker');
echo $name.' is '.$job;
output : bill is worker
语法结构3：嵌套使用
list($a,$b..list($aa,$bb...)) = array $array;
实例：
$a_brand_name = array('吉利','奇瑞',array('BMW','VOLVO'));
list($str_c_brand_name_1,$str_c_brand_name_2,list($str_g_brand_name_1,$str_g_brand_name_2)) = $a_brand_name;
echo $str_g_brand_name_1
output : BMW
语法结构4：
list($a[0],$a[1]....) = array $array;
用数组捕获键值；
实例：
$a_brand_name = array('吉利','奇瑞',array('BMW','VOLVO'));
list($a_car_brand[0],$a_car_brand[1],list($a_car_brand[2],$a_car_brand[3])) =$a_brand_name;
print_r($a_car_brand);
output : Array ( [0] => 吉利 [1] => 奇瑞 [2] => BMW [3] => VOLVO )
extract()
把关联数组的元素导入<a href='http://www.jianshu.com/p/46f91cd5f67a'>当前符号列表</a>中；
把键名当做变量标识符，键值赋值给变量；
如果键名当做变量标识符是一个非法的标识符，那么不会被导出；
基础语法：
int extract(array $array [,constant $flags = EXTRACT_OVERWRIT [,string $prefix]]);
-array $array 被操作的的数组；
-constant $flags 常数，决定键名的转化成变量的方式；
-EXTR_OVERWRIT 覆盖已有变量；
-EXTR_SKIP 保留已有变量；
-EXTR_PREFIX_SAME 如已有同名变量，在同名变量前增加前缀；
-EXTR_PREFIX_ALL 在所有的键名前增加前缀；
-EXTR_PREFIX_INVALID 在非法键名前增加前缀；
-EXTR_IF_EXISTS 导出具有相同变量名的键名，同时覆盖原有的；其他的不处理；
-EXTR_PREFIX_IF_EXISTS 导出具有变量的键名，同时在键名前增加前缀，成为一个新的变量；
-EXTR_REFS 导出的变量是数组键值的引用，随数组的改变而改变；同时会覆盖原有变量；
-string $prefix 添加前缀的字符串；
备注：
在增加的前缀同键名之间用 _ 下划线连接；
语法结构1：
int extract(array $array )
导出所有键名为变量名，同时覆盖原有的变量；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill');
extract($a_bill_info);
echo $name;
#output : bill;
语法结构2：
int extract(array $array ,EXTR_SKIP)
导出所有的键名为变量名，同已有变量名相冲突的是否，保留原有的变量；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill');
extract($a_bill_info,EXTR_SKIP);
echo $name;
#output : old_name;
语法结构3：
int extract(array $array ,EXTR_PREFIX_SAME， string $prefix)
导出所有的键名为变量名，如果同已有变量相冲突，在冲突的键名前增加前缀，为新的变量；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill');
extract($a_bill_info,EXTR_PREFIX_SAME,'bill');
echo $bill_name;
#output : bill;
语法结构4：
int extract(array $array ,EXTR_PREFIX_ALL ,string $prefix)
导出所有的键名为变量名，同时在所有的键名前增加前缀；
如果还有同名的变量名，那么覆盖原有的；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill','age'=>20);
extract($a_bill_info, EXTR_PREFIX_ALL,'bill');
echo $name.'<br/>'.$bill_name.'<br/>'.$bill_age;
语法结构5：
int extract(array $array ,EXTR_PREFIX_INVALID,string $prefix);
导出所有的键名为变量名，同时在非法的变量名前增加前缀；
如果有相同的变量名，那么覆盖；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill','1_age'=>20);
extract($a_bill_info,EXTR_PREFIX_INVALID,'bill');
echo $name. ' '.$bill_1_age;
#output : bill 20;
语法结构6：
int extract(array $array ,EXTR_IF_EXISTS)
导出已经存在相同变量名的键名，同时覆盖原有的；
没有同名变量的键名，不需要处理；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill','1_age'=>20);
extract($a_bill_info,EXTR_IF_EXISTS);
echo $name ;
#output : bill;
语法结构7：
int extract(array $array ,EXTR_PREFIX_IF_EXISTS ,string $prefix);
只导出已经存在相同变量名的键名，同时在键名前增加前缀，变成新的变量；
如果还是有重复的，那么覆盖原有的；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill','1_age'=>20);
extract($a_bill_info,EXTR_PREFIX_IF_EXISTS,'bill');
echo $bill_name.' '.$name;
#output : bill old_name;
语法结构8：
int extract(array $array ,EXTR_REFS);
导出的变量是键值的引用，会随键值的变化而变化；
覆盖同名的变量；
实例：
$name = 'old_name';
$a_bill_info = array('name'=>'bill','1_age'=>20);
extract($a_bill_info,EXTR_REFS,'bill');
echo $name;
#output : bill;
$a_bill_info['name'] = tom;
echo $name;
#output : tom;
array_map()
遍历一个或多个数组，把数组的键值传递给回调函数计算；
返回一个由函数返回值构成的数组；
当遍历一个数组的时候，返回数组的键名是原数组；当同时遍历多个数组的时候，返回数组的键名是从0开始的索引值；
基础语法：
array array_map(callback $callback ,array $array_1 [array $array_2......]);
callback $callback 回调函数，函数的第一个参数接受第一个数组传递过来的键值，函数的第二个参数接受第二个数组传递过来的键值。依次往后；
-如果传递的回调函数是NULL 的话，那么会把数组传递给函数的值直接返回，如果是多个数组传递给函数的话，那么会把多个参数组合成一个子数组返回；
-不可以传递引用参数；不能够修改原数组的键值；
-如果同时遍历的多个数组长度不同，那么用空值补充长度不够的数组；
array $array_1 需要被遍历的数组；
语法结构1：
array array_map(callback $callback ,array $array);
遍历数组的键值，传递给回调函数；
返回有回调函数的返回值构成的关联数组；
关联数组的键名 == 原数组键名；
实例：
$a_bill_info = array('first_name'=>'bill','last_name'=>'bill_ln','age'=>22,'job'=>'worker');
function add_prefix($v){
return 'prefix_'.$v;
}
print_r(array_map('add_prefix',$a_bill_info));
#output : Array ( [first_name] => prefix_bill [last_name] => prefix_bill_ln [age] => prefix_22 [job] => prefix_worker )
语法结构2：
array_map(callback $callback , array $array_1, array $array_2);
同时遍历多个数组元素；
返回一个索引数组；
实例：
$a_bill_info = array('first_name'=>'bill','last_name'=>'bill_ln','age'=>22,'job'=>'worker');
$a_tom_info = array('first_name'=>'tom','last_name'=>'tom_ln','age'=>32,'job'=>'worker');
function connect($a,$b){
return $a.$b;
}
print_r(array_map('connect',$a_bill_info,$a_tom_info));
#output : Array ( [0] => billtom [1] => bill_lntom_ln [2] => 2232 [3] => workerworker );
语法结构3：
array_map(NULL,array $array_1 ,array $array_2)
如果回调函数是 NULL 返回一个多维数组；
实例：
$a_bill_info = array('first_name'=>'bill','last_name'=>'bill_ln','age'=>22,'job'=>'worker');
$a_tom_info = array('first_name'=>'tom','last_name'=>'tom_ln','age'=>32,'job'=>'worker');
$a_jack_info = array('first_name'=>'jack','last_name'=>'jack_ln','age'=>27);
print_r(array_map(NULL ,$a_bill_info,$a_tom_info,$a_jack_info));
#output ：
#Array (
# [0] => Array ( [0] => bill [1] => tom [2] => jack )
# [1] => Array ( [0] => bill_ln [1] => tom_ln [2] => jack_ln )
# [2] => Array ( [0] => 22 [1] => 32 [2] => 27 )
# [3] => Array ( [0] => worker [1] => worker [2] => )
# )
#备注：
#注意返回的多维数组中最后一位是空值；
array_walk()
遍历数组，修改原数组的键值；所以常常传递 键值引用 给自定义函数；
遍历一个数组，把数组的键值，键名依次传递给自定义回调函数；
如果函数有第三个参数，那么这个参数作为自定义函数的第三个参数，传递给自定义函数；
成功返回 true 失败 返回 false;
基础语法：
boolean array_walk(array $array , callback $callback [,mixed $usedate = NLL]);
boolean 返回值；
array $array 需要被遍历的数组；
callback $callback 自定义回调函数；
-自定义回调函数的第一参数是键值，第二个参数是键名，第三个参数是 $usedate 默认是NULL；由于这个函数的返回值是boolean 因此主要用来改变原数组的键值使用的，所以第一个参数常常是传递 键值引用；
mixed $usedate 传递给自定义函数的第三个参数；
备注：
array_walk() 和 foreach() 都是遍历数组，
而且都不能够返回一个具有实际操作意义的值，所以常常都使用键值的引用，都主要用于原数组的修改；
array_walk() 还有能够检查成功与否的 boolean 返回，而foreach() 什么都没有；
foreach() 不仅能够遍历数组，还能够遍历对象；
语法结构1：
boolean array_walk(array $array ,callback $callback);
实例：
$a_salary = ['bill'=>2000,'tom'=>1800,'jack'=>2750];
function increase(&$v){
$v *=1.08;
}
array_walk($a_salary,'increase');
print_r($a_salary);
#output : Array ( [bill] => 2160 [tom] => 1944 [jack] => 2970 );
语法结构2：
boolean array_walk(array $array ,callback $callback ,mixed $usedate);
实例：
$a_salary = ['bill'=>2000,'tom'=>1800,'jack'=>2750];
$float_ratio = 1.08;
function increase(&$v,$k,$ratio){
$v *= $ratio;
}
array_walk($a_salary,'increase',$float_ratio);
print_r($a_salary);
$output: Array ( [bill] => 2160 [tom] => 1944 [jack] => 2970 );
#备注：
#函数 increase 必须是三个形参；不能缺少 $k,即使我们不需要；
array_walk_recursive()
递归遍历数组，把数组的键值传递给自定义函数,
除了递归遍历外，其他方面同 array_walk 相同；
基础语法：
boolean array_walk_recursive(array $array , callback $callback [,mixed $usedate = NULL]);
boolean 返回值，成功返回 true 失败返回 false;
array $array 需要被遍历的函数；
callback $callback 自定义回调函数，
-自定义函数的第一个参数是数组的键值，因为array_walk_recursive 没有实际意义的返回值，所以一般传递键值的引用，改变原数组；
-自定义函数的第二个参数是，键名；
-自定义函数的额第三个参数是 ，mixed $usedate 的值；
mixed $usedate 传递给自定义函数的第三个值；
语法结构1：
boolean array_walk_recursive(array $array , callback $callback);
function callback(&$v,$k){
$v,$k;
}
不带多余参数的遍历数组；
实例：
$a_personal_info = array(
'bill' => array(
'first_name' => 'bill_fn',
'last_name' => 'bill_ln',
'age' => 55,
'other' => array('a','b','c')
),
'tom' => array(
'first_name' => 'tom_fn',
'last_name' => 'tom_ln',
'age' => 30,
'other' => array('a','b','c')
),
'jack' => array(
'first_name' => 'jack_fn',
'last_name' => 'jack_ln',
'age' => 20,
'other' => array('a','b','c')
)
);
function change_age(&$v,$k){
if($k == 'age'){
$v += 10;
}
}
if(array_walk_recursive ($a_personal_info, 'change_age')){
print_r($a_personal_info);
}
#output :
#Array (
#[bill] => Array ( [first_name] => bill_fn [last_name] => bill_ln [age] => 65 [other] => Array ( [0] => 10 [1] => b [2] => c ) )
#[tom] => Array ( [first_name] => tom_fn [last_name] => tom_ln [age] => 40 [other] => Array ( [0] => 10 [1] => b [2] => c ) )
#[jack] => Array ( [last_name] => jack_ln [age] => 30 [other] => Array ( [0] => 10 [1] => b [2] => c ) ) )
语法结构2：
boolean array_walk_recursive(array $array , callback $callback , mixed $usedate);
function callback(&$v,$k,$date){
$v,$k,$date;
}
带额外参数的遍历数组；
实例：
$a_personal_info = array(
'bill' => array(
'first_name' => 'bill_fn',
'last_name' => 'bill_ln',
'age' => 55,
'other' => array('a','b','c')
),
'tom' => array(
'first_name' => 'tom_fn',
'last_name' => 'tom_ln',
'age' => 30,
'other' => array('a','b','c')
),
'jack' => array(
'first_name' => 'jack_fn',
'last_name' => 'jack_ln',
'age' => 20,
'other' => array('a','b','c')
)
);
function change_age(&$v,$k,$date){
if($k == 'age'){
$v += $date;
}
}
if(array_walk_recursive($a_personal_info,'change_age',1)){
print_r($a_personal_info);
}
#output:
#Array (
#[bill] => Array ( [first_name] => bill_fn [last_name] => bill_ln [age] => 56 [other] => Array ( [0] => 10 [1] => b [2] => c ) )
#[tom] => Array ( [first_name] => tom_fn [last_name] => tom_ln [age] => 31[other] => Array ( [0] => 10 [1] => b [2] => c ) )
#[jack] => Array ( [last_name] => jack_ln [age] => 21 [other] => Array ( [0] => 10 [1] => b [2] => c ) ) )
array_filter()
用自定义函数过滤数组；
返回一个有自定义函数返回true 的数组元素构成的数组；
不会改变原有数组元素；
基础语法：
array array_filter(array $array ,callback $callback [constant $flags = NULL]);
array 返回的数组；
array $array 被过滤的原始数组；
callback $callback 自定义函数；
constant $flags 决定传递给自定义函数的参数；
ARRAY_FILTER_USE_KEY 传递键名；
ARRAY_FILTER_USE_BOTH 传递键值和键名，第一个参数是键值，第二个参数是键名；
忽略没有这个参数，传递键值；
语法结构1：
array array_filter(array $array ,callback $callback);
function callback ($v){
$v;
}
实例：
$a_int = range(1,10);
function get_even($v){
if($v%2 == 0){
return true;
}
}
print_r(array_filter($a_int,'get_even'));
#output : Array ( [1] => 2 [3] => 4 [5] => 6 [7] => 8 [9] => 10 );
语法结构2：
array array_filter(array $array ,callback $callback ,ARRAY_FILTER_USE_KEY);
function callback($k){
$k;
}
实例：
$a_personal_info = array(
'王军' => array(
'first_name' => '军',
'last_name' => '王',
'age' => 55,
),
'王丹' => array(
'first_name' => '丹',
'last_name' => '王',
'age' => 30,
),
'李明' => array(
'first_name' => '明',
'last_name' => '李',
'age' => 20,
)
);
function get_people_wangs($k){
if(mb_substr($k,0,1,'utf-8') == '王'){
return true;
}
}
print_r(array_filter($a_personal_info,'get_people_wangs',ARRAY_FILTER_USE_KEY));
#output：
#Array (
#[王军] => Array ( [first_name] => 军 [last_name] => 王 [age] => 55 )
#[王丹] => Array ( [first_name] => 丹 [last_name] => 王 [age] => 30 )
# )
语法结构3：
array array_filter(array $array ,callback $callback ,ARRAY_FILTER_USE_BOTH);
实例：
$a_personal_info = array(
'王军' => array(
'first_name' => '军',
'last_name' => '王',
'age' => 55,
),
'王军' => array(
'first_name' => '军',
'last_name' => '王',
'age' => 30,
),
'李明' => array(
'first_name' => '明',
'last_name' => '李',
'age' => 20,
)
);
function get_people($v,$k){
if(mb_substr($k,0,1,'UTF-8') == '王' && $v['age'] == 30){
return true;
}
}
print_r(array_filter($a_personal_info,'get_people',ARRAY_FILTER_USE_BOTH));
#output : Array ( [王军] => Array ( [first_name] => 军 [last_name] => 王 [age] => 30 ) );
array_rand()
随机返回键名；
基础语法：
mixed array_rand(array $array [int $number = 1]);
mixed 返回一个键名字符串或 多个键名组成的数组；
array $array 被操作的数组；
int $number 指定返回的键名的个数；
备注：
如果 int $number >= 数组的长度，那么返回整个键名构成的索引数组，而且排列的顺序同原数组；
php 获取数组键名的函数
语法结构1：
string array_rand(array $array)
随机返回数组键名字符串；
实例：
$a_bill_info = array('first_name'=>'bill','last_name'=>'bill_ln','age'=>22,'job'=>'worker');
echo array_rand($a_bill_info);
#output : 数组中任意一个随机键名；
语法结构2：
array array_rand(array $array , int $number);
返回一个由随机键名组成的数组；
如果 int $number >= 数组的长度，返回整个数组的键名，同时顺序同原数组；
实例：
$a_bill_info = array('first_name'=>'bill','last_name'=>'bill_ln','age'=>22,'job'=>'worker');
print_r(array_rand($a_bill_info,2));
print_r(array_rand($a_bill_info,count($a_bill_info)));
#output:
#Array ( [0] => first_name [1] => job )
#Array ( [0] => first_name [1] => last_name [2] => age [3] => job )
array_reduce()
遍历数组，迭代的把数组简化成一个值返回；
基础语法：
mixed array_reduce(array $array ,callback $callback [, mixed $initial = NULL]);
mixed 返回值；
array $array 被用来计算的数组；
callback $callback 自定义函数；
-mixed callback(mixed $carry ,mixed $item)
-carry 上次迭代的结果，如果是第一次迭代 则是 initial ;
-item 这次迭代的值；
mixed $initial 传递给第一次迭代的自定义函数的第一个参数，或当迭代的数组为空的时候，作为返回值；
-注意初始值默认是 NULL;
语法结构1：
mixed array_reduce(array $array ,callback $callback );
初始值是NULL 的迭代；
实例：
$a_int = range(1,10);
function sum($carry,$item){
return $carry += $item;
}
echo (array_reduce($a_int,'sum'));
#output : 55;
语法结构2：
mixed array_reduce(array $array ,callback $callback, mixed $initial);
有额外参数的迭代计算；
实例：
$a_int = range(1,10);
$a_empty = array();
function product($carry,$item){
return $carray *= $item;
}
print_r(array_reduce($a_int,'product',1));
print_r(array_reduce($a_int,'product',1));
#output :
# 3628800;
# 1;
备注：
array_reduce() 的第三个参数默认是NULL 在数字计算的时候会转化成0；
array_product()
计算数组中所有键值的乘积；返回这个乘积；
专门用于数字运算；
被操作数组为空的时候，返回1；
基础语法：
number array_product(array $array);
number 返回 整数 or 浮点数；
array $array 被遍历的数组；
实例：
echo array_product(range(1,10));
#output: 3628800
备注：
被操作数组为空的时候，返回1；
array_sum() 被操作数组为空的时候，返回0；
array_sum()
返回数组中所有键值的总和；
主要用作数字；
被操作数组为空的时候，返回0；
基础语法：
number array_sum(array $array);
number 返回整数 or 浮点数；
array $array 被操作的数组；
实例：
echo array_sum(range(1,10));
#output: 55;
备注：
被操作数组为空的时候返回0；
array_product() 数组为空的时候返回1；
