header('content-type:text/html;charset=utf-8');
    //宣告一個數組
    $arr=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    var_dump($arr);

    //array_change_key_case — 返回[字串]鍵名全為小寫或[大寫]的陣列
    $result=array_change_key_case($arr,CASE_UPPER);
    var_dump($result);

    //array_chunk — 將一個[陣列]分割成[幾份][是否保留原陣列的鍵名true false]
 

    $result=array_chunk($arr,2,true);
    var_dump($result);

    //array_combine — 建立一個數組，用一個[陣列]的值作為其鍵名，另一個[陣列]的值作為其值
    $arr1=array(1,2,3,4,5,6);
    $arr2=array('one','two','three','four','five','six');
    $result=array_combine($arr1,$arr2);
    var_dump($result);

    //array_count_values — 統計[陣列]中所有的值出現的次數
 

    $arr=array(1,2,3,4,5,6,6,5,2,67,6,8,2,3,5,6,2,3,7);
    $result=array_count_values($arr);
    var_dump($result);

    //array_diff — 計算[陣列]與[陣列]的差集  求值的差集
    $arr1=array(1,2,4,5,6,7,8,4,3,5,6,6,7,9);
    $arr2=array(32,3,7,8,4,32,6,4,3,2,6,8,1);
    $result=array_diff($arr1,$arr2);
    var_dump($result);

    
 
//array_diff_key — 使用鍵名比較計算[陣列]與[陣列]的差  求鍵的差集
    $result=array_diff_key($arr1,$arr2);
    var_dump($result);

    //array_diff_assoc — 帶索引檢查計算[陣列]與[陣列]的差集 *(只有鍵值都相等才算相等)
    $result=array_diff_assoc($arr1,$arr2);
    var_dump($result);

    //array_intersect — 計算[陣列]與[陣列]的交集 求值的交集
    $result=array_intersect($arr1,$arr2);
    var_dump($result);

    //array_intersect_key — 使用鍵名比較計算[陣列]與[陣列]的交集
    $result=array_intersect_key($arr1,$arr2);
    var_dump($result);
    $result=array_intersect_key($arr2,$arr1);
    var_dump($result);

    //array_intersect_assoc — 帶索引檢查計算[陣列]與[陣列]的交集 *(只有鍵值都相等才算相等)
    $result=array_intersect_assoc($arr1,$arr2);
    var_dump($result);
    $result=array_intersect_assoc($arr2,$arr1);
    var_dump($result);

    //array_key_exists — 檢查給定的[鍵名]或索引是否存在於[陣列]中
    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_key_exists('two',$one);
    var_dump($result);//返回真假值 true->在

    //array_keys — 返回[陣列]中所有的鍵名
    $result=array_keys($one);
    var_dump($result);//返回的是一個由陣列下標作為值的索引陣列

    //array_values — 返回[陣列]中所有的值
    $result=array_values($one);
    var_dump($result);//返回的是一個由陣列de值作為值的索引陣列

    //array_merge_recursive — 遞迴地合併[一個]或[多個]陣列
