php数组函数小结

<?php

header(‘content-type:text/html;charset=utf-8;‘);

/*小结数组的使用*/

#1.array():定义数组eg：

$arr1=array(‘a‘,‘b‘,‘c‘,‘d‘);

$arr3=array(‘c‘,‘d‘,‘e‘,‘f‘);

$arr2=array(‘kA1‘=>‘v1‘,‘kA2‘=>‘v2‘,‘kA3‘=>‘v3‘);

$arr4=array(‘kA1‘=>‘v1‘,‘kA2‘=>‘v2‘,‘kA3‘=>‘v3‘,‘kA4‘=>‘v4‘);

$arr5=array(‘kA1‘=>‘v1‘,‘kA2‘=>‘v1‘,‘kA3‘=>‘v4‘,‘kA4‘=>‘v4‘);

$arr6=array(‘kA1‘=>‘v1‘,‘kA2‘=>‘v1‘,‘kA3‘=>‘v4‘,‘kA4‘=>‘v3‘);

$arr7=array(‘kA1‘=>‘v1‘,‘kA2‘=>‘v1‘);

#2.array_change_key_case(array,case):函数将数组所有的KEY都转换成大写或小写。数组的数字索引不发生变化。如果未提供可选参数（即第二个参数）则默认转换为小写字母

//case可选值：CASE_LOWER,默认值，以小写字母返回数组的键；CASE_UPPER：以大写字母返回数组的键

//注：如果在运行过程中，两个键相同，则最后一个将覆盖前面的

echo ‘<hr>1.array_change_key_case:<br>原数组：‘;

print_r($arr2);

echo ‘<br>大写键：‘;

print_r(array_change_key_case($arr2,CASE_UPPER));

echo ‘<br>小写键：‘;

print_r(array_change_key_case($arr2,CASE_LOWER));

#3.array_chunk(array,size,preserve_key):把数组分割为新的数组块，size：新数组的大小，最后一个数组的单元数目可能会少几个。preserve_key:bool，true，保留元数组的键名，false，分配新的数字键名

echo ‘<hr>2.array_chunk:<br>原数组：‘;

print_r($arr2);

echo ‘<br>preserve_key，默认值false：‘;

print_r(array_chunk($arr2,2));

echo ‘<br>preserve_key，true：‘;

print_r(array_chunk($arr2,2,true));

#4.arry_combine($arr1,$arr2):第一个数组的值做键，第二个数组的值做值，组成一个新数组，这两个数组既可以是索引数组也可以是关联数组，若两个数组的个数不相等，则返回false,若有嵌套数组则转化为Array字符串，并报一个Notice的错

echo ‘<hr>3.array_combie:<br>原数组1：‘;

print_r($arr1);

echo ‘<br>原数组2：‘;

print_r($arr3);

echo ‘<br>新数组：‘;

$tarr=array_combine($arr1, $arr3);

print_r($tarr);

#5.array_count_value($arr1):本函数返回一个数组，其元素的键名是原数组的值，键值是该值在原数组中出现的次数

echo ‘<hr>4.array_count_values:<br>原数组：‘;

print_r($arr5);

echo ‘<br>新数组：‘;

$tarr=array_count_values($arr5);

print_r($tarr);

#6.array_diff($arr1,$arr2,……):该函数返回两个数组的差集数组，但是不在任何其他参数数组中的键值，在返回数组中键名保持不变

echo ‘<hr>5.array_diff(array1, array2):<br>原数组1：‘;

print_r($arr4);

echo ‘<br>原数组2：‘;

print_r($arr5);

echo ‘<br>新数组：‘;

$tarr=array_diff($arr4, $arr5);

print_r($tarr);

#7.array_diff_assc($arr1,$arr2,……):函数返回两个数组的差集数组。该数组包括了所有在被比较的数组中，但是不在任何其他参数数组中的键和值。该函数和arry_diff_assc的区别是：本函数要求键名和键值都进行比较。返回的数组中键名保持不变

echo ‘<hr>6.array_diff_assoc(array1, array2):<br>原数组1：‘;

print_r($arr4);

echo ‘<br>原数组2：‘;

print_r($arr6);

echo ‘<br>新数组：‘;

$tarr=array_diff_assoc($arr4, $arr6);

print_r($tarr);

#8.array_diff_key($arr1,$arr2,……):函数返回两个数组的差集数组。该数组包括了所有在被比较的数组中，但是不在任何其他参数数组中的键和值。该函数和arry_diff_assc的区别是：本函数要求键名和键值都进行比较。返回的数组中键名保持不变

echo ‘<hr>7.array_diff_key(array1, array2):<br>原数组1：‘;

print_r($arr4);

echo ‘<br>原数组2：‘;

print_r($arr7);

echo ‘<br>新数组：‘;

$tarr=array_diff_key($arr4, $arr7);

print_r($tarr);

#9.array_diff_uassoc：函数使用用户自定义的回调函数 (callback) 做索引检查来计算两个或多个数组的差集。返回一个数组，该数组包括了在 array1 中但是不在任何其他参数数组中的值。

#参数 function 是用户自定义的用来比较两个数组的函数，该函数必须带有两个参数 - 即两个要进行对比的键名。因此与函数 array_diff_assoc() 的行为正好相反，后者是用内部函数进行比较的。

