原文来自：http://www.cnblogs.com/sows/p/6045699.html （博客园的）风马一族 侵犯版本，后果自负 2016-11-09 15:56:26
数组 函数
php--数组的尝鲜事例
-
array_change_key_case — 返回字符串键名全为小写或大写的数组
语法：array_change_key_case(数组名);
- php-->修改数组的键名（下标）的字母大小写
array_chunk — 将一个数组分割成多个
语法：array_chunk(数组名,设置数组的长度);
php--将数组划分成若干个数组
- array_column — 返回数组中指定的一列
待定
- array_combine — 创建一个数组，用一个数组的值作为其键名，另一个数组的值作为其值
- php--数组的元素充当另个数组的键名
- array_count_values — 统计数组中所有的值出现的次数
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(23,324,32,45,645,6,56,23,5,5,56,54,65,7,5,45,63,45,34
); //统计数组中各个元素的出现数量
var_dump(array_count_values($arr));
?> 结果：
array(13) {
[23]=>
int(2)
[324]=>
int(1)
[32]=>
int(1)
[45]=>
int(3)
[645]=>
int(1)
[6]=>
int(1)
[56]=>
int(2)
[5]=>
int(3)
[54]=>
int(1)
[65]=>
int(1)
[7]=>
int(1)
[63]=>
int(1)
[34]=>
int(1)
}php--统计各个元素在数组中出现的次数
-
array_diff_assoc — 带索引检查计算数组的差集
- php--两个数组相减
-
array_diff_key — 使用键名比较计算数组的差集
- php--通过数组的下标进行减法运算，计算出不同下标或不同值
-
array_diff_uassoc — 用用户提供的回调函数做索引检查来计算数组的差集
- php--使用回调函数来处理两个数组的减法
-
array_diff_ukey — 用回调函数对键名比较计算数组的差集
- php--使用回调函数，两个函数间不同的下标
-
array_diff — 计算数组的差集
- php--两个数组是减法运算
-
array_fill_keys — 使用指定的键和值填充数组
- php--关系一对多，数组的每个元素，对应另个数组的所有元素
-
array_fill — 用给定的值填充数组
- 语法 array_fill(索引的位置起始，数量，元素的值)
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(111,222,333);
$arr2 = array(111,222,333); var_dump(array_fill(0,2,'a'));
?> 结果：
array(2) {
[0]=>
string(1) "a"
[1]=>
string(1) "a"
}php--给数组提供若干个相同的元素
-
array_filter — 用回调函数过滤数组中的单元- 语法：array_filter(数组名, 回调函数)
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(
254235,34,534,654,75,8,9,677,423,5,7,6435,43543,4,5,7,65,765,3
); var_dump(array_filter($arr,'odd')); function odd($var){
return($var & 0);
}
?> 结果：
//return($var & 0);
array(0) { } //return($var & 1);
array(14) {
[0]=>
int(254235)
[4]=>
int(75)
[6]=>
int(9)
[7]=>
int(677)
[8]=>
int(423)
[9]=>
int(5)
[10]=>
int(7)
[11]=>
int(6435)
[12]=>
int(43543)
[14]=>
int(5)
[15]=>
int(7)
[16]=>
int(65)
[17]=>
int(765)
[18]=>
int(3)
} //return($var & 2);
array(11) {
[0]=>
int(254235)
[1]=>
int(34)
[2]=>
int(534)
[3]=>
int(654)
[4]=>
int(75)
[8]=>
int(423)
[10]=>
int(7)
[11]=>
int(6435)
[12]=>
int(43543)
[15]=>
int(7)
[18]=>
int(3)
}php--过滤数组中的某些元素
-
array_flip — 交换数组中的键和值- 语法：array_flip(数组名);
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(
'name'=>'sows',
'sex'=>'mm',
'age'=>'23'
); var_dump(array_flip($arr));
?> 结果：
array(3) {
["sows"]=>
string(4) "name"
["mm"]=>
string(3) "sex"
[23]=>
string(3) "age"
}php--数组中的键名与元素进行位置调换
-
array_intersect_assoc — 带索引检查计算数组的交集- 语法：array_intersect_assoc(数组1,数组2,数组3.......);
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
'name'=>'sows','age'=>'23','sex'=>'mm'
); $arr2 = array(
'age'=>'23','sex'=>'mm','name'=>'sows'
); var_dump(array_intersect_assoc($arr1,$arr2)); ?> 结果：
array(3) {
["name"]=>
string(4) "sows"
["age"]=>
string(2) "23"
["sex"]=>
string(2) "mm"
} =============================
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
'name'=>'sows','age'=>'23','sex'=>'mm'
); $arr2 = array(
'a1ge'=>'23','sex'=>'m1m','name'=>'sows'
); $arr3 = array(
'age'=>'23','sex'=>'mm','name'=>'sows'
); var_dump(array_intersect_assoc($arr1,$arr2,$arr3)); ?> 结果：
array(1) {
["name"]=>
string(4) "sows"
}php--根据索引，对多个数组进行判断，寻找相同的索引的相同元素
-
array_intersect_key — 使用键名比较计算数组的交集- 语法：array_intersect_key(数组1，数组2，数组3.。。。。。。。。);
- 说明：获取所有数组中，相同的键名，然后键名对应的元素，由第一个数组的元素来提供，元素排序由第一数组决定
<?php //设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
'name'=>'苏俄',
'age'=>'34',
'sex'=>'mm'
); $arr2 = array(
'name'=>'苏俄',
'age'=>'342',
'sex'=>'mm'
); $arr3 = array(
'name'=>'苏俄','sex'=>'mm',
'age'=>'342' ); var_dump(array_intersect_key($arr1,$arr2));
var_dump(array_intersect_key($arr2,$arr1));
var_dump(array_intersect_key($arr3,$arr1,$arr2));
var_dump(array_intersect_key($arr3,$arr2,$arr1)); ?> 结果：
array(3) {
["name"]=>
string(6) "苏俄"
["age"]=>
string(2) "34"
["sex"]=>
string(2) "mm"
}
array(3) {
["name"]=>
string(6) "苏俄"
["age"]=>
string(3) "342"
["sex"]=>
string(2) "mm"
}
array(3) {
["name"]=>
string(6) "苏俄"
["sex"]=>
string(2) "mm"
["age"]=>
string(3) "342"
}
array(3) {
["name"]=>
string(6) "苏俄"
["sex"]=>
string(2) "mm"
["age"]=>
string(3) "342"
}php-求数组间的交集
-
array_intersect_uassoc — 带索引检查计算数组的交集，用回调函数比较索引- 语法：array_intersect_uassoc(数组一，数组二。。。。。，回调函数)
- 说明：求多个数组间的交集，并使用回调函数（自定义）
<?php //设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
'name'=>'sows',
'age'=>'25',
'sex'=>'mm'
); $arr2 = array(
'name'=>'sows',
'age'=>'25',
'sex'=>'mm'
); $arr3 = array(
'name'=>'sows',
'age'=>'215',
'sex'=>'mm'
); var_dump(array_intersect_uassoc($arr1,$arr2,'fun')); var_dump(array_intersect_uassoc($arr1,$arr2,$arr3,'fun')); function fun($a,$b){
if($a > $b){
return 1;
}elseif($a <$b){
return -1;
}else{
return 0;
}
} ?> 结果：
//array_intersect_uassoc($arr1,$arr2,'fun')
array(3) {
["name"]=>
string(4) "sows"
["age"]=>
string(2) "25"
["sex"]=>
string(2) "mm"
} //array_intersect_uassoc($arr1,$arr2,$arr3,'fun')
array(2) {
["name"]=>
string(4) "sows"
["sex"]=>
string(2) "mm"
}php--使用回调函数，获取数组间的交集
-
array_intersect_ukey — 用回调函数比较键名来计算数组的交集- 语法：array_intersect_ukey(数组1，数组2，数组3.。。。。，回调函数)
- 说明：使用回调函数，获取所有数组中，相同的键名，然后键名对应的元素，由第一个数组的元素来提供，元素排序由第一数组决定
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
'name'=>'楼主',
'age'=>'15',
'sex'=>'GG'
); $arr2 = array(
'name'=>'楼主',
'sex'=>'GGM',
'age'=>'15' ); var_dump(array_intersect_ukey($arr2,$arr1,'fun')); function fun($a,$b){
if($a > $b){
return 1;
}elseif($a <$b){
return -1;
}else{
return 0;
}
}
?> 结果：array(3) {
["name"]=>
string(6) "楼主"
["sex"]=>
string(3) "GGM"
["age"]=>
string(2) "15"
}php--使用回调函数，根据数组间的键名比较，获取相同键名的元素，元素的值由第一个数组决定
-
array_intersect — 计算数组的交集- 语法：array_intersect(数组1，数组2，数组3.。。。。);
- 说明：从多个数组中，获取相同的元素
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(1,2,3,4,5,6);
$arr2 = array(1,2,31,4,51,6); var_dump(array_intersect($arr1,$arr1));
var_dump(array_intersect($arr1,$arr2));
var_dump(array_intersect($arr2,$arr1)); ?> 结果：
array(6) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
[5]=>
int(6)
}
array(4) {
[0]=>
int(1)
[1]=>
int(2)
[3]=>
int(4)
[5]=>
int(6)
}
array(4) {
[0]=>
int(1)
[1]=>
int(2)
[3]=>
int(4)
[5]=>
int(6)
}php--获取多个数组间的相同元素
-
array_key_exists — 检查给定的键名或索引是否存在于数组中- 语法：array_key_exists(键名,数组名);
- 说明：在数组中搜索键名, 若存在返回true;若不存在返回false
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
'name'=>'sows',
'age'=>15,
'sex'=>'mm'
); var_dump(array_key_exists('name',$arr1));
var_dump(array_key_exists('sex1',$arr1)); ?> 结果：
bool(true)
bool(false)php--在数组中搜索键名
-
array_keys — 返回数组中部分的或所有的键名- 语法：array_keys(数组) array_keys(数组，元素);
- 说明：获取数组的键名
- php--输出数组的所有键名或部分键名
-
array_map — 将回调函数作用到给定数组的单元上- 语法：array_map(回调函数，数组);
- 说明：使用回调函数，对数组中的每个元素进行处理
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(
'name'=>'楼主',
'age'=>'15',
'sex'=>'GG'
); var_dump(array_map('fun',$arr)); function fun($a){
return $a.=' 你好';
}
?> 结果：
array(3) {
["name"]=>
string(13) "楼主 你好"
["age"]=>
string(9) "15 你好"
["sex"]=>
string(9) "GG 你好"
}php--回调函数对数组的所有元素进行处理
-
array_merge_recursive — 递归地合并一个或多个数组 （ 与array_merge 的效果，有问题）- 语法：array_merge_recursive(数组一，数组二，数组三。。。。。。。);
- 说明：多个数组间的头尾相连，形成大的数组
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(1,2,3,4,5,6,7,8,9,0);
$arr2 = array('a','b','c','d','e','f','g','h','j','n');
$arr3 = array('A','B','C','D','E','F','G','H','J','N'); var_dump(array_merge_recursive($arr1,$arr2)); var_dump(array_merge_recursive($arr2,$arr1)); var_dump(array_merge_recursive($arr1,$arr2,$arr3)); ?> 结果：
//array_merge_recursive($arr1,$arr2)
array(20) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
[5]=>
int(6)
[6]=>
int(7)
[7]=>
int(8)
[8]=>
int(9)
[9]=>
int(0)
[10]=>
string(1) "a"
[11]=>
string(1) "b"
[12]=>
string(1) "c"
[13]=>
string(1) "d"
[14]=>
string(1) "e"
[15]=>
string(1) "f"
[16]=>
string(1) "g"
[17]=>
string(1) "h"
[18]=>
string(1) "j"
[19]=>
string(1) "n"
} //array_merge_recursive($arr2,$arr1)
array(20) {
[0]=>
string(1) "a"
[1]=>
string(1) "b"
[2]=>
string(1) "c"
[3]=>
string(1) "d"
[4]=>
string(1) "e"
[5]=>
string(1) "f"
[6]=>
string(1) "g"
[7]=>
string(1) "h"
[8]=>
string(1) "j"
[9]=>
string(1) "n"
[10]=>
int(1)
[11]=>
int(2)
[12]=>
int(3)
[13]=>
int(4)
[14]=>
int(5)
[15]=>
int(6)
[16]=>
int(7)
[17]=>
int(8)
[18]=>
int(9)
[19]=>
int(0)
} //array_merge_recursive($arr1,$arr2,$arr3))
array(30) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
[5]=>
int(6)
[6]=>
int(7)
[7]=>
int(8)
[8]=>
int(9)
[9]=>
int(0)
[10]=>
string(1) "a"
[11]=>
string(1) "b"
[12]=>
string(1) "c"
[13]=>
string(1) "d"
[14]=>
string(1) "e"
[15]=>
string(1) "f"
[16]=>
string(1) "g"
[17]=>
string(1) "h"
[18]=>
string(1) "j"
[19]=>
string(1) "n"
[20]=>
string(1) "A"
[21]=>
string(1) "B"
[22]=>
string(1) "C"
[23]=>
string(1) "D"
[24]=>
string(1) "E"
[25]=>
string(1) "F"
[26]=>
string(1) "G"
[27]=>
string(1) "H"
[28]=>
string(1) "J"
[29]=>
string(1) "N"
}php--多个数组间相连成大的数组
-
array_merge — 合并一个或多个数组- 语法：array_merge(数组1，数组2，数组3.。。。。。。。)；
- 说明:
-
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(1,2,3,4,5,6,7,8,9,0);
$arr2 = array('a','b','c','d','e','f','g','h','j','n');
$arr3 = array('A','B','C','D','E','F','G','H','J','N'); var_dump(array_merge($arr1,$arr2));
var_dump(array_merge($arr2,$arr1));
var_dump(array_merge($arr1,$arr2,$arr3)); $arr4 = array('name1'=>1,'name2'=>2,'name3'=>3,'name4'=>4);
$arr5 = array('name1'=>1,'name2'=>2,'name3'=>3,'name4'=>4); var_dump(array_merge_recursive($arr4,$arr5));
?> 结果：
array(20) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
[5]=>
int(6)
[6]=>
int(7)
[7]=>
int(8)
[8]=>
int(9)
[9]=>
int(0)
[10]=>
string(1) "a"
[11]=>
string(1) "b"
[12]=>
string(1) "c"
[13]=>
string(1) "d"
[14]=>
string(1) "e"
[15]=>
string(1) "f"
[16]=>
string(1) "g"
[17]=>
string(1) "h"
[18]=>
string(1) "j"
[19]=>
string(1) "n"
}
array(20) {
[0]=>
string(1) "a"
[1]=>
string(1) "b"
[2]=>
string(1) "c"
[3]=>
string(1) "d"
[4]=>
string(1) "e"
[5]=>
string(1) "f"
[6]=>
string(1) "g"
[7]=>
string(1) "h"
[8]=>
string(1) "j"
[9]=>
string(1) "n"
[10]=>
int(1)
[11]=>
int(2)
[12]=>
int(3)
[13]=>
int(4)
[14]=>
int(5)
[15]=>
int(6)
[16]=>
int(7)
[17]=>
int(8)
[18]=>
int(9)
[19]=>
int(0)
}
array(30) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
[3]=>
int(4)
[4]=>
int(5)
[5]=>
int(6)
[6]=>
int(7)
[7]=>
int(8)
[8]=>
int(9)
[9]=>
int(0)
[10]=>
string(1) "a"
[11]=>
string(1) "b"
[12]=>
string(1) "c"
[13]=>
string(1) "d"
[14]=>
string(1) "e"
[15]=>
string(1) "f"
[16]=>
string(1) "g"
[17]=>
string(1) "h"
[18]=>
string(1) "j"
[19]=>
string(1) "n"
[20]=>
string(1) "A"
[21]=>
string(1) "B"
[22]=>
string(1) "C"
[23]=>
string(1) "D"
[24]=>
string(1) "E"
[25]=>
string(1) "F"
[26]=>
string(1) "G"
[27]=>
string(1) "H"
[28]=>
string(1) "J"
[29]=>
string(1) "N"
}
array(4) {
["name1"]=>
array(2) {
[0]=>
int(1)
[1]=>
int(1)
}
["name2"]=>
array(2) {
[0]=>
int(2)
[1]=>
int(2)
}
["name3"]=>
array(2) {
[0]=>
int(3)
[1]=>
int(3)
}
["name4"]=>
array(2) {
[0]=>
int(4)
[1]=>
int(4)
}
}php--多个数组间的头尾相连
-
array_multisort — 对多个数组或多维数组进行排序- 语法：array_multisort(数组1，数组2，数组3.。。。。。，排序顺序|排序类型)
- 排序顺序标志：
-
SORT_ASC- 按照上升顺序排序（默认值，即不填时，默认使用它） -
SORT_DESC- 按照下降顺序排序
-
- 排序类型标志：
-
SORT_REGULAR- 将项目按照通常方法比较（默认值，即不填时，默认使用它） -
SORT_NUMERIC- 将项目按照数值比较 -
SORT_STRING- 将项目按照字符串比较
-
- 排序顺序标志：
- 说明：
- 两种排序方式：用键名进行排序 | 用元素进行排序
- 数组排序前后的顺序会发生改变
- 可以同时对多个数组进行排序，排序只针对一个数组内部的元素，即数组间不会相互影响，
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr1 = array(
324,32,5345,6,788,6,78,79,98786,78897
); array_multisort($arr1,SORT_STRING);
var_dump($arr1);
array_multisort($arr1,SORT_NUMERIC );
var_dump($arr1); $arr2 = array(
'a'=>3324,'d'=>3432,'f'=>435436,'c'=>8723,'g'=>645
);
array_multisort($arr2,SORT_NUMERIC ); //默认式，按元素，从小到大排序
var_dump($arr2);
array_multisort($arr2,SORT_STRING); //按键名，从小到大排序(默认：SORT_ASC)
var_dump($arr2);
array_multisort($arr2,SORT_NUMERIC ); //按元素，从小到大排序(默认：SORT_ASC)
var_dump($arr2); //修改显示的顺序
array_multisort($arr2,SORT_NUMERIC,SORT_ASC); //按元素，从小到大排序
var_dump($arr2);
array_multisort($arr2,SORT_NUMERIC,SORT_DESC); //按元素，从大到小排序
var_dump($arr2); ?> 结果：
array(10) {
[0]=>
int(32)
[1]=>
int(324)
[2]=>
int(5345)
[3]=>
int(6)
[4]=>
int(6)
[5]=>
int(78)
[6]=>
int(788)
[7]=>
int(78897)
[8]=>
int(79)
[9]=>
int(98786)
}
array(10) {
[0]=>
int(6)
[1]=>
int(6)
[2]=>
int(32)
[3]=>
int(78)
[4]=>
int(79)
[5]=>
int(324)
[6]=>
int(788)
[7]=>
int(5345)
[8]=>
int(78897)
[9]=>
int(98786)
}
array(5) {
["g"]=>
int(645)
["a"]=>
int(3324)
["d"]=>
int(3432)
["c"]=>
int(8723)
["f"]=>
int(435436)
}
array(5) {
["a"]=>
int(3324)
["d"]=>
int(3432)
["f"]=>
int(435436)
["g"]=>
int(645)
["c"]=>
int(8723)
}
array(5) {
["g"]=>
int(645)
["a"]=>
int(3324)
["d"]=>
int(3432)
["c"]=>
int(8723)
["f"]=>
int(435436)
}
array(5) {
["g"]=>
int(645)
["a"]=>
int(3324)
["d"]=>
int(3432)
["c"]=>
int(8723)
["f"]=>
int(435436)
}
array(5) {
["f"]=>
int(435436)
["c"]=>
int(8723)
["d"]=>
int(3432)
["a"]=>
int(3324)
["g"]=>
int(645)
}php--对数组按某种方式进行排序
- 语法：array_multisort(数组1，数组2，数组3.。。。。。，排序顺序|排序类型)
-
array_pad — 用值将数组填补到指定长度- 语法：array_pad(数组名,设置数组长度，要增添的元素)
- 1.设置数组长度不超过数组的原先长度，都才有意义
- 2.如果对数组会有删除操作，空余的位置，由增添元素处理，或许有意义
- 说明：给数组增加若干个相同的元素
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(
1,2,5
); //设置数组的长度为10，当原先数组的长度不够10时，剩余的位置由2填充
print_r(array_pad($arr,10,2)); //设置数组的长度为2，当原先数组的长度超过设置的数组长度，则保持不变
print_r(array_pad($arr,2,2)); //设置数组的长度为10，当原先数组的长度不够5时，剩余的位置由3填充
print_r(array_pad($arr,5,3)); ?> 结果：
Array
(
[0] => 1
[1] => 2
[2] => 5
[3] => 2
[4] => 2
[5] => 2
[6] => 2
[7] => 2
[8] => 2
[9] => 2
)
Array
(
[0] => 1
[1] => 2
[2] => 5
)
Array
(
[0] => 1
[1] => 2
[2] => 5
[3] => 3
[4] => 3
)ohp--给数组增添若干个相同的元素
- 语法：array_pad(数组名,设置数组长度，要增添的元素)
-
array_pop — 将数组最后一个单元弹出（出栈）- 语法：array_pop(数组);
- 说明：栈结构：先进后出，用数组作栈结构，元素的进出都在数组尾巴进行
-
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(1,2,3,4,5,6,7,8,9,10); var_dump(array_pop($arr));
var_dump(array_pop($arr));
print_r(array_pop($arr)); ?> 结果：
10
9
8php--移出数组的最后一个元素
-
array_product — 计算数组中所有值的乘积- 语法：array_product(数组);
- 说明：对纯数字的数组进行相乘，用字符串表示的数字也可以接受
-
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; //对数组的数字进行相乘
$arr = array(1,2,3,4,5,6,7,8,9);
var_dump(array_product($arr)); //用字符串表示的数字，同样可以参与运算
$arr = array(1,2,3,4,5,6,7,8,9,'323');
var_dump(array_product($arr)); //对非数字的字符，不起作用
$arr = array(1,2,3,4,5,6,7,8,9,'a3');
var_dump(array_product($arr));
?> 结果：
int(362880)
int(117210240)
int(0)php--对纯数字的数组进行相乘
-
array_push — 将一个或多个单元压入数组的末尾（入栈）- 语法：array_push(数组，要添加的元素);
- 说明：栈结构：先进后出，用数组作栈结构，元素的进出都在数组尾巴进行
-
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(1,2,3,4,5,6,7,8,9,10); var_dump(array_push($arr,11));
var_dump(array_push($arr,12));
var_dump(array_push($arr,13)); print_r($arr);
?> 结果：
int(11)
int(12)
int(13)
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
[5] => 6
[6] => 7
[7] => 8
[8] => 9
[9] => 10
[10] => 11
[11] => 12
[12] => 13
)php--向数组的尾巴添加元素
-
array_rand — 从数组中随机取出一个或多个单元- 语法：array_rand(数组，产生数字的长度); //长度不能超过数组的长度
- 说明：用数组产生随机数
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(1,2,3,4,5,6,7,8,9,0); //随机获取一个元素
var_dump(array_rand($arr)); //随机获取二个元素
var_dump(array_rand($arr,2)); //随机获取三个元素
var_dump(array_rand($arr,3)); ?> 结果：
//随机产生一个数字
int(5) //随机产生二个数字
array(2) {
[0]=>
int(2)
[1]=>
int(7)
} //随机产生三个数字
array(3) {
[0]=>
int(0)
[1]=>
int(7)
[2]=>
int(9)
}php--从数组中随机产生数字
-
array_reduce — 用回调函数迭代地将数组简化为单一的值- 语法：array_reduce(数组名,回调函数的名); //回调函数的写法，自己订
- 说明：把数组的元素，转化成一个值
-
<?php
//设置文件的编码为 utf-8,以便识别中文
header('Content-type:text/html;charset=utf-8'); //让结果，按原先的格式输出
echo '<pre>'; $arr = array(234,32,4,25,34,543,643,6,43543); //=================================================
//让数组通过回调函数，进行处理
var_dump(array_reduce($arr,'fun')); //使用回调函数，对元素进行相加
function fun($a, $b){ $a += $b;
return $a;
}
//===============================================
//使用回调函数，对元素进行相加，并添加数字
var_dump(array_reduce($arr,'fun1',100)); //使用回调函数，对元素进行相加
function fun1($a, $b){ $a += $b;
return $a;
}
?> 结果：
int(45064)
int(45164)php--数组通过回调函数进行处理，化成一个数字
-
array_replace_recursive — 使用传递的数组递归替换第一个数组的元素- 语法：
- 说明：
- array_replace — 使用传递的数组替换第一个数组的元素
- array_reverse — 返回一个单元顺序相反的数组
- array_search — 在数组中搜索给定的值，如果成功则返回相应的键名
- array_shift — 将数组开头的单元移出数组
- array_slice — 从数组中取出一段
- array_splice — 把数组中的一部分去掉并用其它值取代
- array_sum — 计算数组中所有值的和
- array_udiff_assoc — 带索引检查计算数组的差集，用回调函数比较数据
- array_udiff_uassoc — 带索引检查计算数组的差集，用回调函数比较数据和索引
- array_udiff — 用回调函数比较数据来计算数组的差集
- array_uintersect_assoc — 带索引检查计算数组的交集，用回调函数比较数据
- array_uintersect_uassoc — 带索引检查计算数组的交集，用回调函数比较数据和索引
- array_uintersect — 计算数组的交集，用回调函数比较数据
- array_unique — 移除数组中重复的值
- array_unshift — 在数组开头插入一个或多个单元
- array_values — 返回数组中所有的值
- array_walk_recursive — 对数组中的每个成员递归地应用用户函数
- array_walk — 使用用户自定义函数对数组中的每个元素做回调处理
- array — 新建一个数组
- arsort — 对数组进行逆向排序并保持索引关系
- asort — 对数组进行排序并保持索引关系
- compact — 建立一个数组，包括变量名和它们的值
- count — 计算数组中的单元数目或对象中的属性个数
- current — 返回数组中的当前单元
- each — 返回数组中当前的键／值对并将数组指针向前移动一步
- end — 将数组的内部指针指向最后一个单元
- extract — 从数组中将变量导入到当前的符号表
- in_array — 检查数组中是否存在某个值
- key_exists — 别名 array_key_exists
- key — 从关联数组中取得键名
- krsort — 对数组按照键名逆向排序
- ksort — 对数组按照键名排序
- list — 把数组中的值赋给一些变量
- natcasesort — 用“自然排序”算法对数组进行不区分大小写字母的排序
- natsort — 用“自然排序”算法对数组排序
- next — 将数组中的内部指针向前移动一位
- pos — current 的别名
- prev — 将数组的内部指针倒回一位
- range — 建立一个包含指定范围单元的数组
- reset — 将数组的内部指针指向第一个单元
- rsort — 对数组逆向排序
- shuffle — 将数组打乱
- sizeof — count 的别名
- sort — 对数组排序
- uasort — 使用用户自定义的比较函数对数组中的值进行排序并保持索引关联
- uksort — 使用用户自定义的比较函数对数组中的键名进行排序
- usort — 使用用户自定义的比较函数对数组中的值进行排序
数学函数的说明
1. array_change_key_case ：返回字符串键名全为小写或大写的数组