//如果輸入的陣列中有相同的字串鍵名，則這些值會被合併到一個數組中去，這將遞迴下去，因此如果一個值本身是一個數組，本函式將按照相應的條目把它合併為另一個數組。然而，如果陣列具有相同的陣列鍵名，後一個值將不會覆蓋原來的值，而是附加到後面。 
    $one1=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $one2=['one'=>'111','two'=>'222','fly','three'=>array('one'=>'------','two'=>'======')];
    $one3=['one'=>'AAA','two'=>'BBB','three'=>array('one'=>'yiyiyi','two'=>'ererer'),'four'=>array('bed','bath')];
    $result=array_merge_recursive($one1,$one2,$one3);
    var_dump($result);

    $test1=['one'=>array('one'=>'111','two'=>'222'),'two'=>'22'];
    $test2=['one'=>array('one'=>'---','twoo'=>'==='),'two'=>'=='];
    $result=array_merge_recursive($test1,$test2);
    var_dump($result);

    //array_merge — 合併[一個]或[多個]陣列
    $demo1=[1,2,3];
    $demo2=[2,3,4];
    $result=array_merge($demo1,$demo2);
    var_dump($result);//如果只給了一個數組並且該陣列是數字索引的，則鍵名會以連續方式重新索引。 

    $demo1=['one'=>1,'aa',4];
    $demo2=[2,'one'=>3,4];
    $result=array_merge($demo1,$demo2);
    var_dump($result);//合併時，如果鍵值是字串且相等，則後面的鍵值會覆蓋前面的，如果是索引的鍵值則不會覆蓋

    //array_pop — 將[陣列]最後一個單元彈出（出棧）
    $demo1=[1,2,3];
    $result=array_pop($demo1);
    var_dump($result);//函式的返回值是陣列最後一個彈出的值
    var_dump($demo1);//檢視彈出後的陣列結構

    //array_push — 在原來的[陣列]中 將[一個]或[多個]單元壓入陣列的末尾（入棧）
    $result=array_push($demo1,5555,6666,'gdfsdf');
    var_dump($result);//返回陣列新的單元總數
    var_dump($demo1);//檢視壓入後的陣列結構

    //array_shift — 將[陣列]開頭的單元移出陣列
    $result=array_shift($demo1);
    var_dump($result);//函式的返回值是陣列第一個彈出的值
    var_dump($demo1);//檢視彈出後的陣列結構

    //array_unshift — 在[陣列]開頭插入[一個]或[多個]單元
    $result=array_unshift($demo1,'555','666','aaa');
    var_dump($result);//返回陣列新的單元總數
    var_dump($demo1);//檢視彈出後的陣列結構

    //array_slice — 從陣列中取出一段
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_slice($demo1,2);//從第2個開始往後取，即從第3個開始取        //從下標2開始取
    var_dump($result);
    $result=array_slice($demo1,0,3);//從第0個開始往後取，即從第1個開始取,取3個    //從下標0開始取
    var_dump($result);
    $result=array_slice($demo1,-4,2);//從倒數第4個開始  加上自身往後取1個        //從後取
    var_dump($result);
    $result=array_slice($demo1,2,-3);//從第2個開始往後取全部，即從第3個開始取，第三個引數如果為-1、-2、-3，則就從取出來的所有元素中去掉最後1、2、3個
    var_dump($result);
    $result=array_slice($demo1,2,-3,TRUE);//從第2個開始往後取全部，即從第3個開始取，第三個引數如果為-1、-2、-3，則就從取出來的所有元素中去掉最後1、2、3個
    var_dump($result);//array_slice() 預設將重置陣列的鍵,加上第四個引數TRUE就會使用原來的下標
echo '<hr color=red>';

    //array_splice — 把[陣列]中的哪一個[位置]的哪[一部分]去掉並用[其它值]取代
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,2);//從下標為2開始取，即從第3個開始取
    var_dump($result);//返回一個包含被移除單元的陣列
    var_dump($demo1);//新陣列
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,1,-1);//從左側下標1開始取 若第二引數為-則就從後往前取 -1為捨去最後一個
    var_dump($result);//返回一個包含被移除單元的陣列
    var_dump($demo1);//新陣列
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,1,count($demo1),'hhhhhhhhhh');//從左側下標1開始取 
    var_dump($result);;//返回一個包含被移除單元的陣列
    var_dump($demo1);//新陣列
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,-1,2,array(111,222));//從右側開始往後取 
    var_dump($result);;//返回一個包含被移除單元的陣列
    var_dump($demo1);//新陣列
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,1,0,array(111,222));//從右側開始往後取 
    var_dump($result);;//返回一個包含被移除單元的陣列
    var_dump($demo1);//新陣列 注意新加入的元素在'aaa'後面 !!!!!!!!

echo '<hr color=red>';
/*
    echo '<hr>';
    //array_reverse — 返回一個單元順序相反的陣列
    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_reverse($one);//返回一個相反的陣列    //關聯陣列不適合
    var_dump($result);

    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_reverse($one,true);//第二個引數如果設定為true 返回一個相反的保留之前的鍵的陣列????????????????????????????????????????????????????????????
    var_dump($result);
 */
    echo '<hr>';
    //array_reverse — 返回一個單元順序[相反]的[true 保留之前的鍵的索引]陣列
    $one=['aaa','bbb','ccc','ddd'];
    $result=array_reverse($one);//返回一個相反的陣列 只適合於索引陣列 只有值相反
    var_dump($result);

    $one=['aaa','bbb','ccc','ddd'];
    $result=array_reverse($one,true);//第二個引數如果設定為true 返回一個相反的保留之前的鍵的陣列 只適合於索引陣列 值鍵全相反
    var_dump($result);