echo ‘<hr>8.array_diff_uassoc(array1, array2):<br>原数组1：‘;

function myfun($v1,$v2)

{

if ($v1===$v2)

{

return 0;

}

if ($v1>$v2)

{

return 1;

}

else

{

return -1;

}

}

$a1=array(0=>"Dog",1=>"Cat",2=>"Horse");

print_r($a1);

$a2=array(3=>"Dog",1=>"Cat",5=>"Horse");

echo ‘<br>原数组2：‘;

print_r($a2);

echo ‘<br>新数组：‘;

print_r(array_diff_uassoc($a1,$a2,‘myfun‘));

#10.array_diff_ukey() 返回一个数组，该数组包括了所有出现在 array1 中但是未出现在任何其它参数数组中的键名的值。注意关联关系保留不变。与 array_diff() 不同的是，比较是根据键名而不是值来进行的。

#11.array_fill(start,num,value),该函数返回一个索引从start开始，包含的num个value的数组；

echo ‘<hr>9.array_fill(2, 5,"huge"):<br>‘;

$val=‘huge‘;

print_r(array_fill(2, 5, $val));

#12.array_filter(arr,fun),函数用回调函数过滤数组中的元素，如果回调函数返回真，则保留该元素，否则过滤掉

function filter1($v){

if($v==‘v1‘){

return false;

}

return true;

}

echo ‘<hr>10.array_filter(arr,fun):<br>原数组1：‘;

print_r($arr2);

echo ‘<br>新数组：‘;

print_r(array_filter($arr2,‘filter1‘));

#13array_flip():该函将数组的键值互换，如果原数组中出现重复的键值，则最后一个值，将作为数组的值，其他的则将被丢弃，如果原函数中的键值出现非数字和字符串，该函数将报错

echo ‘<hr>11.array_flip:<br>原数组:‘;

print_r($arr2);

echo ‘<br>新数组：‘;

print_r(array_flip($arr2));

#14.array_intersect($arr1,$arr2,……):该函数返回两个或多个数组的交集数组，键名与第一个数组中键名保持一致

echo ‘<hr>12.array_instersect(array1, array2):<br>原数组1：‘;

print_r($arr4);

echo ‘<br>原数组2：‘;

print_r($arr5);

echo ‘<br>新数组：‘;

$tarr=array_intersect($arr4, $arr5);

print_r($tarr);

#15.array_intersect_assoc($arr1,$arr2,……):该函数返回两个或多个数组的交集数组，该函数除了比较值外还比较键

#16.array_intersect_key($arr1,$arr2,……):该函数使用键名比较来得到数组的交集

#17.array_intersect_uassoc($arr1,$arr2,……，function):该函数使用键名、值名比较来得到数组的交集

#18.array_intersect_ukey($arr1,$arr2,……，function):该函数使用键名比较来得到数组的交集

#19.array_key_exists():如果search中存在key则返回真，否则返回假

echo ‘<hr>13.array_key_exists(key, search):<br>原数组:‘;

print_r($arr2);

echo ‘<br>结果：‘;

echo array_key_exists(‘kA1‘, $arr2);

#20.array_keys(arr,value),第二个参数可选，如果有则返回value对应的键名构成的数组，如果不填，则返回键名构成的新数组

echo ‘<hr>14.array_keys(key, search):<br>原数组:‘;

print_r($arr6);

echo ‘<br>默认值：‘;

print_r(array_keys($arr6));

echo ‘<br>取单个key：‘;

print_r(array_keys($arr6,‘v3‘));

#21.array_map(fun,$arr1,$arr2,……)：该函数根据fun，建立数组的映射关系，如果fun为null，则返回两个数组组成的二维数组，如果为一个数组则根据数组的值，进行对应的输出，如果是两个数组，则进行比较后输出新的值，fun中参数的个数要和该函数数组的个数相同

function fun2($v){

if($v==‘a‘){

return ‘this is a‘;

}

return $v;

}

function fun3($v1,$v2){

if($v1==$v2){

return ‘Same‘;

}

return ‘Diffrent‘;

}

echo ‘<hr>15.array_map(callback, arr1):<br>原数组1:‘;

print_r($arr1);

echo ‘<br>原数组2:‘;

$tarr=array(‘a‘,‘b‘,‘e‘,‘f‘);

print_r($tarr);

echo ‘<br>一个数组‘;

echo ‘<br> fun:null,‘;

print_r(array_map(null, $arr1));

echo ‘<br> fun:fun2,‘;

print_r(array_map(‘fun2‘, $arr1));

echo ‘<br>两个数组‘;

echo ‘<br> fun:null,‘;

print_r(array_map(null, $arr1,$tarr));

echo ‘<br> fun:fun3,‘;

print_r(array_map(‘fun3‘, $arr1,$tarr));

#22array_merge($arr1,$arr2,……):该函数将多个数组进行合并，如果有相同的键名，

#则前面的值将被后面的覆盖，如果是数字索引，则键名以连续的方式重新索引

#如果传入一个数组，则该函数将该数组的数字键以数字索引的方式从0开始进行重新索引

