php中有什么數組函數

這篇文章將為大家詳細講解有關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中有什么數組函數”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。