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 '

1.array_change_key_case:
原陣列：';

print_r($arr2);

echo '
大寫鍵：';

print_r(array_change_key_case($arr2,CASE_UPPER));

echo '
小寫鍵：';

print_r(array_change_key_case($arr2,CASE_LOWER));

#3.array_chunk(array,size,preserve_key):把陣列分割為新的陣列塊，size：新陣列的大小，最後一個陣列的單元數目可能會少幾個。preserve_key:bool，true，保留元陣列的鍵名，false，分配新的數字鍵名

echo '

2.array_chunk:
原陣列：';

print_r($arr2);

echo '
preserve_key，預設值false：';

print_r(array_chunk($arr2,2));

echo '
preserve_key，true：';

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

#4.arry_combine($arr1,$arr2):第一個陣列的值做鍵，第二個陣列的值做值，組成一個新陣列，這兩個陣列既可以是索引陣列也可以是關聯陣列，若兩個陣列的個數不相等，則返回false,若有巢狀陣列則轉化為Array字串，並報一個Notice的錯

echo '

3.array_combie:
原陣列1：';

print_r($arr1);

echo '
原陣列2：';

print_r($arr3);

echo '
新陣列：';

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

print_r($tarr);

#5.array_count_value($arr1):本函式返回一個陣列，其元素的鍵名是原陣列的值，鍵值是該值在原陣列中出現的次數

echo '

4.array_count_values:
原陣列：';

print_r($arr5);

echo '
新陣列：';

$tarr=array_count_values($arr5);

print_r($tarr);

#6.array_diff($arr1,$arr2,……):該函式返回兩個陣列的差集陣列，但是不在任何其他引數陣列中的鍵值，在返回陣列中鍵名保持不變

echo '

5.array_diff(array1, array2):
原陣列1：';

print_r($arr4);

echo '
原陣列2：';

print_r($arr5);

echo '
新陣列：';

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

print_r($tarr);

#7.array_diff_assc($arr1,$arr2,……):函式返回兩個陣列的差集陣列。該陣列包括了所有在被比較的陣列中，但是不在任何其他引數陣列中的鍵和值。該函式和arry_diff_assc的區別是：本函式要求鍵名和鍵值都進行比較。返回的陣列中鍵名保持不變

echo '

6.array_diff_assoc(array1, array2):
原陣列1：';

print_r($arr4);

echo '
原陣列2：';

print_r($arr6);

echo '
新陣列：';

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

print_r($tarr);

#8.array_diff_key($arr1,$arr2,……):函式返回兩個陣列的差集陣列。該陣列包括了所有在被比較的陣列中，但是不在任何其他引數陣列中的鍵和值。該函式和arry_diff_assc的區別是：本函式要求鍵名和鍵值都進行比較。返回的陣列中鍵名保持不變

echo '

7.array_diff_key(array1, array2):
原陣列1：';

print_r($arr4);

echo '
原陣列2：';

print_r($arr7);

echo '
新陣列：';

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

print_r($tarr);

#9.array_diff_uassoc：函式使用使用者自定義的回撥函式 (callback) 做索引檢查來計算兩個或多個陣列的差集。返回一個陣列，該陣列包括了在 array1 中但是不在任何其他引數陣列中的值。

#引數 function 是使用者自定義的用來比較兩個陣列的函式，該函式必須帶有兩個引數 - 即兩個要進行對比的鍵名。因此與函式 array_diff_assoc() 的行為正好相反，後者是用內部函式進行比較的。

echo '

8.array_diff_uassoc(array1, array2):
原陣列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 '
原陣列2：';

print_r($a2);

echo '
新陣列：';

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 '

9.array_fill(2, 5,"huge"):
';

$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 '

10.array_filter(arr,fun):
原陣列1：';

print_r($arr2);

echo '
新陣列：';

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

#13array_flip():該函將陣列的鍵值互換，如果原陣列中出現重複的鍵值，則最後一個值，將作為陣列的值，其他的則將被丟棄，如果原函式中的鍵值出現非數字和字串，該函式將報錯

