經常使用的數組函數-S

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個開始取，第三個參數若是爲-一、-二、-3，則就從取出來的全部元素中去掉最後一、二、3個
    var_dump($result);
    $result=array_slice($demo1,2,-3,TRUE);//從第2個開始日後取所有，即從第3個開始取，第三個參數若是爲-一、-二、-3，則就從取出來的全部元素中去掉最後一、二、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 — 用「天然排序」算法對[數組]進行不區分大小寫字母的排序