常用的数组函数-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,,true);
    var_dump($result);

    //array_combine — 创建一个数组，用一个[数组]的值作为其键名，另一个[数组]的值作为其值
    $arr1=array(,,,,,);
    $arr2=array('one','two','three','four','five','six');
    $result=array_combine($arr1,$arr2);
    var_dump($result);

    //array_count_values — 统计[数组]中所有的值出现的次数
    $arr=array(,,,,,,,,,,,,,,,,,,);
    $result=array_count_values($arr);
    var_dump($result);

    //array_diff — 计算[数组]与[数组]的差集  求值的差集
    $arr1=array(,,,,,,,,,,,,,);
    $arr2=array(,,,,,,,,,,,,);
    $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'=>'','two'=>'','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'=>'','two'=>''),'two'=>''];
    $test2=['one'=>array('one'=>'---','twoo'=>'==='),'two'=>'=='];
    $result=array_merge_recursive($test1,$test2);
    var_dump($result);

    //array_merge — 合并[一个]或[多个]数组
    $demo1=[,,];
    $demo2=[,,];
    $result=array_merge($demo1,$demo2);
    var_dump($result);//如果只给了一个数组并且该数组是数字索引的，则键名会以连续方式重新索引。 

    $demo1=['one'=>,'aa',];
    $demo2=[,'one'=>,];
    $result=array_merge($demo1,$demo2);
    var_dump($result);//合并时，如果键值是字符串且相等，则后面的键值会覆盖前面的，如果是索引的键值则不会覆盖

    //array_pop — 将[数组]最后一个单元弹出（出栈）
    $demo1=[,,];
    $result=array_pop($demo1);
    var_dump($result);//函数的返回值是数组最后一个弹出的值
    var_dump($demo1);//查看弹出后的数组结构

    //array_push — 在原来的[数组]中 将[一个]或[多个]单元压入数组的末尾（入栈）
    $result=array_push($demo1,,,'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,'','','aaa');
    var_dump($result);//返回数组新的单元总数
    var_dump($demo1);//查看弹出后的数组结构

    //array_slice — 从数组中取出一段
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_slice($demo1,);//从第2个开始往后取，即从第3个开始取        //从下标2开始取
    var_dump($result);
    $result=array_slice($demo1,,);//从第0个开始往后取，即从第1个开始取,取3个    //从下标0开始取
    var_dump($result);
    $result=array_slice($demo1,-,);//从倒数第4个开始  加上自身往后取1个        //从后取
    var_dump($result);
    $result=array_slice($demo1,,-);//从第2个开始往后取全部，即从第3个开始取，第三个参数如果为-1、-2、-3，则就从取出来的所有元素中去掉最后1、2、3个
    var_dump($result);
    $result=array_slice($demo1,,-,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开始取，即从第3个开始取
    var_dump($result);//返回一个包含被移除单元的数组
    var_dump($demo1);//新数组
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,,-);//从左侧下标1开始取 若第二参数为-则就从后往前取 -1为舍去最后一个
    var_dump($result);//返回一个包含被移除单元的数组
    var_dump($demo1);//新数组
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,,count($demo1),'hhhhhhhhhh');//从左侧下标1开始取
    var_dump($result);;//返回一个包含被移除单元的数组
    var_dump($demo1);//新数组
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,-,,array(,));//从右侧开始往后取
    var_dump($result);;//返回一个包含被移除单元的数组
    var_dump($demo1);//新数组
echo '<hr>';
    $demo1=['aaa','bbb','ccc','ddd','eee','fff','ggg'];
    $result=array_splice($demo1,,,array(,));//从右侧开始往后取
    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个
    var_dump($result);

    //array_product — 计算[数组]中所有值的乘积
    $one=['one'=>'aaa','two'=>'bbb','three'=>'ccc','four'=>'ddd'];
    $result=array_product($one);//如果键值为字符串，则所有键值相乘结果为0
    var_dump($result);
    $one=['one'=>'','two'=>'','three'=>'','four'=>''];
    $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'=>'','two'=>'','three'=>'','four'=>''];
    $result=array_sum($one);//返回7
    var_dump($result);

    //array_pad — 将[数组]填补到[指定长度][用值]
    $demo=['one'=>'a','b','three'=>'c'];
    $result=array_pad($demo,,'aaa');//如果第二参数为正，侧从最后按照第三个参数作为键值开始补够指定的数目  注意：默认按照索引方式添加
    var_dump($result);
    $result=array_pad($demo,-,'a-6');//如果第二参数为-，侧从最开始按照第三个参数作为键值开始补够指定的数目  注意：默认按照索引方式添加
    var_dump($result);
    $result=array_pad($demo,,'a-6');//如果第二参数的值小于数组的长度，则不会添加
    var_dump($result);

    //array_unique — 移除[数组]中重复的值
    $arr=array(,,,,,,,,,,,,,,,,,,);
    $result=array_unique($arr);
    var_dump($result);

    //count — 计算[数组]中的单元数目或对象中的属性个数
    $arr=array(,,,,,,,,,,,,,,,,,,);
    $result=count($arr);
    var_dump($result);

    //in_array — 检查[某个值]是否存在[数组]中[true 值和类型全部相同]
    $demo=['one'=>'a','','three'=>'c'];
    $result=in_array(,$demo);//返回的是布尔值真假 注意变量在后
    var_dump($result);
    $result=in_array(,$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(,,,,,,,,,,,,,,,,,,);
    $result=range(,);//注意 只会返回在这个范围内的单个值 就是如果数组在这个范围内有多个相同的值，只会返回一个
    var_dump($result);
    $result=range(,,);//注意 ruo指定了至三个参数 就是在前面范围的基础上按照每次加n(为正值)再次缩小范围
    var_dump($result);

    //sort — 对[数组]其值排序（针对其值进行排序）
    $arr=array(,,,,,,,,,,,,,,,,,,);
    $result=sort($arr);
    var_dump($result);//返回布尔值类型
    var_dump($arr);//对原数组删除键值并进行重新排序

    //rsort — 对[数组]其值逆向排序（针对其值进行逆向排序）
    $arr=array(,,,,,,,,,,,,,,,,,,);
    $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(,,);
    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(,,'fff');//第一个参数规定必须为整型-->必须是索引数组
    var_dump($result);

    echo '<hr>';

//array_search — 搜索给定的[值]在[数组]中,是否[值和类型必须都相等]true/false，如果成功返回其键名  注意值如果是字符串 此种方式是严格区分大小写的比较
    $arr1=[,,,,,,,,];
    $arr2=['name'=>'maChong','age'=>'','sex'=>'man'];

    echo array_search(,$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(,$arr2).'<br>';//不比较类型的 返回下标age
    var_dump(array_search(,$arr2,true));//加入第三个参数 严格区分值的类型的比较  只有都相等才返回  否则返回空 false
    echo '<hr>';
//current — 返回[数组]中的当前单元
    $arr2=['name'=>'maChong','age'=>'','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','','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=[,,,,,,,,];
    $arr1=['name'=>'machong','name1'=>'machong','age'=>'','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 — 用“自然排序”算法对[数组]进行不区分大小写字母的排序