PH常用函数汇总
张宣
<?php
/**
* array_change_key_case() 把数组中所有键更改为小写或大写
* array_chunk() 把一个数组分割为新的数组块
* array_column() 返回输入数组中某个单一列的值
* array_combine() 通过合并两个数组来创建一个新数组
* array_count_values() 用于统计数组中所有值出现的次数
* array_diff() 比较数组，返回差集（只比较键值）
* array_diff_assoc() 比较数组，返回差集（比较键名和键值）
* array_diff_key() 比较数组，返回差集（只比较键名）
* array_fill() 用给定的键值填充数组
* array_fill_keys() 用指定键名的给定键值填充数组
* array_filter() 用回调函数过滤数组中的元素
* array_flip() 交换数组中的键和值
* array_intersect() 比较数组，返回交集（只比较键值）
* array_intersect_assoc() 比较数组，返回交集（比较键名和键值）
* array_intersect_key() 比较数组，返回交集（只比较键名）
* array_key_exists() 检查指定的键名是否存在于数组中
* array_keys() 返回数组中所有的键名
* array_map() 把数组中的每个值发送到用户自定义函数，返回新的值
* array_merge() 把一个或多个数组合并为一个数组
* array_merge_recursive() 递归地合并一个或多个数组
* array_multisort() 对多个数组或多维数组进行排序
* array_pad() 用值将数组填补到指定长度
* array_pop() 删除数组的最后一个元素（出栈）
* array_product() 计算数组中所有值的乘积
* array_push() 将一个或多个元素插入数组的末尾（入栈）
* array_rand() 返回数组中一个或多个随机的键
* array_reduce() 通过使用用户自定义函数，以字符串返回数组
* array_replace() 使用后面数组的值替换第一个数组的值
* array_replace_recursive() 递归地使用后面数组的值替换第一个数组的值
* array_reverse() 以相反的顺序返回数组
* array_search() 搜索数组中给定的值并返回键名
* array_shift() 删除数组中首个元素，并返回被删除元素的值
* array_slice() 返回数组中被选定的部分
* array_splice() 删除并替换数组中指定的元素
* array_sum() 返回数组中值的和
* array_udiff() 比较数组，返回差集（只比较值，使用一个用户自定义的键名比较函数）
* array_udiff_assoc() 比较数组，返回差集（比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）
* array_udiff_uassoc() 比较数组，返回差集（比较键和值，使用两个用户自定义的键名比较函数）
* array_uintersect() 比较数组，返回交集（只比较值，使用一个用户自定义的键名比较函数）
* array_uintersect_assoc() 比较数组，返回交集（比较键和值，使用内建函数比较键名，使用用户自定义函数比较键值）
* array_uintersect_uassoc() 比较数组，返回交集（比较键和值，使用两个用户自定义的键名比较函数）
* array_unique() 删除数组中的重复值
* array_unshift() 在数组开头插入一个或多个元素
* array_values() 返回数组中所有的值
* array_walk() 对数组中的每个成员应用用户函数
* array_walk_recursive() 对数组中的每个成员递归地应用用户函数
* arsort() 对关联数组按照键值进行降序排序
* asort() 对关联数组按照键值进行升序排序
* compact() 创建包含变量名和它们的值的数组
* count() 返回数组中元素的数目
* current() 返回数组中的当前元素
* each() 返回数组中当前的键／值对
* end() 将数组的内部指针指向最后一个元素
* extract() 从数组中将变量导入到当前的符号表
* in_array() 检查数组中是否存在指定的值
* key() 从关联数组中取得键名
* krsort() 对数组按照键名逆向排序
* ksort() 对数组按照键名排序
* list() 把数组中的值赋给一些变量
* natcasesort() 用“自然排序”算法对数组进行不区分大小写字母的排序
* natsort() 用“自然排序”算法对数组排序
* next() 将数组中的内部指针向前移动一位
* pos()current() 的别名
* prev() 将数组的内部指针倒回一位
* range() 创建包含指定范围单元的数组
* reset() 将数组的内部指针指向第一个元素
* rsort() 对数组逆向排序
* shuffle() 将数组打乱
* sizeof() count() 的别名
* sort() 对数组排序
*/
// array_change_key_case() 把数组中所有键更改为小写或大写(CASE_UPPER),默认为小写(CASE_LOWER)
$age=array("Bill"=>"Bill","Steve"=>"56","Mark"=>"31");
// print_r(array_change_key_case($age,CASE_UPPER));
// array_chunk($arr,$num) 把一个数组分割为新的数组块，一般用于一维数组，分割时重置键，针对二维及以上数组，不存在递归分割
$cars = array(array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45)
);
$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
// print_r(array_chunk($cars,2));
// array_column($arr,'column','index_key') 返回数组中某一个单列的值
$arr = array(
'dasd' =>array(
'id' => 5698,
'first_name' => 'Bill',
'last_name' => 'Gates',
),
'dassadasdasd' =>array(
'id' => 4767,
'first_name' => 'Steve',
'last_name' => 'Jobs',
),
'ddasdasdasasd' =>array(
'id' => 3809,
'first_name' => 'Mark',
'last_name' => 'Zuckerberg',
)
);
// 返回$arr中last_name的值并形成一个新数组
// print_r(array_column($arr,'last_name')); Array ( [0] => Gates [1] => Jobs [2] => Zuckerberg )
// 返回$arr中last_name的值并形成一个以id为键的新数组
// print_r(array_column($arr,'last_name','id')); Array ( [5698] => Gates [4767] => Jobs [3809] => Zuckerberg )
// 第二个参数为null时，返回原数组，重置数组键
// print_r(array_column($arr,null));
/*Array
(
[0] => Array
(
[id] => 5698
[first_name] => Bill
[last_name] => Gates
)
[1] => Array
(
[id] => 4767
[first_name] => Steve
[last_name] => Jobs
)
[2] => Array
(
[id] => 3809
[first_name] => Mark
[last_name] => Zuckerberg
)
)*/
// 第二个参数为null时，返回原数组，可配合第三个参数来重置数组键
// print_r(array_column($arr,null,'first_name'));
/*Array
(
[Bill] => Array
(
[id] => 5698
[first_name] => Bill
[last_name] => Gates
)
[Steve] => Array
(
[id] => 4767
[first_name] => Steve
[last_name] => Jobs
)
[Mark] => Array
(
[id] => 3809
[first_name] => Mark
[last_name] => Zuckerberg
)
)
*/
// array_combine($arr1,$arr2)
// 合并两个数组来创建一个新的数组，第一个数组为键，第二个数组为值 若数组个数不同，返回false
$fname=array("Bill","Steve","Mark");
$age=array("60","56","31");
$c=array_combine($fname,$age);
// print_r($c); // Array ( [Bill] => 60 [Steve] => 56 [Mark] => 31 )
// array_count_values($arr) 对数组中所有的值进行计数
$a=array("A","Cat","Dog","A","Dog");
// print_r(array_count_values($a)); // Array ( [A] => 2 [Cat] => 1 [Dog] => 2 )
// array_diff($arr1,$arr2[,$arr3]) 返回两个或以上数组的差集数组（其他数组与第一数组进行仅有值的比较）
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
// 比较a1与a2，返回a1中与a2不匹配的部分，结果不包括a2中的键值
// print_r(array_diff($a1,$a2)); // Array ( [b] => green [c] => blue [d] => yellow )
// 比较a1,a2与a3，返回a1中与a2,a3同时不匹配的部分，结果不包括a2,a3中的键值
// print_r(array_diff($a1,$a2,$a3)); // Array ( [b] => green [c] => blue )
// array_diff_assoc($a1,$a2,$a3...) 比较2个或以上数组的键与值并返回差集
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
// 条件：当键与值同时匹配
// print_r(array_diff_assoc($a1,$a2)); // Array ( [a] => red [b] => green [c] => blue [d] => yellow )
// array_diff_key($a1,$a2,$a3...) 比较两个或以上的数组的键，并返回差集
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
// print_r(array_diff_key($a1,$a2)); // Array ( [b] => green )
$a1=array("red","green","blue","yellow");
$a2=array("red","green","blue");
// print_r(array_diff_key($a1,$a2)); // Array ( [3] => yellow )
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
$a3=array("f"=>"green","c"=>"purple","g"=>"red");
// print_r(array_diff_key($a1,$a2,$a3)); // Array ( [a] => red [b] => green )
// array_fill(start_index, num, value) 從start_index索引開始，填充num條值為value形成新數組
// print_r(array_fill(5,3,'value')); // Array ( [5] => value [6] => value [7] => value )
// array_fill_keys(keys, value) 用指定鍵、值填充數組
$keys=array("a","b","c","d");
// print_r(array_fill_keys($keys,'blue')); // Array ( [a] => blue [b] => blue [c] => blue [d] => blue )
// array_filter($array[,'myfunction']) 使用自定义函数过滤数组中的元素，数组键名保持不变。若无自定义函数，则取出数组中为空、null的值
$a = [1,2,3,4,5,6,7,8,9,10];
// print_r(array_filter($a,function($a){ if($a > 5) { return $a; } }));
// array_flip(arr) 反转数组的键值，如果同一值出现了多次，则最后一个键名将作为它的值，所有其他的键名都将丢失。 如果原数组中的值的数据类型不是字符串或整数，函数将报错。
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
// print_r(array_flip($a1)); // Array ( [red] => a [green] => b [blue] => c [yellow] => d )
// array_intersect(array1, array2) 比较两个或以上的数组的值，并返回交集
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");
// print_r(array_intersect($a1, $a2)); // Array ( [a] => red [b] => green [c] => blue )
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"black","g"=>"purple");
$a3=array("a"=>"red","b"=>"black","h"=>"yellow");
// print_r(array_intersect($a1,$a2,$a3)); // Array ( [a] => red )
// array_intersect_assoc(array1, array2) 比较两个或以上的数组的键、值，并返回交集
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
// print_r(array_intersect_assoc($a1,$a2)); // Array ( [a] => red [b] => green [c] => blue )
// array_intersect_key($a1,$a2,$a3) 比较两个或以上的数组的键，并返回交集
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
// print_r(array_intersect_key($a1,$a2));
/*Array
(
[a] => red
[c] => blue
)
*/
// array_key_exists(key, array) 检查键是否存在于数组中，区分大小写
$a=array("Volvo"=>"XC90","BMW"=>"X5");
/*if (array_key_exists('Volvo',$a)) {
echo '键存在';
}else{
echo '键不存在';
}*/
/*$a=array("Volvo","BMW");
if (array_key_exists(0,$a))
{
echo "键存在！";
}
else
{
echo "键不存在！";
}*/
// array_keys(array,value,strict) 返回包含数组中所有键的一个新数组
$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
// print_r(array_keys($a));
/*Array
(
[0] => Volvo
[1] => BMW
[2] => Toyota
)*/
// 如果提供了第二个参数，则只返回键值为该值的键名,不存在返回空数组
// print_r(array_keys($a,'Highlander'));
/*Array
(
[0] => Toyota
)
*/
// 如果 strict 参数指定为 true，则 PHP 会使用全等比较 (===) 来严格检查键值的数据类型，默认false
$a=array(10,20,30,"10");
// print_r(array_keys($a,"10",false));
/*Array
(
[0] => 0
[1] => 3
)
*/
$a=array(10,20,30,"10");
// print_r(array_keys($a,"10",true));
/*Array
(
[0] => 3
)
*/
// array_map('function',arr) 函数将用户自定义函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新值的数组
// 回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致
$arr = ['20180000001/3.55','20180000044/3.55','20180005501/3.55','20144000001/3.55'];
// print_r(array_map(function($v){ return substr($v,0,11); },$arr));
/*Array
(
[0] => 20180000001
[1] => 20180000044
[2] => 20180005501
[3] => 20144000001
)
*/
$a1=array("Horse","Dog","Cat");
$a2=array("Cow","Dog","Rat");
// print_r(array_map(function($k,$v){ if($k === $v){ return 'same'; }else{ return 'diff'; } },$a1,$a2));
/*Array
(
[0] => diff
[1] => same
[2] => diff
)
*/
// print_r(array_map(function($v){ return strtoupper($v); }, $a1));
/*Array
(
[0] => HORSE
[1] => DOG
[2] => CAT
)
*/
// print_r(array_map(null,$a1,$a2)); 函数名赋值为null时，返回包含a1，a2的数组
// array_merge(array1,array2) 将两个数组或多个数组合并为一个数组
// 如果元素有相同的键，则最后的元素会覆盖其他元素
$a1=array("red","green");
$a2=array("blue","yellow");
// print_r(array_merge($a1,$a2));
/*Array
(
[0] => red
[1] => green
[2] => blue
[3] => yellow
)
*/
// 如果仅向函数输入一个数组，且键名是整数，将返回带有整数键名的新数组，键名以0开始进行重新索引
$a=array(3=>"red",4=>"green");
// print_r(array_merge($a));
/*Array
(
[0] => red
[1] => green
)
*/
// array_merge_recursive(array1,array2) 把一个或多个数组合并为一个数组
// 该函数与 array_merge() 函数的区别在于处理两个或更多个数组元素有相同的键名时,array_merge_recursive() 不会进行键名覆盖，而是将多个相同键名的值递归组成一个数组。
$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
// print_r(array_merge_recursive($a1,$a2));
/*Array
(
[a] => red
[b] => Array
(
[0] => green
[1] => yellow
)
[c] => blue
)
*/
// 如果仅向 array_merge_recursive() 函数输入一个数组，结果与 array_merge() 相同，函数将返回带有整数键名的新数组，键名以 0 开始进行重新索引
// array_multisort(arr) 函数返回排序数组，输入一个或多个数组，函数先对第一个数组进行排序，接着是其他数组，如果两个或多个值相同，它将对下一个数组进行排序
// 字符串键名将被保留，但是数字键名将被重新索引，从 0 开始，并以 1 递增
$a=array("Dog","Cat","Horse","Bear","Zebra");
array_multisort($a);
// print_r($a);
/*Array
(
[0] => Bear
[1] => Cat
[2] => Dog
[3] => Horse
[4] => Zebra
)
*/
// array_multisort(array1,sorting order,sorting type,array2,array3...)
/**
* array1 必需,规定数组
* sorting order 可选,规定排列顺序,SORT_ASC 默认，升序(A-Z);SORT_DESC 降序(Z-A)
* sorting type 可选,规定排序类型
* SORT_REGULAR - 默认,把每一项按常规顺序排列（Standard ASCII，不改变类型）
* SORT_NUMERIC - 把每一项作为数字来处理。
* SORT_STRING - 把每一项作为字符串来处理。
* SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
* SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
* SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写
*
*/
// 合并两个数组，并按数字降序排列
$a1=array(1,30,15,7,25);
$a2=array(4,30,20,41,66);
$num=array_merge($a1,$a2);
array_multisort($num,SORT_DESC,SORT_NUMERIC);
// print_r($num);
// 多维数组的排序
$arr = array(
array('name'=>'lisi','order'=>1),
array('name'=>'zhangsan','order'=>11),
array('name'=>'wangwu','order'=>111),
);
$arr1 = array_map(create_function('$n', 'return $n["order"];'), $arr);
array_multisort($arr1,SORT_DESC,$arr );
// print_r($arr);
/*Array
(
[0] => Array
(
[name] => wangwu
[order] => 13
)
[1] => Array
(
[name] => lisi
[order] => 12
)
[2] => Array
(
[name] => zhangsan
[order] => 4
)
)
*/
// array_pad(array,size,value) 向array中插入值为value直至array数组个数为size
$a=array("red","green");
// print_r(array_pad($a,5,"blue"));
/* Array
(
[0] => red
[1] => green
[2] => blue
[3] => blue
[4] => blue
)
*/
// size设置为负数，函数会在原始数组之前插入新的元素，小于原始数组的长度，函数不会删除任何元素
// print_r(array_pad($a,-5,"blue"));
/*Array
(
[0] => blue
[1] => blue
[2] => blue
[3] => red
[4] => green
)
*/
// array_pop(array) 删除数组中的最后一个元素
$a=array("red","green","blue");
array_pop($a); // 返回数组的最后一个值,如果数组是空的，或者非数组，将返回 NULL
// print_r($a);
/*Array
(
[0] => red
[1] => green
)
*/
// array_product(array) 计算并返回数组的乘积
$a=array(5,5,2,10);
// echo(array_product($a)); //500
// array_push(array, var) 向第一个参数的数组尾部添加一个或多个元素，然后返回新数组的长度
$a=array("red","green");
// 如果用 array_push() 来给数组增加一个单元，还不如用 $array[] =，因为这样没有调用函数的额外负担
$a[] = '';
// print_r($a);
/*Array
(
[0] => red
[1] => green
[2] =>
)*/
array_push($a,"blue","yellow");
// print_r($a);
/*Array
(
[0] => red
[1] => green
[2] =>
[3] => blue
[4] => yellow
)*/
// 即使数组中有字符串键名，添加的元素也始终是数字键
$a=array("a"=>"red","b"=>"green");
array_push($a,"blue","yellow");
// print_r($a);
// Array ( [a] => red [b] => green [0] => blue [1] => yellow )
// array_rand(arr,num);
$a=array("red","green","blue","yellow","brown");
$random_keys=array_rand($a,3);
// print_r($random_keys);
/*Array ([0] => 0 [1] => 2 [2] => 3 )
Array ([0] => 0 [1] => 1 [2] => 3 )
Array ([0] => 1 [1] => 2 [2] => 4 )*/
// ** array_reduce(arr, function,initial) 向用户自定义函数发送数组中的值，并返回一个字符串
function myfunction($v1,$v2)
{
// $v1 上次的值 $v2 本次的值
return $v1 . "-" . $v2;
}
$a=array("Dog","Cat","Horse");
// print_r(array_reduce($a,"myfunction")); //-Dog-Cat-Horse
// initial 规定发送到函数的初始值
$a=array("Dog","Cat","Horse");
// print_r(array_reduce($a,"myfunction",5)); //5-Dog-Cat-Horse
$a=array(10,15,20);
// print_r(array_sum($a)); // 45
// print_r(array_reduce($a,function($v1,$v2){ return $v1+$v2; },5)); // 50
// print_r(array_reduce($a,function($v1,$v2){ return $v1*$v2; },5)); // 15000
// print_r(array_product($a)); // 3000
// 2种方法:返回array('id'=>name)
$user = array(
0 => array(
'id' => 1,
'name' => '张三',
'email' => 'zhangsan@sina.com',
),
1 => array(
'id' => 2,
'name' => '李四',
'email' => 'lisi@163.com',
),
2 => array(
'id' => 5,
'name' => '王五',
'email' => '10000@qq.com',
)
);
foreach($user as $k=>$v){
$name2[$v['id']] = $v['name'];
}
// print_r($name2);
/*Array
(
[1] => 张三
[2] => 李四
[5] => 王五
)
*/
// print_r(array_reduce($user,function($v,$w){ $v[$w['id']] = $w['name'];return $v; }));
/*Array
(
[1] => 张三
[2] => 李四
[5] => 王五
)*/
// 将id作为键，重组数组
// print_r(array_column($user,null,'id'));
/*Array
(
[1] => Array
(
[id] => 1
[name] => 张三
[email] => zhangsan@sina.com
)
[2] => Array
(
[id] => 2
[name] => 李四
[email] => lisi@163.com
)
[5] => Array
(
[id] => 5
[name] => 王五
[email] => 10000@qq.com
)
)
*/
// array_replace(array, array1) 使用第二个数组的值替换第一个数组的值
$a1=array("red","green");
$a2=array("blue","yellow");
// print_r(array_replace($a1,$a2));
/*Array
(
[0] => blue
[1] => yellow
)*/
// 如果一个键存在于 array1 中同时也存在于 array2 中，第一个数组的值将被第二个数组中的值替换、新增
$a1=array("a"=>"red","b"=>"green");
$a2=array("a"=>"orange","burgundy");
// print_r(array_replace($a1,$a2));
/*Array
(
[a] => orange
[b] => green
[0] => burgundy
)
*/
// 如果一个键存在于第二个数组 array2，但是不存在于第一个数组 array1，则会在第一个数组 array1 中创建这个元素
$a1=array("a"=>"red","green");
$a2=array("a"=>"orange","b"=>"burgundy");
// print_r(array_replace($a1,$a2));
/*Array
(
[a] => orange
[0] => green
[b] => burgundy
)
*/
// 使用三个数组 - 最后一个数组（$a3）会覆盖之前的数组（$a1 和 $a2）
$a1=array("red","green");
$a2=array("blue","yellow");
$a3=array("orange","burgundy");
// print_r(array_replace($a1,$a2,$a3));
/*Array
(
[0] => orange
[1] => burgundy
)
*/
// 使用数值键 - 如果一个键存在于第二个数组中但不在第一个数组中
$a1=array("red","green","blue","yellow");
$a2=array(0=>"orange",3=>"burgundy");
// print_r(array_replace($a1,$a2));
/*Array
(
[0] => orange
[1] => green
[2] => blue
[3] => burgundy
)
*/
// array_replace_recursive(a1,a2) 递归地使用a2的值替换$a1的值
$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
// print_r(array_replace_recursive($a1,$a2));
/*Array
(
[a] => Array
(
[0] => yellow
)
[b] => Array
(
[0] => black
[1] => blue
)
)*/
$a1=array("a"=>array("red"),"b"=>array("green","blue"));
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$a3=array("a"=>array("orange"),"b"=>array("burgundy"));
// print_r(array_replace_recursive($a1,$a2,$a3));
/*Array
(
[a] => Array
(
[0] => orange
)
[b] => Array
(
[0] => burgundy
[1] => blue
)
)
*/
// array_replace() 与 array_replace_recursive() 的差别
$a1=array("a"=>array("red"),"b"=>array("green","blue"),);
$a2=array("a"=>array("yellow"),"b"=>array("black"));
$result=array_replace_recursive($a1,$a2);
// print_r($result);
/*Array
(
[a] => Array
(
[0] => yellow
)
[b] => Array
(
[0] => black
[1] => blue
)
)
*/
$result=array_replace($a1,$a2);
// print_r($result); // Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black ) )
// array_reverse(array1) 以相反的元素顺序返回数组
$a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
// print_r(array_reverse($a)); // Array ( [c] => Toyota [b] => BMW [a] => Volvo )
$a=array("Volvo","XC90",array("BMW","Toyota"));
// print_r($a);
// Array ( [0] => Volvo [1] => XC90 [2] => Array ( [0] => BMW [1] => Toyota ) )
$reverse=array_reverse($a);
// print_r($reverse);
// Array ([0] => Array ([0] => BMW [1] => Toyota ) [1] => XC90 [2] => Volvo )
$preserve=array_reverse($a,true);
// 第二个参数为true，保留原始键名
// print_r($preserve);
// Array ([2] => Array ([0] => BMW [1] => Toyota ) [1] => XC90 [0] => Volvo )
// array_search(needle, arr, strict) 函数在数组中搜索某个键值，并返回对应的键名
$a=array("a"=>"5","b"=>5,"c"=>"5");
// echo array_search(5,$a); // a
// echo array_search(5,$a,true); // b
// array_shift(arr) 函数删除数组中第一个元素，并返回被删除元素的值
$a=array("a"=>"red","b"=>"green","c"=>"blue");
// echo array_shift($a); // red
// print_r ($a); // Array ( [b] => green [c] => blue )
// array_slice(array,start,length,preserve) 在数组中根据条件取出一段值，并返回
/**
* array 必需,规定数组
* start 必需,数值,规定取出元素的开始位置, 0 = 第一个元素
* 如果该值设置为正数，则从前往后开始取
* 如果该值设置为负数，则从后向前取 start 绝对值, -2 意味着从数组的倒数第二个元素开始
*
* length 可选,数值,规定被返回数组的长度
* 如果该值设置为整数，则返回该数量的元素
* 如果该值设置为负数，则函数将在数组末端length远的地方终止取出
* 如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素
*
* preserve 可选,规定函数是保留键名还是重置键名,可能的值：
* true - 保留键名
* false - 默认,重置键名
* return 返回数组中的选定部分
*/
$a=array("red","green","blue","yellow","brown");
// print_r(array_slice($a,2)); //Array ([0] => blue [1] => yellow [2] => brown )
// print_r(array_slice($a,1,2)); // Array ([0] => green [1] => blue )
// print_r(array_slice($a,-2,1)); //Array ([0] => yellow )
// print_r(array_slice($a,1,2,true)); // Array ([1] => green [2] => blue )
// 如果数组有字符串键，所返回的数组将保留键名
$a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"brown");
// print_r(array_slice($a,1,2)); // Array ([b] => green [c] => blue )
$a=array("0"=>"red","1"=>"green","2"=>"blue","3"=>"yellow","4"=>"brown");
// print_r(array_slice($a,1,2)); //Array ([0] => green [1] => blue )
// array_splice(array,start,length,array) 从数组中移除元素，并用新元素取代它
/**
* array 必需,规定数组
* start 必需,数值,规定删除元素的开始位置
* 0 = 第一个元素
* 如果该值设置为正数，则从数组中该值指定的偏移量开始移除
* 如果该值设置为负数，则从数组末端倒数该值指定的偏移量开始移除
* -2 意味着从数组的倒数第二个元素开始
* length 可选,数值,规定被移除的元素个数，也是被返回数组的长度
* 如果该值设置为正数，则移除该数量的元素
* 如果该值设置为负数，则移除从 start 到数组末端倒数 length 为止中间所有的元素
* 如果该值未设置，则移除从 start 参数设置的位置开始直到数组末端的所有元素
* array 可选,规定带有要插入原始数组中元素的数组
* 如果只有一个元素，则可以设置为字符串，不需要设置为数组
* return 返回由被提取元素组成的数组
*/
// 返回由被提取元素组成的数组
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"purple","b"=>"orange");
// print_r(array_splice($a1,0,2,$a2)); // Array ([a] => red [b] => green )
array_splice($a1,0,2,$a2);
// print_r($a1); // Array ([0] => purple [1] => orange [c] => blue [d] => yellow )
array_splice($a1,1,0,$a2);
// print_r($a1);
// Array ([a] => red [0] => purple [1] => orange [b] => green [c] => blue [d] => yellow )
// array_sum($arr) // 返回数组中所有值的和
// array_unique($a1) 删除数组中的重复值。
$a=array("a"=>"red","b"=>"green","c"=>"red");
// print_r(array_unique($a)); // Array ([a] => red [b] => green )
// array_unshift(array, var) 将var插入到array开头
array_unshift($a, 'blue');
// print_r($a); // Array ([0] => blue [a] => red [b] => green [c] => red )
// array_values(arr) 返回数组的所有值
$a=array("Name"=>"Bill","Age"=>"60","Country"=>"USA");
// print_r(array_values($a)); // Array ([0] => Bill [1] => 60 [2] => USA )
// array_walk(array,myfunction,userdata...) 对数组中的每个元素应用用户自定义函数
$a=array("a"=>"red","b"=>"green","c"=>"blue");
// array_walk($a,function($v,$k){ echo "The key $k has the value $v \n"; });
/*The key a has the value red
The key b has the value green
The key c has the value blue*/
// 设置一个参数
// array_walk($a,function($v,$k,$p){ echo "$k $p $v \n"; },'has the value');
/*a has the value red
b has the value green
c has the value blue
*/
// 更改一个数组元素的值（请注意 &$value）
array_walk($a,function(&$v){ $v='555'; });
// print_r($a); Array ([a] => 555 [b] => 555 [c] => 555 )
// array_walk_recursive(input, funcname) 对数组中的每个元素应用用户自定义函数
function myfunctions($value,$key)
{
echo "键 $key 的值是 $value 。\n";
}
$a1=array("a"=>"red","b"=>"green");
$a2=array($a1,"1"=>"blue","2"=>"yellow");
// array_walk_recursive($a2,"myfunctions");
/*键 a 的值是 red 。
键 b 的值是 green 。
键 1 的值是 blue 。
键 2 的值是 yellow 。
*/
$age=array("Steve"=>"56","Bill"=>"60","Mark"=>"31");
sort($age); // 按照值对关联数组进行升序排序,不保持索引关系
// print_r($age); Array ([0] => 31 [1] => 56 [2] => 60 )
asort($age); // 按照值对关联数组进行升序排序,保持索引关系
// print_r($age); Array ([Mark] => 31 [Steve] => 56 [Bill] => 60 )
rsort($age); // 按照值对关联数组进行降序排序,不保持索引关系
// print_r($age); Array ([0] => 60 [1] => 56 [2] => 31 )
arsort($age); // 按照值对关联数组进行降序排序,保持索引关系
// print_r($age);Array ([Bill] => 60 [Steve] => 56 [Mark] => 31 )
ksort($age); // 按照键对关联数组进行升序排序,保持索引关系
// print_r($age); Array ([Bill] => 60 [Mark] => 31 [Steve] => 56 )
krsort($age); // 按照键对关联数组进行降序排序,保持索引关系
// print_r($age); Array ([Steve] => 56 [Mark] => 31 [Bill] => 60 )
// compact(var1,var2...) 创建一个包含变量名和它们的值的数组
$firstname = "Bill";
$lastname = "Gates";
$age = "60";
$result = compact("firstname", "lastname", "age");
// print_r($result);Array ([firstname] => Bill [lastname] => Gates [age] => 60 )
// 使用不匹配变量的字符串，以及一个变量名数组：
$name = array("firstname", "lastname");
$result = compact($name, "location", "age");
// print_r($result);Array ([firstname] => Bill [lastname] => Gates [age] => 60 )
// count(array,mode) // 返回数组中元素的数目,mode为1时计算多维数组中的所有元素
$cars=array("Volvo","BMW","Toyota");
// echo count($cars); //3
$people = array("Bill", "Steve", "Mark", "David");
// echo current($people) . "\n"; // 当前元素是 Bill
// echo next($people) . "\n"; // Bill 的下一个元素是 Steve
// echo current($people) . "\n"; // 现在当前元素是 Steve
// echo prev($people) . "\n"; // Steve 的上一个元素是 Bill
// echo end($people) . "\n"; // 最后一个元素是 David
// echo prev($people) . "\n"; // David 之前的元素是 Mark
// echo current($people) . "\n"; // 目前的当前元素是 Mark
// echo reset($people) . "\n"; // 把内部指针移动到数组的首个元素，即 Bill
// echo next($people) . "\n"; // Bill 的下一个元素是 Steve
// print_r (each($people)); // 返回当前元素的键名和键值（目前是 Steve），并向前移动内部指针
$a = "Original";
$my_array = array("a" => "Cat", "b" => "Dog", "c" => "Horse");
extract($my_array, EXTR_PREFIX_SAME, "dup");
// echo "\$a = $a; \$b = $b; \$c = $c; \$dup_a = $dup_a \n";
// in_array(search,array,type) 搜索数组中是否存在指定的值
/*search 必需,规定要在数组搜索的值
array 必需,规定要搜索的数组
type 可选,如果设置该参数为 true，则检查搜索的数据与数组的值的类型是否相同*/
// list() 将数组中的值赋给一些变量
$my_array = array("Dog","Cat","Horse");
list($a, $b, $c) = $my_array;
// echo "I have several animals, a $a, a $b and a $c.";
// I have several animals, a Dog, a Cat and a Horse.
list($a, , $c) = $my_array;
// echo "我在这里只用了 $a 和 $c 变量。";
// 我在这里只用了 Dog 和 Horse 变量。
// natcasesort() 函数用"自然排序"算法对数组进行排序，键值保留它们原始的键名
$temp_files = array("temp15.txt","Temp10.txt", "temp1.txt","Temp22.txt","temp2.txt");
natsort($temp_files);
// echo "自然排序："; print_r($temp_files); echo "\n";
// 自然排序：Array ([1] => Temp10.txt [3] => Temp22.txt [2] => temp1.txt [4] => temp2.txt [0] => temp15.txt )
natcasesort($temp_files);
// echo "不区分大小写的自然排序："; print_r($temp_files);echo "\n";
// 不区分大小写的自然排序：Array ([2] => temp1.txt [4] => temp2.txt [1] => Temp10.txt [0] => temp15.txt [3] => Temp22.txt )
// range(low,high,step) 返回包含从 low 到 high , step步长的元素的数组
$letter = range("a","d");
// print_r ($letter); Array ([0] => a [1] => b [2] => c [3] => d )
$number = range(1,50,10);
// print_r ($number); Array ([0] => 1 [1] => 11 [2] => 21 [3] => 31 [4] => 41 )
// shuffle() 把数组中的元素按随机顺序重新排列
$my_array = array("red","green","blue","yellow","purple");
shuffle($my_array);
// print_r($my_array); Array ([0] => yellow [1] => purple [2] => red [3] => green [4] => blue )
$my_array = array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"purple");
shuffle($my_array);
// print_r($my_array); Array ([0] => yellow [1] => red [2] => blue [3] => purple [4] => green )
// sizeof() count() 的别名
// 重置数组键的几种方法：
array_column($arr,null);
// 配合first_name的值重置数组键
array_column($arr,null,'first_name');
// 键名是整数,重置数组键
array_merge($arr);
array_merge_recursive($arr);
类似资料：