echo '

11.array_flip:
原陣列:';

print_r($arr2);

echo '
新陣列：';

print_r(array_flip($arr2));

#14.array_intersect($arr1,$arr2,……):該函式返回兩個或多個陣列的交集陣列，鍵名與第一個陣列中鍵名保持一致

echo '

12.array_instersect(array1, array2):
原陣列1：';

print_r($arr4);

echo '
原陣列2：';

print_r($arr5);

echo '
新陣列：';

$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 '

13.array_key_exists(key, search):
原陣列:';

print_r($arr2);

echo '
結果：';

echo array_key_exists('kA1', $arr2);

#20.array_keys(arr,value),第二個引數可選，如果有則返回value對應的鍵名構成的陣列，如果不填，則返回鍵名構成的新陣列

echo '

14.array_keys(key, search):
原陣列:';

print_r($arr6);

echo '
預設值：';

print_r(array_keys($arr6));

echo '
取單個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 '

15.array_map(callback, arr1):
原陣列1:';

print_r($arr1);

echo '
原陣列2:';

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

print_r($tarr);

echo '
一個陣列';

echo '
fun:null,';

print_r(array_map(null, $arr1));

echo '
fun:fun2,';

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

echo '
兩個陣列';

echo '
fun:null,';

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

echo '
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 '

16.array_merge($arr1,$arr2):
原陣列1:';

print_r($a1);

echo '
原陣列2:';

print_r($a2);

echo '
一個陣列：';

print_r(array_merge($a1));

echo '
兩個個陣列：';

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

#23.array_merge_recursive($a1,$a2,……),該函式同array_merge相同，只是當出現重複鍵名時，

#該函式將以遞迴的形式生成一個子陣列

echo '

17.array_merge_recursive($arr1,$arr2):
原陣列1:';

print_r($a1);

echo '
原陣列2:';

print_r($a2);

echo '
結果：';

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

#24.array_multy_sort():函式可以對多個陣列或多維陣列進行排序

#引數中陣列被當成一個表的列並以行來進行排序，第一個引數是要排序的主要陣列。

#如果陣列中行（值）比較為相同的話，就會按照下一個輸入陣列中相應值的到校進行排序，一次類推

#第一個引數是陣列，隨後每一個引數可能是陣列，以可能是下面的排序標識

#SORT_ASC：預設，升序

#SORT_DESC：降序

#隨後可以指定排序的型別

#SORT_REGULAR:預設，將每一項按照常規順序進行排序

#SORT_NUMERIC:將每一項按照數字書序排序

#SORT_STRING:將每一項按照字母順序排序

#注：字串鍵名將會被保留，數字鍵名將會從0開始以1逐漸遞增進行重新索引

#排序型別只能指定一種

echo '

18.array_multisort(arr,order,type,arr2):
原陣列1:';

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

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

print_r($a1);

echo '
原陣列2:';

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

print_r($a2);

echo '
$a1結果：';

array_multisort($a1);

print_r($a1);

echo '
$a1,$a2結果：';

array_multisort($a3,$a2);

print_r($a3);

print_r($a2);

echo '
$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 '

19.array_pad(input, pad_size, pad_value):
原陣列1:';

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

print_r($ar1);

$val='填充值';

echo '
正值結果：';

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

echo '
負值結果：';

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

#26.array_pop($arr),刪除陣列中的最後一個元素,並返回被刪除的元素

echo '

20.array_pop(array):
原陣列:';

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

print_r($ar1);

echo '
被刪除的元素，結果：';

echo array_pop($ar1);

echo '
刪除後的陣列，結果：';

print_r(array_pop($ar1));

#27.array_product($arr):函式計算並返回陣列的乘積,如果陣列是非數字則返回0,

#該陣列可以使多維陣列

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

echo '

21.array_product(array):
原陣列:';

$res=array_product($tarr);

echo '結果：'.$res;

#28.array_push($arr,$va1,$va2……):函式將多個值壓入陣列