echo '<hr color=red>';
    //array_rand — 從[陣列]中隨機取出[一個或多個單元]
    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_rand($one);//沒有指定第二個引數，預設隨機取出一個
    var_dump($result);
    $result=array_rand($one,3);//指定第二個引數，預設隨機取出3個
    var_dump($result);

    //array_product — 計算[陣列]中所有值的乘積
    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_product($one);//如果鍵值為字串，則所有鍵值相乘結果為0
    var_dump($result);
    $one=['one'=>'1','two'=>'1','three'=>'2','four'=>'3'];
    $result=array_product($one);//返回6
    var_dump($result);

    //array_sum — 計算[陣列]中所有值的和
    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_sum($one);//如果鍵值為字串，則所有鍵值相jia結果為0
    var_dump($result);
    $one=['one'=>'1','two'=>'1','three'=>'2','four'=>'3'];
    $result=array_sum($one);//返回7
    var_dump($result);

    //array_pad — 將[陣列]填補到[指定長度][用值]
    $demo=['one'=>'a','b','three'=>'c'];
    $result=array_pad($demo,6,'aaa');//如果第二引數為正，側從最後按照第三個引數作為鍵值開始補夠指定的數目  注意：預設按照索引方式新增
    var_dump($result);
    $result=array_pad($demo,-6,'a-6');//如果第二引數為-，側從最開始按照第三個引數作為鍵值開始補夠指定的數目  注意：預設按照索引方式新增
    var_dump($result);
    $result=array_pad($demo,2,'a-6');//如果第二引數的值小於陣列的長度，則不會新增
    var_dump($result);

    //array_unique — 移除[陣列]中重複的值
    $arr=array(1,2,3,4,5,6,6,5,2,67,6,8,2,3,5,6,2,3,7);
    $result=array_unique($arr);
    var_dump($result);

    //count — 計算[陣列]中的單元數目或物件中的屬性個數
    $arr=array(1,2,3,4,5,6,6,5,2,67,6,8,2,3,5,6,2,3,7);
    $result=count($arr);
    var_dump($result);

    //in_array — 檢查[某個值]是否存在[陣列]中[true 值和型別全部相同]
    $demo=['one'=>'a','666','three'=>'c'];
    $result=in_array(666,$demo);//返回的是布林值真假 注意變數在後
    var_dump($result);
    $result=in_array(666,$demo,true);//返回的是布林值真假 注意變數在後  第三引數加上true之後會判斷指定的值的型別是否也和陣列中存在的相同值的型別相同
    var_dump($result);

echo '<hr color=red>';
    //key — 從關聯陣列中取得鍵名!!!!!!!!!!!key() 返回[陣列]中當前單元的鍵名!!!!!!!!!!!!!!!!!!!!!!!!!!!
    $demo=['one'=>'a','three'=>'c'];
    $result=current($demo);//current — 返回陣列中的當前單元
    if($result=='a'){
        echo key($demo);
    }
echo '<hr color=red>';
    //shuffle — 將[陣列]打亂
    $one1=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=shuffle($one1);
    var_dump($result);//返回的是布林型別
    var_dump($one1);//打亂並刪除原有的鍵值 並組合成新的索引陣列

    //range — 建立一個包含指定範圍[小數值][大數值][階梯值]單元的陣列
    $arr=array(1,3,6,1,5,6,6,5,2,67,6,8,2,3,5,6,2,3,7);
    $result=range(1,2);//注意 只會返回在這個範圍內的單個值 就是如果陣列在這個範圍內有多個相同的值，只會返回一個
    var_dump($result);
    $result=range(3,7,2);//注意 ruo指定了至三個引數 就是在前面範圍的基礎上按照每次加n(為正值)再次縮小範圍
    var_dump($result);

    //sort — 對[陣列]其值排序（針對其值進行排序）
    $arr=array(1,3,6,1,5,6,6,5,2,67,6,8,2,3,5,6,2,3,7);
    $result=sort($arr);
    var_dump($result);//返回布林值型別
    var_dump($arr);//對原陣列刪除鍵值並進行重新排序

    //rsort — 對[陣列]其值逆向排序（針對其值進行逆向排序）
    $arr=array(1,3,6,1,5,6,6,5,2,67,6,8,2,3,5,6,2,3,7);
    $result=rsort($arr);
    var_dump($result);//返回布林值型別
    var_dump($arr);//對原陣列刪除鍵值並進行重新逆向排序