$a1=array(1 =>‘value1‘ ,2 =>‘value2‘  ,‘k3‘ =>‘value3‘,‘k4‘ =>‘value4‘  ,‘k5‘ =>‘value5‘);

$a2=array(‘ke1‘ =>‘value1‘ ,‘k2‘ =>‘valu2‘  ,‘k3‘ =>‘valu3‘,‘ke4‘ =>‘valu4‘  ,‘k5‘ =>‘valu5‘);

echo ‘<hr>16.array_merge($arr1,$arr2):<br>原数组1:‘;

print_r($a1);

echo ‘<br>原数组2:‘;

print_r($a2);

echo ‘<br>一个数组：‘;

print_r(array_merge($a1));

echo ‘<br>两个个数组：‘;

print_r(array_merge($a1,$a2));

#23.array_merge_recursive($a1,$a2,……),该函数同array_merge相同，只是当出现重复键名时，

#该函数将以递归的形式生成一个子数组

echo ‘<hr>17.array_merge_recursive($arr1,$arr2):<br>原数组1:‘;

print_r($a1);

echo ‘<br>原数组2:‘;

print_r($a2);

echo ‘<br>结果：‘;

print_r(array_merge_recursive($a1,$a2));

#24.array_multy_sort():函数可以对多个数组或多维数组进行排序

#参数中数组被当成一个表的列并以行来进行排序，第一个参数是要排序的主要数组。

#如果数组中行（值）比较为相同的话，就会按照下一个输入数组中相应值的到校进行排序，一次类推

#第一个参数是数组，随后每一个参数可能是数组，以可能是下面的排序标识

#SORT_ASC：默认，升序

#SORT_DESC：降序

#随后可以指定排序的类型

#SORT_REGULAR:默认，将每一项按照常规顺序进行排序

#SORT_NUMERIC:将每一项按照数字书序排序

#SORT_STRING:将每一项按照字母顺序排序

#注：字符串键名将会被保留，数字键名将会从0开始以1逐渐递增进行重新索引

#排序类型只能指定一种

echo ‘<hr>18.array_multisort(arr,order,type,arr2):<br>原数组1:‘;

$a1 = array(‘a‘ => ‘B1‘,‘c‘=>‘A‘ );

$a3 = array(‘a‘ => ‘B1‘,‘c‘=>‘A‘ );

print_r($a1);

echo ‘<br>原数组2:‘;

$a2= array(‘m‘ => ‘X‘,‘f‘=>‘U‘ );

print_r($a2);

echo ‘<br>$a1结果：‘;

array_multisort($a1);

print_r($a1);

echo ‘<br>$a1,$a2结果：‘;

array_multisort($a3,$a2);

print_r($a3);

print_r($a2);

echo ‘<br>$a1,$a2降序结果：‘;

array_multisort($a3,SORT_ASC,SORT_STRING,$a2);

print_r($a3);

print_r($a2);

#25.array_pad($arr,size,valu),函数向一个数组中插入带有指定值的指定

#数量的元素

#如果size是负的长度值，则填补到左侧，反之填补到右侧，如果size小于数

#组的长度该函数不会删除任何元素

echo ‘<hr>19.array_pad(input, pad_size, pad_value):<br>原数组1:‘;

$ar1=array(‘a‘,‘s‘,‘d‘);

print_r($ar1);

$val=‘填充值‘;

echo ‘<br>正值结果：‘;

print_r(array_pad($ar1,5,$val));

echo ‘<br>负值结果：‘;

print_r(array_pad($ar1,-5,$val));

#26.array_pop($arr),删除数组中的最后一个元素,并返回被删除的元素

echo ‘<hr>20.array_pop(array):<br>原数组:‘;

$ar1=array(‘a‘,‘s‘,‘d‘);

print_r($ar1);

echo ‘<br>被删除的元素，结果：‘;

echo array_pop($ar1);

echo ‘<br>删除后的数组，结果：‘;

print_r(array_pop($ar1));

#27.array_product($arr):函数计算并返回数组的乘积,如果数组是非数字则返回0,

#该数组可以使多维数组

$tarr=array(1,2,3,array(1,2,3));

echo ‘<hr>21.array_product(array):<br>原数组:‘;

$res=array_product($tarr);

echo ‘结果：‘.$res;

#28.array_push($arr,$va1,$va2……):函数将多个值压入数组

echo ‘<hr>22.array_push(array):<br>原数组:‘;

$ar1=array(‘a‘,‘s‘,‘d‘);

print_r($ar1);

echo ‘<br>结果：‘;

array_push($ar1,‘huge‘,‘huge2‘);

print_r($ar1);

#29.array_rand($arr,num):函数从数组中随机选出一个或多个元素并返回。

#第二个参数用来确定要选出元素的个数，如果不止一个，则返回包含随机

#键名的数组，否则返回该元素的键名

echo ‘<hr>23.array_rand(array,num):<br>原数组:‘;

$a1=array(1 =>‘value1‘ ,2 =>‘value2‘  ,‘k3‘ =>‘value3‘,‘k4‘ =>‘value4‘  ,‘k5‘ =>‘value5‘);

print_r($a1);

echo ‘<br>取1个，结果：‘;

echo array_rand($a1);

echo ‘<br>取3个，结果：‘;