echo '

22.array_push(array):
原陣列:';

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

print_r($ar1);

echo '
結果：';

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

print_r($ar1);

#29.array_rand($arr,num):函式從陣列中隨機選出一個或多個元素並返回。

#第二個引數用來確定要選出元素的個數，如果不止一個，則返回包含隨機

#鍵名的陣列，否則返回該元素的鍵名

echo '

23.array_rand(array,num):
原陣列:';

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

print_r($a1);

echo '
取1個，結果：';

echo array_rand($a1);

echo '
取3個，結果：';

print_r(array_rand($a1,3));

#30.array_reduce()：函式用回撥函式迭代第將陣列簡化為單一的值，如果指定第三個

#引數則該引數將被當做是陣列中的第一個值來處理，或則如果陣列為空的話就作為最終的返回值

function myfun4($v1,$v2){

echo '
';

echo $v1.':'.$v2;

return $v1.'-'.$v2;

}

echo '

24.array_reduce(array,num):
原陣列:';

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

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

#31.array_reverse:該函式將陣列中的順序翻轉，建立新的陣列並返回，

#如果是索引陣列，若第二個引數指定為true，則元素的鍵名保持不變，否則鍵名將丟失(預設)

echo '

25.array_reverse(array,preserve):
原陣列1:';

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

print_r($arr);

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

echo '
陣列2：';

print_r($arr1);

echo '
關聯陣列:';

print_r(array_reverse($arr));

echo '
索引陣列：';

print_r(array_reverse($arr1,false));

#32.array_search(val,arr,strict):在陣列中查詢一個鍵值，如果找到了返回該鍵值對應的鍵名

#反之，則返回false，當第三個引數被指定為true時，當資料型別和值都相等的情況下才返回對應的鍵值

echo '

26.array_search:
原陣列：';

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

print_r($arr);

echo '
結果:';

echo array_search('Dog',$arr);

echo '
結果:';

#33.array_shift(arr):函式刪除陣列中的第一個元素並返回該元素對應的值

#如果是索引陣列，所有元素將獲得新的鍵，從0開始，並以1遞增

echo '

27.array_shift:
原陣列：';

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

print_r($arr);

echo "
函式返回值";

echo array_shift($arr);

echo '
:陣列輸出結果：';

print_r($arr);

#34.array_slice(arr,offset,length,preserve):函式在陣列中取一段值，並返回，如果是索引陣列則保留原來的鍵名

#arr：規定輸入的陣列

#offset：規定取出元素的開始位置，如果是正數，則從前往後數，負數，則從後往前

#length：可選，數值規定返回陣列的長度。如果是負數，則從後向前，選取該絕對值數目的元素。如果未設定該值，則返回所有元素

#preserve：可選值，true保留鍵，false：預設，重置鍵

echo '

28.array_slice:
原陣列：';

$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 '

29.array_splice:
原陣列：';

$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 '
被剪下的部分：';

print_r($tarr);

echo '
:剪下後的陣列：';

print_r($arr);

#36.array_sum():函式返回陣列中所有值的總和,字串將被轉換為整數

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

echo '

30.array_sum:
原陣列：';

print_r($arr);

echo '
結果：';

echo array_sum($arr);

#37.array_udiff()函式返回一個陣列，該陣列包括了所有在被比較陣列中，

#但是不在任何其他引數陣列中的值，鍵名暴力與不變

#資料的比較式用array_diff函式的function進行的，function函式帶有兩個將

#進行比較的。function函式帶有兩個將進行比較的引數。如果第一個引數小於第

#二個引數，則函式返回一個負數，如果兩個引數相等，則返回0，如果第一個引數

#大於第二個，則返回一個正數

function myfun5($v1,$v2){

if($v1==$v2){

return 0;

}

return 1;

}

echo '

30.array_udiff:
原陣列1：';

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

print_r($a1);

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

echo '
原陣列2：';

print_r($a2);

echo '
結果：';

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