echo '<hr color=red>';
    //ksort — 對[陣列]按照鍵名排序（針對關聯陣列）
    $one1=['a'=>'aaa','b'=>'bbb','d'=>'ddd','c'=>'ccc'];//如何比較字串的大小!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    $result=ksort($one1);
    var_dump($result);//返回布林值型別
    var_dump($one1);//對原陣列鍵值進行排序
echo '<hr color=red>';
    //krsort — 對[陣列]按照鍵名逆向排序
    $one1=['a'=>'aaa','b'=>'bbb','c'=>'ccc','d'=>'ddd'];
    $result=krsort($one1);
    var_dump($result);//返回布林值型別
    var_dump($one1);//對原陣列鍵值進行排序

echo '<hr>';
$aaa='aaa';
$bbb='bbb';
if($aaa>$bbb){
    echo 'aaa大於bbb';
}else{
    echo 'aaa小於bbb';
}



echo '<hr color=red size=15>';
//-----------------------------補充-----------補充-------------補充--------------補充---------------補充-----------------------補充-------------------------補充



//array宣告一個數組
    $arr=array(1,2,3);
    var_dump($arr);
    echo '<hr>';

//compact — 用已賦值的一個[變數名]和已賦值的另n個[變數名]建立一個數組，陣列中包括變數名和它們的值   [變數名]可以是一個[陣列變數名]
    
    $name='machong';
    $sex='nan';
    $result=compact('name','sex');
    var_dump($result);

    
    $name2='machong';
    $sex2='nan';
    $play2='lanqiu';
    $work2='study';
    $hobby2=['play2','work2'];
    $result=compact('name2','sex2',$hobby2);//注意[變數名]可以是一個[陣列變數名],但是在宣告該陣列時,陣列變數名對應的陣列內部的鍵值必須是在外部已經宣告過的變數名稱
    var_dump($result);//                                                    變數可以為空

    $name3='machong';
    $sex3='nan';
    $play3='lanqiu';
    $work3='study';
    $hobby3=['play3','work3'];
    $personInfo3=array('name3','sex3');
    $result=compact($personInfo3,$hobby3);//注意[變數名]可以是一個[陣列變數名],但是在宣告該陣列時,陣列變數名對應的陣列內部的鍵值必須是在外部已經宣告過的變數名稱
    var_dump($result);

    echo '<hr>';

//array_fill 從[指定的鍵INT]開始填充多少[數目] [用什麼填充]
/*    //不適合關聯陣列 不是對原陣列進行填充--->相當於新建一個數組
    $one1=['a'=>'aaa','b'=>'bbb','c'=>'ccc','d'=>'ddd'];
    $result=array_fill('b',2,'fff');
    var_dump($result);
 */
/*
    $result=array_fill('b',2,'fff');//第一個引數指定為隨意的關聯陣列的鍵值無效--->一個引數必須是整型 即為手冊上的int型別
    var_dump($result);
 */
    $result=array_fill(2,2,'fff');//第一個引數規定必須為整型-->必須是索引陣列
    var_dump($result);

    echo '<hr>';

//array_search — 搜尋給定的[值]在[陣列]中,是否[值和型別必須都相等]true/false，如果成功返回其鍵名  注意值如果是字串 此種方式是嚴格區分大小寫的比較
    $arr1=[1,2,3,4,5,6,7,8,9];
    $arr2=['name'=>'maChong','age'=>'25','sex'=>'man'];

    echo array_search(3,$arr1).'<br>';//返回下標2
    echo array_search('man',$arr2).'<br>';//返回鍵 man
    var_dump(array_search('machong',$arr2)).'<br>';//嚴格區分大小寫 返回空->false----在 PHP 4.2.0 之前，array_search() 在失敗時返回 NULL 而不是 FALSE。
    echo array_search(25,$arr2).'<br>';//不比較型別的 返回下標age
    var_dump(array_search(25,$arr2,true));//加入第三個引數 嚴格區分值的型別的比較  只有都相等才返回  否則返回空 false
    echo '<hr>';
//current — 返回[陣列]中的當前單元
    $arr2=['name'=>'maChong','age'=>'25','sex'=>'man'];//預設第一個元素為當前單元
    echo current($arr2).'<br>';