print_r(array_rand($a1,3));

#30.array_reduce()：函数用回调函数迭代第将数组简化为单一的值，如果指定第三个

#参数则该参数将被当做是数组中的第一个值来处理，或则如果数组为空的话就作为最终的返回值

function myfun4($v1,$v2){

echo ‘<br>‘;

echo $v1.‘:‘.$v2;

return $v1.‘-‘.$v2;

}

echo ‘<hr>24.array_reduce(array,num):<br>原数组:‘;

$arr=array(‘Dog‘,‘Cat‘,‘Horse‘);

print_r(array_reduce($arr,‘myfun4‘,‘初始值‘));

#31.array_reverse:该函数将数组中的顺序翻转，创建新的数组并返回，

#如果是索引数组，若第二个参数指定为true，则元素的键名保持不变，否则键名将丢失(默认)

echo ‘<hr>25.array_reverse(array,preserve):<br>原数组1:‘;

$arr=array(‘a‘=>‘Dog‘,‘b‘=>‘Cat‘,‘c‘=>‘Horse‘);

print_r($arr);

$arr1=array(‘Dog‘,‘Cat‘,‘Horse‘);

echo ‘<br>数组2：‘;

print_r($arr1);

echo ‘<br>关联数组:‘;

print_r(array_reverse($arr));

echo ‘<br>索引数组：‘;

print_r(array_reverse($arr1,false));

#32.array_search(val,arr,strict):在数组中查找一个键值，如果找到了返回该键值对应的键名

#反之，则返回false，当第三个参数被指定为true时，当数据类型和值都相等的情况下才返回对应的键值

echo ‘<hr>26.array_search:<br>原数组：‘;

$arr=array(‘a‘=>‘Dog‘,‘b‘=>‘Cat‘,‘c‘=>‘Horse‘);

print_r($arr);

echo ‘<br>结果:‘;

echo array_search(‘Dog‘,$arr);

echo ‘<br>结果:‘;

#33.array_shift(arr):函数删除数组中的第一个元素并返回该元素对应的值

#如果是索引数组，所有元素将获得新的键，从0开始，并以1递增

echo ‘<hr>27.array_shift:<br>原数组：‘;

$arr=array(‘a‘=>‘Dog‘,‘b‘=>‘Cat‘,‘c‘=>‘Horse‘);

print_r($arr);

echo "<br>函数返回值";

echo array_shift($arr);

echo ‘<br>:数组输出结果：‘;

print_r($arr);

#34.array_slice(arr,offset,length,preserve):函数在数组中取一段值，并返回，如果是索引数组则保留原来的键名

#arr：规定输入的数组

#offset：规定取出元素的开始位置，如果是正数，则从前往后数，负数，则从后往前

#length：可选，数值规定返回数组的长度。如果是负数，则从后向前，选取该绝对值数目的元素。如果未设置该值，则返回所有元素

#preserve：可选值，true保留键，false：默认，重置键

echo ‘<hr>28.array_slice:<br>原数组：‘;

$arr=array(‘a‘=>‘Dog‘,‘b‘=>‘Cat‘,‘c‘=>‘Horse‘);

print_r(array_slice($arr,-2,1));

#35.array_splice(arr,offset,length,arr2):与array_slice()函数类似，选择数组中的一系列元素，但不返回，而是删除它们并用其他值替代

#如果提供了第四个参数，则之前选中的那些元素将被第四个参数指定的数组取代

#关联数组，填入到新数组后将会按所以数组的形式重新索引

echo ‘<hr>29.array_splice:<br>原数组：‘;

$arr=array(‘a‘=>‘Dog‘,‘b‘=>‘Cat‘,‘c‘=>‘Horse‘,‘e‘=>‘Pig‘);

$arr2=array(‘b‘=>‘Ha‘,‘c‘=>‘Hu‘);

$tarr=array_splice($arr,0,3,$arr2);

print_r($arr);

echo ‘<br>被剪切的部分：‘;

print_r($tarr);

echo ‘<br>:剪切后的数组：‘;

print_r($arr);

#36.array_sum():函数返回数组中所有值的总和,字符串将被转换为整数

$arr=array(‘a‘=>"4",1=>"5",2=>6);

echo ‘<hr>30.array_sum:<br>原数组：‘;

print_r($arr);

echo ‘<br>结果：‘;

echo array_sum($arr);

#37.array_udiff()函数返回一个数组，该数组包括了所有在被比较数组中，

#但是不在任何其他参数数组中的值，键名暴力与不变

#数据的比较式用array_diff函数的function进行的，function函数带有两个将

#进行比较的。function函数带有两个将进行比较的参数。如果第一个参数小于第

#二个参数，则函数返回一个负数，如果两个参数相等，则返回0，如果第一个参数

#大于第二个，则返回一个正数

function myfun5($v1,$v2){

/*

echo ‘<br>‘;

echo "$v1:$v2";

echo ‘<br>‘;

*/

if($v1==$v2){

return 0;

}

return 1;

}

echo ‘<hr>30.array_udiff:<br>原数组1：‘;

$a1=array(‘a‘=>‘Cat‘,‘b‘=>‘Bug1‘,‘c‘=>‘Horse1‘,‘d‘=>‘Horse_1‘);