#38.array_udiff_assoc:函式返回arr1中存在但其他陣列都不存在的部分。函式要比較鍵、值；

echo '

31.array_udiff_assoc:
原陣列1：';

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

print_r($a1);

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

echo '
原陣列2：';

print_r($a2);

echo '
結果：';

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 '

32.array_udiff_uassoc:
結果：';

$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 '

33.array_uintersect:
結果：';

$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 '

34.array_uintersect_assoc:
結果：';

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

#42.array_uniqe():函式移除陣列中的重複發的值，當幾個陣列的值相等時，只保留第一個元素，其他元素被刪除，

#返回陣列中的鍵名保持不變

echo '

35.array_unique(array):
原陣列：';

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

print_r($a);

echo '
結果：';

print_r(array_unique($a));

#43.array_unshift()函式：函式在陣列開頭插入一個或多個元素。

#被加入的元素作為一個整體新增，這些元素在陣列中的順序一樣。

#該函式會返回陣列中元素的個數

echo '

36.array_unshift:
原陣列：';

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

print_r($a);

echo '
結果：陣列個數，';

echo array_unshift($a,'Horse');

echo '；陣列，';

print_r($a);

#44.array_values:函式返回一個包含給定陣列中所有鍵值的陣列，但不保留鍵名

echo '

37.array_values:
原陣列：';

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

print_r($a);

echo '
結果：';

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 '

38.array_walk:
原陣列：';

function myfun6($v,$k){

echo "
The key $k has the value $v
";

}

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

print_r($a);

echo '
結果：';

array_walk($a,'myfun6');

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

{

echo "$key $p $value
";

}

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

#46.array_walk_recursive():函式與array_walk不一樣的是，如果原陣列中的元素也是陣列，就會遞迴地呼叫回撥函式

echo '

39.array_walk:
原陣列：';

$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 '

40.array_arsort:
原陣列：';

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

print_r($a1);

echo '
結果：';

arsort($a1);

print_r($a1);

#48.array_sort(arr,sorttype):對陣列進行正向排序，引數同上

echo '

41.array_arsort:
原陣列：';

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

print_r($a1);

echo '
結果：';

asort($a1);

print_r($a1);

#49.compact()函式建立一個由引數所帶變數組成的陣列。如果引數中存在陣列，該陣列中變數的值也被獲取

#本函式返回一個關聯陣列，鍵名為函式引數，鍵值為引數中變數的值；

#compact(var1,var2),中引數可以是帶變數名的字串，或者是一個變數陣列

#注：任何沒有變數名與之對應的字串都被略過

echo '

42.compact(var1,var2...):
結果：';

$first='LI';

$last='Huge';

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

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

print_r($arr);

#50.count():函式計算陣列彙總的單元數目或物件中屬性個數

#對於陣列返回其元素的個數，對於其他值，返回1.

#如果引數是變數，而變數沒定義，則返回0如果mode設定為COUNT_RECURSIVE(或1)，則會遞迴

echo '

43.count(array,mode):
原陣列：';

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

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

print_r($a1);

echo "
預設結果：";

echo count($a1);

echo "
檢測多維陣列結果：";

echo count($a1,COUNT_RECURSIVE);

#51.current():函式返回陣列中的當前元素

#每個陣列內部都有一個內部指標指向它當前的元素，初始指向插入到陣列中第一個元素

#該函式返回當前被內部指標指向的陣列元素，並不移動指標，如果內部指標指向超出了單元列表的末端

#，current()返回false

echo '

44.current（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

echo current($a1);

#51.each():函式生成一個由陣列內部指標所指向的元素的鍵名和鍵值組成的陣列，並把內部指標向前移動，如果內部指標越界返回false

#0,key指向當前陣列元素鍵名，1，value指向當前陣列元素的鍵值

echo '

45.each（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

print_r(each($a1));

#52.end():函式將陣列內部指標指向最後一個元素，並返回該元素的值（如果成功）

echo '

46.end（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

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 '

47.extract（）:
原陣列：';