//next — 將[陣列]中的內部指標向前移動一位 
    echo next($arr2).'<br>';//把當前單元向後移動到下一個單元 並返回其值
//prev — 將[陣列]的內部指標倒回一位
    echo prev($arr2).'<br>';//把當前單元向前移動到上一個單元 並返回其值
//end — 將[陣列]的內部指標指向最後一個單元 
    echo end($arr2).'<br>';//把當前單元向後移動到最後一個單元 並返回其值
//reset — 將陣列的內部指標指向第一個單元
    echo reset($arr2).'<hr>';//把當前單元重置為一個單元 並返回其值
//list — 把一些[變數][變數]....等於索引陣列中的值  注意此陣列必須是索引陣列，並且是從0開始的 
    $arr=['machong','25','man','work'];
    list($name,$age,$sex,$hobby)=$arr;
    echo $name.'的年齡是'.$age.'<br>';
    echo $name.'的性別是'.$sex.'<br>';
    echo $name.'的愛好是'.$hobby.'<hr>';


//array_flip — 交換[陣列]中的鍵和值  注意因為陣列的鍵型別只有INT和str鍵值型別都可以  所以在反轉的時候 要保證原陣列的鍵值裡面不能出現int和str之外的型別，否則會出現警告，另外如果需要反轉的原陣列中如果存在相同的鍵值，翻轉後，其下標是相同的，所以後面的下標會覆蓋前面的，只返回後面的下標作為翻轉後的值
    $arr=[1,2,3,4,5,6,7,8,9];
    $arr1=['name'=>'machong','name1'=>'machong','age'=>'25','hobby'=>array(),'resource'=>fopen('aaaaaaa.tex','w')];
    var_dump($arr1);

    var_dump(array_flip($arr1));



//asort — 對[陣列]進行排序並保持索引關係    返回的是布林型的真假  
    $one1=['b'=>'bbb','a'=>'aaa','c'=>'ccc','d'=>'ddd'];
    var_dump(asort($one1));//true
    var_dump($one1);

    //第二個引數為可選引數!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //■SORT_REGULAR - 正常比較單元（不改變型別） 
    //■SORT_NUMERIC - 單元被作為數字來比較 
    //■SORT_STRING - 單元被作為字串來比較 
    //■SORT_LOCALE_STRING - 根據當前的區域（locale）設定來把單元當作字串比較。PHP 4.4.0 和 5.0.2 新加。在 PHP 6 之前，使用了系統的區域設定，可以用 setlocale() 來改變。自 PHP 6 起，必須用 i18n_loc_set_default() 函式。 

//arsort — 對[陣列]進行逆向排序並保持索引關係 

    $one1=['b'=>'bbb','a'=>'aaa','c'=>'ccc','d'=>'ddd'];
    var_dump(arsort($one1));
    var_dump($one1);

    //第二個引數為可選引數!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //■SORT_REGULAR - 正常比較單元（不改變型別） 
    //■SORT_NUMERIC - 單元被作為數字來比較 
    //■SORT_STRING - 單元被作為字串來比較 
    //■SORT_LOCALE_STRING - 根據當前的區域（locale）設定來把單元當作字串比較。PHP 4.4.0 和 5.0.2 新加。在 PHP 6 之前，使用了系統的區域設定，可以用 setlocale() 來改變。自 PHP 6 起，必須用 i18n_loc_set_default() 函式。 


//natsort — 用“自然排序”演算法對[陣列]排序 
    $arr=['machong1.jpg','machong12.jpg','machong2.jpg','machong23.jpg'];
    sort($arr);
    var_dump($arr);
    natsort($arr);
    var_dump($arr);

//natcasesort — 用“自然排序”演算法對[陣列]進行不區分大小寫字母的排序 

$arr=['machong1.jpg','maChong12.jpg','macHong2.jpg','Machong23.jpg'];
    natsort($arr);//區分大小寫比較
    var_dump($arr);
    natcasesort($arr);//不區分大小寫比較
    var_dump($arr);