print_r($a1);

$a2=array(‘Bug2‘,‘Cat‘,‘Fish‘);

echo ‘<br>原数组2：‘;

print_r($a2);

echo ‘<br>结果：‘;

print_r(array_udiff($a1,$a2,‘myfun5‘));

#38.array_udiff_assoc:函数返回arr1中存在但其他数组都不存在的部分。函数要比较键、值；

echo ‘<hr>31.array_udiff_assoc:<br>原数组1：‘;

$a1=array(‘a‘=>‘Cat‘,‘b‘=>‘Bug1‘,‘c‘=>‘Horse1‘,‘d‘=>‘Horse_1‘);

print_r($a1);

$a2=array(‘Bug2‘,‘a‘=>‘Cat‘,‘Fish‘);

echo ‘<br>原数组2：‘;

print_r($a2);

echo ‘<br>结果：‘;

print_r(array_udiff_assoc($a1,$a2,‘myfun5‘));

#39.array_udiff_uassoc:函数返回 array1 数组中存在但其它数组中都不存在的部分。返回的数组中键名保持不变。

function myfunction_key($v1,$v2)

{

if ($v1===$v2)

{

return 0;

}

return 1;

}

function myfunction_value($v1,$v2)

{

if ($v1===$v2)

{

return 0;

}

return 1;

}

echo ‘<hr>32.array_udiff_uassoc:<br>结果：‘;

$a1=array("a"=>"Cat","b"=>"Dog","c"=>"Horse");

$a2=array("a"=>"Cat","b"=>"Dog","c"=>"Fish");

print_r(array_udiff_uassoc($a1,$a2,"myfunction_key","myfunction_value"));

#40.array_uintersect():函数计算数组的交集，用回调函数比较数据

function myfunction($v1,$v2)

{

if ($v1===$v2)

{

return 0;

}

if ($v1 > $v2) return 1;

{

return -1;

}

return 1;

}

echo ‘<hr>33.array_uintersect:<br>结果：‘;

$a1=array("a"=>"Cat","b"=>"Dog","c"=>"Horse");

$a2=array(1=>"Cat",2=>"Dog",3=>"Fish");

print_r(array_uintersect($a1,$a2,"myfunction"));

#41.array_uintersect_assoc：与 array_uintersect() 不同的是键名也要比较。数据（键值）是用回调函数比较的。

function myfunction1($v1,$v2)

{

if ($v1===$v2)

{

return 0;

}

return 1;

}

$a1=array("a"=>"Cat","b"=>"Dog","c"=>"Horse");

$a2=array("a"=>"Cat","b"=>"Horse","c"=>"Dog");

echo ‘<hr>34.array_uintersect_assoc:<br>结果：‘;

print_r(array_uintersect_assoc($a1,$a2,"myfunction1"));

#42.array_uniqe():函数移除数组中的重复发的值，当几个数组的值相等时，只保留第一个元素，其他元素被删除，

#返回数组中的键名保持不变

echo ‘<hr>35.array_unique(array):<br>原数组：‘;

$a=array(‘a‘=>‘Cat‘,‘b‘=>‘Dog‘,‘c‘=>‘Cat‘);

print_r($a);

echo ‘<br>结果：‘;

print_r(array_unique($a));

#43.array_unshift()函数：函数在数组开头插入一个或多个元素。

#被加入的元素作为一个整体添加，这些元素在数组中的顺序一样。

#该函数会返回数组中元素的个数

echo ‘<hr>36.array_unshift:<br>原数组：‘;

$a=array(‘a‘=>‘Cat‘,‘b‘=>‘Dog‘);

print_r($a);

echo ‘<br>结果：数组个数，‘;

echo array_unshift($a,‘Horse‘);

echo ‘；数组，‘;

print_r($a);

#44.array_values:函数返回一个包含给定数组中所有键值的数组，但不保留键名

echo ‘<hr>37.array_values:<br>原数组：‘;

$a=array(‘a‘=>‘Cat‘,‘b‘=>‘Dog‘);

print_r($a);

echo ‘<br>结果：‘;

print_r(array_values($a));

#45.array_walk():函数对数组中的每个元素应用回调函数，如果成功返回TRUE，反之返回false

#典型情况下function接受两个参数，array参数的值作为第一个，键名作为第二个，如果提

#了可选参数userdata，将被作为第三个参数传递给回调函数

#如果function函数需要的参数比给出的多，则每次array_walk调用function时都会产生一个E_WARNING

#级的错误。这些警告可以通过在array_walk()调用前加上php的错误操作符@来抑制，或者用error——reporting（）

echo ‘<hr>38.array_walk:<br>原数组：‘;

function myfun6($v,$k){

echo "<br>The key $k has the value $v<br>";

}

$a=array(‘a‘=>‘Cat‘,‘b‘=>‘Dog‘,‘c‘=>‘Horse‘);

print_r($a);

echo ‘<br>结果：‘;

array_walk($a,‘myfun6‘);

function myfun7($value,$key,$p)

{

echo "$key $p $value<br />";

}

array_walk($a,"myfun7","has the value");

#46.array_walk_recursive():函数与array_walk不一样的是，如果原数组中的元素也是数组，就会递归地调用回调函数