$c='章魚';

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

print_r($a1);

echo "
預設結果：";

extract($a1);

echo $c.','.$d;

#54.in_array(value，arr,type):在陣列中搜尋給定的值

#如果type設定為true，則搜尋的值存在於陣列中並且型別相同時，才會返回true

echo '

48.in_array（）:
原陣列：';

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

print_r($a1);

$c=1;

echo "
結果1：";

echo in_array($c,$a1);

#55.key($arr):函式返回陣列中的當前元素的鍵值

echo '

49.key（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

echo key($a1);

#56.krsort(arr,sorttype):函式將陣列按鍵逆向排序，為陣列保留原來的鍵

echo '

50.krsort（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

krsort($a1);

print_r($a1);

#57.ksort(arr,sorttype):函式將陣列按鍵正向排序，為陣列保留原來的鍵

echo '

51.ksort（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

ksort($a1);

print_r($a1);

#58.list(var1，var2...):函式用陣列中的元素為一組變數賦值

#函式只用於數字索引陣列，切假定數字索引從0開始

echo '

52.list（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

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

echo $a;

#59.natcasesort()函式用不區分大小寫的自然順序演算法對給定陣列中元素排序

#自然排序：數字從1到9字母從a-z短者優先，該函式不區分大小寫。

#natcasesort是natsort不區分大小寫字母的版本

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

echo '

53.natcasesort（）:
原陣列：';

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

print_r($a1);

echo "
natsort結果：";

natsort($a1);

print_r($a1);

echo '
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 '

54.next（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

echo next($a1);

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

#62.prev(arr):同next（arr),函式把指向當前元素的指標移動到上一個元素的位置，並返回當前元素的值，

#注意事項同next

echo '

55.prev（）:
原陣列：';

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

print_r($a1);

echo "
結果：";

next($a1);

echo prev($a1);

#63.range(first,second,step):函式建立並返回一個包含指定範圍的元素的陣列

#first，陣列元素的最小值

#second，規定陣列元素的最大值

#step，規定元素之間的步進位制，預設是1

#該函式建立一個陣列，包含從first到second（包含first和second）之間的整數或

#字元，如果first比second小則返回反序的陣列

echo '

56.range（first,second,step）:
結果：';

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

print_r($a);

#64.reset(arr):函式把陣列內部指標指向第一個元素並返回這個元素的值

echo '

57.reset（arr）:
原陣列：';

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

print_r($a);

next($a);

echo '
當前值：';

echo current($a);

echo '
重置後：';

echo reset($a);

#65.rsort(arr,sorttype):函式對陣列的元素按照鍵值進行逆向排序，sorttype型別同asort

echo '

58.rsort（arr，storttype）:
原陣列：';

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

print_r($a);

echo '
結果：';

rsort($a);

print_r($a);

#66.shuffle()函式把陣列中的元素按隨機順序重新排列，若成功返回true，否則返回false

#注：本函式為陣列中單元賦予新的鍵名。這將刪除原有的鍵名而不僅是重新排序

echo '

59.shuffle（）:
原陣列：';

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

print_r($a1);

echo '
結果：';

shuffle($a1);

print_r($a1);

#67.sizeof(arr,mode):函式計算陣列中單元數目或物件中屬性個數，count()的別名

#68.sort()函式按升序對給定陣列的值進行排序,本函式為陣列的單元賦予新的鍵名，原有的鍵名將被刪除

echo '

60.sort（arr,sorttype）:
原陣列：';

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

print_r($a1);

echo '
結果：';

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

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

echo "
$a:$b
";

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 '

70.uasort,uksort,usort:
原陣列：';

print_r($a1);

echo '
uasort(array, cmp_function):';

uasort($a1,'myfun8');

print_r($a1);

echo '
uksort(array, cmp_function):';

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

uksort($a1,'myfun8');

print_r($a1);

echo '
usort(array, cmp_function):';

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

usort($a1,'myfun8');

print_r($a1);

php陣列函式小結

相關文章