//array_change_key_case — 返回[字串]鍵名全為小寫或[大寫]的陣列

    //array_chunk — 將一個[陣列]分割成[幾份][是否保留原陣列的鍵名true false]

    //array_combine — 建立一個數組，用一個[陣列]的值作為其鍵名，另一個[陣列]的值作為其值

    //array_count_values — 統計[陣列]中所有的值出現的次數

    //array_diff — 計算[陣列]與[陣列]的差集  求值的差集

    //array_diff_key — 使用鍵名比較計算[陣列]與[陣列]的差  求鍵的差集

    //array_diff_assoc — 帶索引檢查計算[陣列]與[陣列]的差集 *(只有鍵值都相等才算相等)

    //array_intersect — 計算[陣列]與[陣列]的交集 求值的交集
    
    //array_intersect_key — 使用鍵名比較計算[陣列]與[陣列]的交集

    //array_intersect_assoc — 帶索引檢查計算[陣列]與[陣列]的交集 *(只有鍵值都相等才算相等)
    
    //array_key_exists — 檢查給定的[鍵名]或索引是否存在於[陣列]中
    
    //array_keys — 返回[陣列]中所有的鍵名
    
    //array_values — 返回[陣列]中所有的值
    
    //array_merge_recursive — 遞迴地合併[一個]或[多個]陣列

    //array_merge — 合併[一個]或[多個]陣列
    
    //array_pop — 將[陣列]最後一個單元彈出（出棧）
    
    //array_push — 在原來的[陣列]中 將[一個]或[多個]單元壓入陣列的末尾（入棧）

    //array_shift — 將[陣列]開頭的單元移出陣列

    //array_unshift — 在[陣列]開頭插入[一個]或[多個]單元

    //array_slice — 從陣列中取出一段

    //array_splice — 把[陣列]中的哪一個[位置]的哪[一部分]去掉並用[其它值]取代
    
    //array_reverse — 返回一個單元順序[相反]的[true 保留之前的鍵的索引]陣列

    //array_rand — 從[陣列]中隨機取出[一個或多個單元]

    //array_product — 計算[陣列]中所有值的乘積

    //array_sum — 計算[陣列]中所有值的和

    //array_pad — 將[陣列]填補到[指定長度][用值]

    //array_unique — 移除[陣列]中重複的值

    //count — 計算[陣列]中的單元數目或物件中的屬性個數
    
    //in_array — 檢查[某個值]是否存在[陣列]中[true 值和型別全部相同]

    //key — 從關聯陣列中取得鍵名!!!!!!!!!!!key() 返回[陣列]中當前單元的鍵名!!!!!!!!!!!!!!!!!!!!!!!!!!!

    //shuffle — 將[陣列]打亂

    //range — 建立一個包含指定範圍[小數值][大數值][階梯值]單元的陣列

    //sort — 對[陣列]其值排序（針對其值進行排序）

    //rsort — 對[陣列]其值逆向排序（針對其值進行逆向排序）

    //ksort — 對[陣列]按照鍵名排序（針對關聯陣列）

    //krsort — 對[陣列]按照鍵名逆向排序


//array宣告一個數組

//compact — 用已賦值的一個[變數名]和已賦值的另n個[變數名]建立一個數組，陣列中包括變數名和它們的值   [變數名]可以是一個[陣列變數名]
    


//array_fill 從[指定的鍵INT]開始填充多少[數目] [用什麼填充]

//array_search — 搜尋給定的[值]在[陣列]中,是否[值和型別必須都相等]true/false，如果成功返回其鍵名  注意值如果是字串 此種方式是嚴格區分大小寫的比較

//current — 返回[陣列]中的當前單元

//next — 將[陣列]中的內部指標向前移動一位 
    
//prev — 將[陣列]的內部指標倒回一位

//end — 將[陣列]的內部指標指向最後一個單元 

//reset — 將陣列的內部指標指向第一個單元

//list — 把一些[變數][變數]....等於索引陣列中的值  注意此陣列必須是索引陣列，並且是從0開始的 

//array_flip — 交換[陣列]中的鍵和值  注意因為陣列的鍵型別只有INT和str鍵值型別都可以  所以在反轉的時候 要保證原陣列的鍵值裡面不能出現int和str之外的型別，否則會出現警告，另外如果需要反轉的原陣列中如果存在相同的鍵值，翻轉後，其下標是相同的，所以後面的下標會覆蓋前面的，只返回後面的下標作為翻轉後的值

//asort — 對[陣列]進行排序並保持索引關係    返回的是布林型的真假  

//arsort — 對[陣列]進行逆向排序並保持索引關係 

//natsort — 用“自然排序”演算法對[陣列]排序 

//natcasesort — 用“自然排序”演算法對[陣列]進行不區分大小寫字母的排序