echo ‘<hr>39.array_walk:<br>原数组：‘;

$a1=array("a"=>"Cat","b"=>"Dog");

$a2=array($a1,"1"=>"Bird","2"=>"Horse");

print_r($a2);

array_walk_recursive($a2,"myfun6");

#47.array_arsort(arr,sorttype):函数对数组进行你想排序并保持索引关系。主要用于对那些单元顺序很重要的结合数组进行排序

#可选的第二个参数包含了附加的排序标识，如果成功则返回true，反之返回false。

#其中sorttype的可能值有：

#SORT_REQULAR-默认。以他们原来的类型进行处理（不改变类型）

#SORT_NUMERIC,把值作为数字来处理

#SORT_STRING，把值作为字符串来处理

#SORT_LOCAL_STRING，把值作为字符串来处理，基于本地设置

echo ‘<hr>40.array_arsort:<br>原数组：‘;

$a1=array("a"=>"Cat","b"=>"Dog");

print_r($a1);

echo ‘<br>结果：‘;

arsort($a1);

print_r($a1);

#48.array_sort(arr,sorttype):对数组进行正向排序，参数同上

echo ‘<hr>41.array_arsort:<br>原数组：‘;

$a1=array("b"=>"Dog","a"=>"Cat");

print_r($a1);

echo ‘<br>结果：‘;

asort($a1);

print_r($a1);

#49.compact()函数创建一个由参数所带变量组成的数组。如果参数中存在数组，该数组中变量的值也被获取

#本函数返回一个关联数组，键名为函数参数，键值为参数中变量的值；

#compact(var1,var2),中参数可以是带变量名的字符串，或者是一个变量数组

#注：任何没有变量名与之对应的字符串都被略过

echo ‘<hr>42.compact(var1,var2...):<br>结果：‘;

$first=‘LI‘;

$last=‘Huge‘;

//$none=‘‘;//有空值

$arr=compact(‘first‘,‘last‘,‘none‘);

print_r($arr);

#50.count():函数计算数组汇总的单元数目或对象中属性个数

#对于数组返回其元素的个数，对于其他值，返回1.

#如果参数是变量，而变量没定义，则返回0如果mode设置为COUNT_RECURSIVE(或1)，则会递归

echo ‘<hr>43.count(array,mode):<br>原数组：‘;

$b1=array("c"=>"Dog","d"=>"Cat");

$a1=array("b"=>"Dog","a"=>"Cat",$b1);

print_r($a1);

echo "<br>默认结果：";

echo count($a1);

echo "<br>检测多维数组结果：";

echo count($a1,COUNT_RECURSIVE);

#51.current():函数返回数组中的当前元素

#每个数组内部都有一个内部指针指向它当前的元素，初始指向插入到数组中第一个元素

#该函数返回当前被内部指针指向的数组元素，并不移动指针，如果内部指针指向超出了单元列表的末端

#，current()返回false

echo ‘<hr>44.current（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

echo current($a1);

#51.each():函数生成一个由数组内部指针所指向的元素的键名和键值组成的数组，并把内部指针向前移动，如果内部指针越界返回false

#0,key指向当前数组元素键名，1，value指向当前数组元素的键值

echo ‘<hr>45.each（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

print_r(each($a1));

#52.end():函数将数组内部指针指向最后一个元素，并返回该元素的值（如果成功）

echo ‘<hr>46.end（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

echo end($a1);

#53.extract(arr,type,prefix):函数从数组中把变量导入到当前的符号表中

#对数组中的每个元素，键名用于变量名，键值用于变量值。

#type用于指定当变量已经存在，而数组中又有同名元素时，函数如何对待这样的冲突

#函数返回成功设置的变量数目

#extract_rules可选值：函数将检查每个键名是否合法，同时也检查和符号表中的变量名是否冲突

#EXTR_OVERWRITE,默认，如果存在，则覆盖已有变量

#EXTR_SKIP,如果存在不覆盖已有的变量，忽略数组中的同名元素

#EXTR_PREFIX_SAME，如果有冲突，在变量名前加上前缀

#EXTR_PREFIX_ALL,给所有的变量名加上前缀

#EXTR_PREFIX_INVALID，仅在非法会数字变量名前加上前缀

#EXTR_IF_EXISTS,仅在当前符号表中已有同名变量时，覆盖他们的值。其他都不做处理

#EXTR_PREFIX_IF_EXISTS,仅在当前符号表中已有同名变量时，建立附加前缀的变量名

#EXTR_PRFS，将变量作为引用提取

#prefix仅在type包含PREFIX时有效，如果附加了前缀后结果依然不合法，结果将不会导入到符号表中

#前缀和数组键名之间会自动加上一个下划线

echo ‘<hr>47.extract（）:<br>原数组：‘;

$c=‘章鱼‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>默认结果：";

extract($a1);

echo $c.‘,‘.$d;

#54.in_array(value，arr,type):在数组中搜索给定的值

#如果type设置为true，则搜索的值存在于数组中并且类型相同时，才会返回true

echo ‘<hr>48.in_array（）:<br>原数组：‘;

$a1=array("c"=>"1","d"=>"Cat");

print_r($a1);

$c=1;

echo "<br>结果1：";

echo in_array($c,$a1);

#55.key($arr):函数返回数组中的当前元素的键值

echo ‘<hr>49.key（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

echo key($a1);

#56.krsort(arr,sorttype):函数将数组按键逆向排序，为数组保留原来的键

echo ‘<hr>50.krsort（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

krsort($a1);

print_r($a1);

#57.ksort(arr,sorttype):函数将数组按键正向排序，为数组保留原来的键

echo ‘<hr>51.ksort（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat","a"=>"Horse");

print_r($a1);

echo "<br>结果：";

ksort($a1);

print_r($a1);

#58.list(var1，var2...):函数用数组中的元素为一组变量赋值

#函数只用于数字索引数组，切假定数字索引从0开始

echo ‘<hr>52.list（）:<br>原数组：‘;

$a1=array("Dog","Cat");

print_r($a1);

echo "<br>结果：";

list($a,$b)=$a1;

echo $a;

#59.natcasesort()函数用不区分大小写的自然顺序算法对给定数组中元素排序

#自然排序：数字从1到9字母从a-z短者优先，该函数不区分大小写。

#natcasesort是natsort不区分大小写字母的版本

#如果成功，则返回true，反之，返回false

echo ‘<hr>53.natcasesort（）:<br>原数组：‘;

$a1= array("temp15.txt","Temp10.txt","temp1.txt","Temp22.txt","temp2.txt");

print_r($a1);

echo "<br>natsort结果：";

natsort($a1);

print_r($a1);

echo ‘<br>natcasesort结果：‘;

$a1= array("temp15.txt","Temp10.txt","temp1.txt","Temp22.txt","temp2.txt");

natcasesort($a1);

print_r($a1);

#60.next():函数把指向当前元素的指针移动到下一个元素，并返回当前元素的值

#如果内部指针已经超过数组的最后一个元素，函数返回一个false

#注：如果数组包含空的单元，或者单元的值是 0 则该函数碰到这些单元也返回 FALSE。要正确遍历可能含有空单元或者单元值为 0 的数组

echo ‘<hr>54.next（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

echo next($a1);

#61.pos(arr):pos是current()的别名，他返回当前元素的值；

#62.prev(arr):同next（arr),函数把指向当前元素的指针移动到上一个元素的位置，并返回当前元素的值，

#注意事项同next

echo ‘<hr>55.prev（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat");

print_r($a1);

echo "<br>结果：";

next($a1);

echo prev($a1);

#63.range(first,second,step):函数创建并返回一个包含指定范围的元素的数组

#first，数组元素的最小值

#second，规定数组元素的最大值

#step，规定元素之间的步进制，默认是1

#该函数创建一个数组，包含从first到second（包含first和second）之间的整数或

#字符，如果first比second小则返回反序的数组

echo ‘<hr>56.range（first,second,step）:<br>结果：‘;

$a=range(‘a‘,‘d‘,2);

print_r($a);

#64.reset(arr):函数把数组内部指针指向第一个元素并返回这个元素的值

echo ‘<hr>57.reset（arr）:<br>原数组：‘;

$a=array(‘a‘,‘d‘,2);

print_r($a);

next($a);

echo ‘<br>当前值：‘;

echo current($a);

echo ‘<br>重置后：‘;

echo reset($a);

#65.rsort(arr,sorttype):函数对数组的元素按照键值进行逆向排序，sorttype类型同asort

echo ‘<hr>58.rsort（arr，storttype）:<br>原数组：‘;

$a=array(‘a‘,‘d‘,2);

print_r($a);

echo ‘<br>结果：‘;

rsort($a);

print_r($a);

#66.shuffle()函数把数组中的元素按随机顺序重新排列，若成功返回true，否则返回false

#注：本函数为数组中单元赋予新的键名。这将删除原有的键名而不仅是重新排序

echo ‘<hr>59.shuffle（）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat","a"=>"Horse");

print_r($a1);

echo ‘<br>结果：‘;

shuffle($a1);

print_r($a1);

#67.sizeof(arr,mode):函数计算数组中单元数目或对象中属性个数，count()的别名

#68.sort()函数按升序对给定数组的值进行排序,本函数为数组的单元赋予新的键名，原有的键名将被删除

echo ‘<hr>60.sort（arr,sorttype）:<br>原数组：‘;

$a1=array("c"=>"Dog","d"=>"Cat","a"=>"Horse");

print_r($a1);

echo ‘<br>结果：‘;

sort($a1);

print_r($a1);

#69.uasort(arr,fun)：函数用用户自定义的比较函数对数组排序，并保持索引关联

#uksort(arr,fun):函数使用户自定义的比较函数按照键名对数组排序，并保持索引关系

#usort(arr,fun)函数用用户自定义的函数对数组排序，会删除原有的键名

#其中fun是用户自定义函数，函数设计必须为返回-1,0,1并接受两个供比较的参数，同时以类

#似下面的方式来工作

#a=b,返回0

#a>b,返回1

#a<b,返回-1

function myfun8($a,$b){//逆向排序

echo "<br>$a:$b<br>";

if($a==$b){

return 0;

}elseif($a>$b){

return -1;

}else{

return 1;

}

}

$a1=array("c"=>"Dog","d"=>"Cat","a"=>"Horse","c1"=>"Dog1","d1"=>"Cat1","a1"=>"Horse1");

echo ‘<hr>70.uasort,uksort,usort:<br>原数组：‘;

print_r($a1);

echo ‘<br>uasort(array, cmp_function):‘;

uasort($a1,‘myfun8‘);

print_r($a1);

echo ‘<br>uksort(array, cmp_function):‘;

$a1=array("c"=>"Dog","d"=>"Cat","a"=>"Horse");

uksort($a1,‘myfun8‘);

print_r($a1);

echo ‘<br>usort(array, cmp_function):‘;

$a1=array("c"=>"Dog","d"=>"Cat","a"=>"Horse");

usort($a1,‘myfun8‘);

print_r($a1);

php数组函数小结

时间： 2024-12-29 06:56:50

php数组函数小结的相关文章

[从头学数学] 第159节 反比例函数 小结与复习题

剧情提要: [机器小伟]在[project师阿伟]的陪同下进入了筑基后期的修炼, 这次要修炼的目标是[反比例函数 小结与复习题]. 正剧開始: 星历2016年04月03日 09:50:19, 银河系厄尔斯星球中华帝国江南行省. [project师阿伟]正在和[机器小伟]一起研究[反比例函数 小结与复习题]. <span style="font-size:18px;"> if (1) { var r = 20; config.setSector(1,1,1,1); confi

javascript jquery数组操作小结

----------------------------------------------------------定义数组---------------------------------------------------------- $(function(){ var aArray = {};//定义一个数组 aArray['name'] = "张三"; aArray['sex'] = "男"; aArray['mail'] = "[email p

判断对象是否为数组/函数

打印Object的prototype属性: 有一个toString方法,不同于一般变量的toString方法,当Object的toString方法执行时: 1.获取当前对象的[[Class]]属性的值; 2.返回 "[object " + 第一步得出的值+ "]"格式的字符串,例如[object Array], 解析: [[Class]]是一种内部属性,所有的对象(原生对象和宿生对象)都拥有该属性,描述该对象的类型 (值得注意的是[[Class]]的值只能是Obje

数组函数

2016年11月22号 今天苦逼的学习了"几个"数组函数.不多也就30几个! 首先学习了 数组的指针:在每一个数组的内部,都有一个数组元素的指针,该指针负责指向数组内的某个元素,那么这个被指向的元素,就叫作"当前元素"!而他又有两个小弟,分别实现键和值:key:语法:key(数组名)作用:获取该数组当前元素的键!current:语法:current(数组名)作用:获取该数组当前元素的值! 然而,数组的指针不能永远只指向某个元素,应该将数组的指针在需要的时候下移一位!

PHP数组函数

数组函数: count: 返回数组的个数 explode: 把字符串切割为数组 join: 把数组连接为字符串 array_values:返回数组中的value值,组成一个新数组 array_keys :返回数组中的key值,组成一个新数组 array_pop : 删除数组中最后一组元素 list : 把数组中的值,赋值给对应的变量 next:数组中的指针往后移动一位 prev:数组中的指针往前移动一位 end:选取最后一个元素 in_array:判断数组中是否存在某个值 array_rever

自定义数组函数

// 自定义数组函数Array.prototype.maxima.//Array.prototype为必须的,maxima为数组名.//调用时arr.maxima()这样调用window.onload = function() { Array.prototype.sum = function(){ for(var sum = i = 0 ; i < this.length; i ++){ sum += parseInt(this[i]); } return sum; }; Array.proto

数组拷贝、数组函数、通过数组函数来模拟数据结构的栈和队列、回调的意义、数组函数的排序问题、算法以及寻找素数的筛选法

1.数组的拷贝数组拷贝时指针的指向问题. 数组在拷贝时,指针的位置随之复制[这一点拷贝是完全一样]但是如果拷贝的数组的指针是非法的,那么拷贝出新指针的位置进行初始化<?php$arr1=array('123');end($arr1);next($arr1);//这个指针非法$arr2 = $arr1;//这里进行数组的拷贝var_dump(current($arr2));//得到指向‘123’元素的指针var_dump(current($arr1));//此时这个数组的指针有问题?> 但是拷贝

labview学习之“创建数组”函数

“创建数组”函数 一.位置:“函数”-“编程”-“数组”-“创建数组” 其图标为: 图1 图标 二.简介: “创建数组”函数有两种模式,一种是“连接模式”,一种是“添加模式”. 如需切换两种模式,可右键单击“创建数组”函数,切换连接输入菜单项. “创建数组”函数默认输入端数量为1.如需添加输入,可右键单击该函数并从菜单中选择添加输入,或者调整函数的大小. (1)在连接模式下,输入可以同时包含n维数组.n-1维数组(n>0).“创建数组”函数通过连接输入数组的每个元素得到一个n维数组. (2)在添

js 格式化时间日期函数小结

下面是脚本之家为大家整理的一些格式化时间日期的函数代码,需要的朋友可以参考下. 代码如下: Date.prototype.format = function(format){ var o = { "M+" : this.getMonth()+1, //month "d+" : this.getDate(), //day "h+" : this.getHours(), //hour "m+" : this.getMinutes(