PHP数组

作者: 竹与豆 | 来源:发表于2018-08-13 08:15 被阅读33次

一、数组定义

array()

1、索引数组

在一个变量中，存储一个或多个值。数组中的每一个元素都有一个访问ID，根据ID获取对应元素。

$arr = array("刘海","JS","28","1989-09-09");
print_r($arr);

//Array ( [0] => 刘海 [1] => JS [2] => 28 [3] => 1989-09-09 )
//每一个元素都有一个索引id(下标)，从0开始。

//根据索引取值
echo "姓名:".$arr[0]."<br/>";
echo "课程:".$arr[1]."<br/>";
echo "年龄:".$arr[2]."<br/>";
echo "出生:".$arr[3]."<br/>";
/*
姓名:刘海
课程:JS
年龄:28
出生:1989-09-09
*/

一般用来存放相同类型的数据，或者相同类别数据，相当于一个简单的数据集合。

2、关联数组

array("key"=>"value") 给值关联相对名称。可以通过名称获取对应的值，对应的是字典类型(key->value)。

$arr = array("uname"=>"刘海","age"=>"23","birth"=>"1995-09-09");
print_r($arr);
//Array ( [uname] => 刘海 [age] => 23 [birth] => 1995-09-09 ) 

echo "<br/>";
echo "姓名：".$arr["uname"]."<br/>";
echo "年龄：".$arr["age"]."<br/>";
echo "出生：".$arr["birth"]."<br/>";
/*
姓名：刘海
年龄：23
出生：1995-09-09
*/

3、多维数组

$arr1 = array("uname"=>"刘海","age"=>"23","birth"=>"1995-09-09");
$arr2 = array("uname"=>"张文","age"=>"33","birth"=>"1985-09-09");
$arr = array($arr1,$arr2);
echo "<pre>"; //格式化打印
print_r($arr);

/*
Array
(
    [0] => Array
        (
            [uname] => 刘海
            [age] => 23
            [birth] => 1995-09-09
        )

    [1] => Array
        (
            [uname] => 张文
            [age] => 33
            [birth] => 1985-09-09
        )

)
*/

4、数组定义方式

//>>>>>>>>>>>>>>>>
$arr1 = array("uname"=>"刘海","age"=>"23","birth"=>"1995-09-09");
    print_r($arr1);
/*
Array
(
    [uname] => 刘海
    [age] => 23
    [birth] => 1995-09-09
)
*/

//>>>>>>>>>>>>>>>>
$arr2 = array("first","second","third");
print_r($arr2);
    /*
Array
(
    [0] => first
    [1] => second
    [2] => third
)
    */
    
//>>>>>>>>>>>>>>>>
$arr3[0] = "姓名";
$arr3[1] = "年龄";
$arr3[3] = "出生";
print_r($arr3);

    /*
Array
(
    [0] => 姓名
    [1] => 年龄
    [3] => 出生
)
    */
    
//>>>>>>>>>>>>>>>>
$arr4[] = "PHP";
$arr4[] = "JS";
$arr4[] = "HTML";
print_r($arr4);
/*
Array
(
    [0] => PHP
    [1] => JS
    [2] => HTML
)
*/

//>>>>>>>>>>>>>>>>
$arr5["first"] = "PHP";
$arr5["second"] = "JS";
$arr5["third"] = "HTML";
print_r($arr5);
    /*
Array
(
    [first] => PHP
    [second] => JS
    [third] => HTML
)
    */
    
//>>>>>>>>>>>>>>>>
//多维数组
$arr5["PHP"] = array();
$arr5["PHP"][] = "基础知识";
$arr5["PHP"][] = "字符串";
$arr5["PHP"][] = "图像处理";
$arr5["PHP"][] = "数据库";

$arr5["DIV"] = array();
$arr5["DIV"][] = "HTML";
$arr5["DIV"][] = "CSS布局";
$arr5["DIV"][] = "hack技术";
$arr5["DIV"][] = "整站开发";
print_r($arr5);

/*
Array
(
    [first] => PHP
    [second] => JS
    [third] => HTML
    [PHP] => Array
        (
            [0] => 基础知识
            [1] => 字符串
            [2] => 图像处理
            [3] => 数据库
        )

    [DIV] => Array
        (
            [0] => HTML
            [1] => CSS布局
            [2] => hack技术
            [3] => 整站开发
        )
)
*/

5、函数定义数组

1、array_fill(index,number,value);函数用给定的值填充数组，返回的数组有 number 个元素，值为 value。返回的数组使用数字索引，从 start 位置开始并递增。如果 number 为 0 或小于 0，就会出错。

$arr = array_fill(30,2,"xxxx");
print_r($arr);

/*
Array
(
    [30] => xxxx
    [31] => xxxx
)
*/

2、range()生成包含指定范围的数组

range(low,high,step)生成从low开始到high步长为step的数字数组。步长不设置默认为1.

echo "<pre/>";
$arr = range(1, 12 ,2);
print_r($arr);

/*
Array
(
    [0] => 1
    [1] => 3
    [2] => 5
    [3] => 7
    [4] => 9
    [5] => 11
)
*/

echo "<pre/>";
$arr = range(1, 12 );
$arr1 = range(1,20);
echo "<table style='width:800px;' cellspacing=1 cellpadding=2>";
foreach ($arr as $key) {
    echo "<tr>";
        foreach ($arr1 as $value) {
            echo "<td style='border:solid 1px #ccc;'>{$value}</td>";
        }
    echo "</tr>";
}
    
echo "</table>";

[图片上传失败...(image-721078-1534119315799)]

6、读取数组

foreach($arr as $key => $value)

索引数组

//索引数组
$arr = array("PHP","实战课程","学以致用");
foreach ($arr as $value) {

    //echo "<span style='color:#f00;border:solid 2px #ccc;display:block; padding:3px;'>
    ".$value."</span>";
    echo $value."<br/>";
}

/*
PHP
实战课程
学以致用
*/

关联数组


$arr = array("名称"=>"PHP","性质"=>"实战课程","主题"=>"学以致用");
foreach ($arr as $key => $value) {
    echo $key.":".$value."<br/>";
}
/*
名称:PHP
性质:实战课程
主题:学以致用
*/

嵌套数组

$arr5["PHP"] = array();
$arr5["PHP"]["first"] = "基础知识";
$arr5["PHP"]["second"] = "字符串";
$arr5["PHP"]["third"] = "图像处理";

$arr5["DIV"] = array();
$arr5["DIV"]["first"] = "HTML";
$arr5["DIV"]["second"] = "CSS布局";
$arr5["DIV"]["third"] = "hack技术";

$arr5["HTML"] = "HTML";
$arr5["JS"] = "js,jquery";

foreach ($arr5 as $key => $value) {
    if (is_array($value)) {
        echo $key.":<br>";
        foreach ($value as $k => $v) {
            echo "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;".$k."=>".$v."<br/>";
        }
    } else {
        echo $key."=>".$value;
    }
    echo "<br/>";
}
/*
PHP:
     first=>基础知识
     second=>字符串
     third=>图像处理

DIV:
     first=>HTML
     second=>CSS布局
     third=>hack技术

HTML=>HTML
JS=>js,jquery
*/

foreach ($arr5 as $key => $value) {
    if (is_array($value)) {
        echo $key."<br/>";
        echo "&nbsp;&nbsp;$nbsp"."first:".$value["first"]."  second".$value["second"];
    } else {
        echo $key."=>".$value;
    }
    echo "<br/>";
}

/*
PHP
  first:基础知识 second字符串
DIV
  first:HTML secondCSS布局
HTML=>HTML
JS=>js,jquery
*/

二、数组处理函数

(一) 数组与字符串

implode($str,"分隔符") 数组元素通过分隔符组合成字符串。

explode("分隔符", $str);通过分割符将数组拆分成数组。

$file = array("/upload/a1.jpg","/upload/a2.jpg","/upload/a3.jpg",);
print_r($file)."<br/>";
$files = implode($file, ",");
echo $files."<br/>";
$arr2 = explode(",", $files);

print_r($arr2);

/*
Array ( [0] => /upload/a1.jpg [1] => /upload/a2.jpg [2] => /upload/a3.jpg ) /upload/a1.jpg,/upload/a2.jpg,/upload/a3.jpg
Array ( [0] => /upload/a1.jpg [1] => /upload/a2.jpg [2] => /upload/a3.jpg )
*/

(二) 判断数组元素

in_array(元素,$arr,类型是否一致) 验证元素是否在数组中。第三个参数指明是否需要判断类型，默认FALSE，不设置。

$arr = array(1,2,3,4,5,6);

var_dump(in_array(22, $arr));//bool(false) 
echo "<br/>";
var_dump(in_array("1", $arr));//bool(true) 
echo "<br/>";
var_dump(in_array("1", $arr,TRUE));//bool(false)

(三) 将数组拆分成新数组

each() 把数组元素拆分为新的数组。此函数每次取出一个元素，重复调用可移动获取下一个元素，直到最后结束返回bool(false)。返回内容：0和key是原数组元素的键名或索引，1和value是原数组元素的值。格式如下：

Array
(
    [1] => "元素的值"
    [value] => "元素的值"
    [0] => "元素的键"/索引值
    [key] => "元素的键"/索引值
)

echo "<pre>";
$arr = array("url"=>"www.baidu.com","name"=>"百度");
// $arr = array("www.baidu.com","百度");
print_r($arr);
echo "<br/>";
$arr1 = each($arr); 
print_r($arr1);
$arr1 = each($arr); 
print_r($arr1);
    
var_dump(each($arr));//结尾返回bool(false)

/*
Array
(
    [url] => www.baidu.com
    [name] => 百度
)

Array
(
    [1] => www.baidu.com
    [value] => www.baidu.com
    [0] => url
    [key] => url
)
Array
(
    [1] => 百度
    [value] => 百度
    [0] => name
    [key] => name
)
bool(false)

*/

(四) 把数组元素赋值给变量

list() 将索引数组的元素，赋值给变量。只能操作索引数组。

$arr = array("www.baidu.com","百度","测试数据");
list($url,$name) = $arr; //只对索引数组有效果
echo $url,$name;
echo "<br/>";

//www.baidu.com百度

对于关联数组，可通过each()函数拆分数组之后，再通过list()将值赋值给变量。

$arr = array("url"=>"www.baidu.com","name"=>"百度");  
list($key,$value) = each($arr);
echo $key,$value;

//url www.baidu.com 
// 新数组的 索引为0和1的元素。即为关联数组元素的key和value。

根据each()函数特性，可以取出关联数组中所有的元素。

$arr = array("url"=>"www.baidu.com","name"=>"百度");  
while (list($key,$value) = each($arr)) {
    echo $key."=>".$value;  
    echo "<br/>";
}
/*
url=>www.baidu.com
name=>百度
*/

(五) 统计函数

1、count($arr, 标记)统计数组中元素的个数。标记位默认不传，传1则用递归的方式统计所有的元素个数(包括数组本身)。

$arr = array("www.baidu.com","百度","测试数据",array("1",'2','3'));
echo count($arr)."<br/>"; //4

echo count($arr,1)."<br/>"; //7 原数组4个元素 + 嵌套内的元素个数

2、array_count_values()统计数组中值出现的次数

array_count_values()返回对应值出现的次数组成的数组。

$arr = array('qq','baidu','taobao','sina','baidu','taobao','sina','taobao','sina');

print_r(array_count_values($arr));//统计数组中每个值出现的次数

/*
Array
(
    [qq] => 1
    [baidu] => 2
    [taobao] => 3
    [sina] => 3
)*/

数组库中的sql语句有同样的功能。

(六) 数组指针操作

1、reset($arr)把数组内部指针移动到数组第一个元素，并返回元素值。

$arr = array("1","2","3");
echo "<pre/>";

print_r(each($arr));
print_r(each($arr));
print_r(reset($arr));//1，返回第一个元素值
print_r(each($arr));
/*
Array
(
    [1] => 1
    [value] => 1
    [0] => 0
    [key] => 0
)
Array
(
    [1] => 2
    [value] => 2
    [0] => 1
    [key] => 1
)
1Array
(
    [1] => 1
    [value] => 1
    [0] => 0
    [key] => 0
)

*/

2、end($arr)把数组内部指针移动到数组最后一个元素

$arr = array("1","2","3");
echo "<pre/>";
echo end($arr)."<br/>"; //3 返回最后一个元素值
print_r(each($arr));
    
/*
3
Array
(
    [1] => 3
    [value] => 3
    [0] => 2
    [key] => 2
)
*/

3、next()把数组指针向下移动一位

next($arr)执行一次，把数组指针向下移动一位，并返回当前指针，如果到结尾返回FALSE，如果当前元素的值为空，或者0，返回FALSE。

起始获取的值为下一位，默认从0开始的时候，next()获取1位置的值。但是不能用这个函数遍历，在判断空元素或0的时候，与结束的FALSE对应的判断结果相同。

$arr = array("11","22","33");
echo "<pre/>";
echo next($arr).","; //第一次打印索引为1的值(默认起始索引0，加1为1)
echo next($arr).",";
var_dump(next($arr)); //bool(false)
//22,33,bool(false)

4、prev()把数组指针向上移动一位，并返回当前指针，如果当前元素的值为空，或者0，返回FLASE。
5、current()数组当前指针的值。

返回当前指针指向的值。如果当前元素为空返回FALSE。

$arr = array("11","22",0,"33");
do {
    echo current($arr)."<br/>";

} while (next($arr)); //遇到0返回false，循环终止。

/*
11
22
*/

遍历数组的替代方法

$arr = array("11","22",0,"33");
echo "<pre/>";

while (list($key,$value) = each($arr)) {
    echo $value."<br/>";
}

6、key() 返回当前指针指向元素的键名

$arr = array("url"=>"www.baidu.com","name"=>"网址");
echo "<pre/>";

echo key($arr);
echo "<br/>";
next($arr);
echo key($arr);
echo "<br/>";
prev($arr);
echo key($arr);
/*
url
name
url
*/

(七) 查找、修改、分割、合并

1、array_search("value",$arr,strict)查找元素值对应的键名。

在数组中查找一个键值。如果找到了该值，匹配元素的键名会被返回。如果没找到，则返回false。只返回第一个查找到值的key。

第三个参数设置是否判断类型，如果设置为true，表示只有在值和类型都相同的时候，才返回相应元素的键名。默认不设置，为false。

$arr1 = array("url"=>"www.baidu.com","name"=>"网址");
echo array_search('网址', $arr1)."<br/>"; //name
$arr = array("111",'2222','3333','2222');
echo array_search('2222', $arr)."<br/>"; //1
var_dump(array_search('222', $arr)); // bool(false)

2、array_change_key_case()将数组所有的键转为大写/小写字母

array_change_key_case($arr,case)第二个参数为可选值，CASE_LOWER-默认值，将数组的键转换为小写字母。CASE_UPPER将数组的键转换为大写字母。

$arr = array("url"=>"www.baidu.com","name"=>"网址");
echo "<pre/>";
print_r($arr);
print_r(array_change_key_case($arr,CASE_UPPER));
    
/*
    Array
(
    [url] => www.baidu.com
    [name] => 网址
)
Array
(
    [URL] => www.baidu.com
    [NAME] => 网址
)
*/

如果运行此函数时有两个或多个键相同(键值区分大小写)，最后的元素会覆盖其他元素。

$arr = array('a'=>'1','b'=>'2','A'=>'3','b'=>'4');
echo "<pre/>";
print_r($arr);
print_r(array_change_key_case($arr,CASE_UPPER));
    
/*
Array
(
    [a] => 1
    [b] => 4
    [A] => 3
)
Array
(
    [A] => 3
    [B] => 4
)

*/

3、array_chunk()把数组分割为新的数组块

array_chunk($arr,size,preserve_key)分割数组，size为分割后数组的期待长度。最后一个数组数目可能会少几个。

preserve_key 是可选参数，指定新数组的元素是否有和原数组相同的键(关联数组)，还是从0开始新的数字键(索引数组)。默认重新分配新的键。

$arr = array('a'=>'1','b'=>'2','A'=>'3','B'=>'4');
// echo "<pre/>";
print_r(array_chunk($arr, 3));
echo "<br/>";
print_r(array_chunk($arr, 3,true));

$arr1 = array('a','b','c','d');
echo "<br/>";
print_r(array_chunk($arr1, 2));
echo "<br/>";
print_r(array_chunk($arr1, 2,true));
    
/*
Array ( [0] => Array ( [0] => 1 [1] => 2 [2] => 3 ) [1] => Array ( [0] => 4 ) ) 
Array ( [0] => Array ( [a] => 1 [b] => 2 [A] => 3 ) [1] => Array ( [B] => 4 ) ) 
Array ( [0] => Array ( [0] => a [1] => b ) [1] => Array ( [0] => c [1] => d ) ) 
Array ( [0] => Array ( [0] => a [1] => b ) [1] => Array ( [2] => c [3] => d ) )
*/

4、array_combine()合并两个数组

array_combine(keys,values) 合并两个数组，组成新的数组，一个数组元素为键名，一组元素为键值。

键名数组和键值数组的元素个数必须相同！

如果其中一个数组为空，或者两个数组的元素个数不同，则会发错错误array_combine(): Both parameters should have an equal number of elements

$key = array('1','2','3','4','5');
$value = array('a','b','c','d','e');
$arr = array_combine($key, $value);
echo "<pre/>";;
print_r($arr);

/*
Array
(
    [1] => a
    [2] => b
    [3] => c
    [4] => d
    [5] => e
)
*/

(八) 差集

1、array_diff() 比较键值，返回数组的差集数组。

array_diff(array1,array2,array3...);array1 与其他数组进行比较的第一个数组。该数组包括了所有在被比较的数组(array1)中，但是不在任何其他参数数组中的键值。在返回的数组中，键名保持不变。

$arr1 = array('1','2','3','4','5');
$arr2 = array('a','b','c','d','e');
$arr3 = array('3','6','2','9','10');
$arr = array_diff($arr1, $arr2);
echo "<pre/>";;
print_r($arr);

$arr = array_diff($arr1, $arr2,$arr3);
    
print_r($arr);

/*
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
    [0] => 1
    [3] => 4
    [4] => 5
)
*/

2、array_diff_key() 比较键名，返回差集数组。

array_diff_key(array1,array2,array3...);函数比较两个或多个数组的键名，并返回一个差集数组。

返回在第一个被比较数组中，但是不在其他任何比较数组中的键名的元素集合。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}

$arr1 = array("url"=>"www.baidu.com",'name'=>"百度",'webname'=>"xxx");
$arr2 = array("url"=>"www.baidu.com",'name'=>"百度","xxxx"=>"xxxx");
$arr = array_diff_key($arr1, $arr2);
dum($arr);

/*
Array
(
    [webname] => xxx
)
*/

3、array_udiff() 通过回调函数，比较键值，返回差集

array_udiff(array1,array2,array3...,myfunction)数据的比较是用array_udiff()函数的myfunction进行的。myfunction函数带有两个将进行比较的参数。如果第一个参数小于第二个参数，则函数返回一个负数，如果两个参数相等，则要返回 0，如果第一个参数大于第二个，则返回一个正数。

返回第一个被比较数组中，在其他所有数组中满足定义函数的键值的元素集合。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func($v1,$v2) {
    //在这里，比较键值
    //如果相同，则不保留
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key1'=>"11",'key2'=>"222",'key3'=>'33','key4'=>'10');
$arr2 = array('keya'=>"11",'keyb'=>"22",'keyc'=>'333','10');

$arr = array_udiff($arr1, $arr2,"func");
dum($arr);
/*
Array
(
    [key2] => 222
    [key3] => 33
)
*/

4、array_udiff_assoc() 通过回调函数，比较键名和键值，返回差值

array_udiff_assoc(array1,array2,array3...,myfunction)同时比较数组的键名和键值。myfunction比较的内部回调函数。

返回在第一个被比较数组中，在其他所有比较数组中都不存在的键名，以及满足自定义函数的键值的元素集合。

该函数使用内建函数来比较键名，使用用户自定义函数比较键值。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key1'=>"11",'key2'=>"22",'key3'=>'33');
$arr2 = array('key'=>"11",'key2'=>"22",'key3'=>'333');
$arr = array_udiff_assoc($arr1, $arr2,"func");
// $arr = array_udiff_uassoc($arr1, $arr2,"func","func");
dum($arr);

/*
Array
(
    [key1] => 11
    [key3] => 33
)
*/

5、array_udiff_uassoc() 通过回调函数，比较键名和键值，并返回差集。

array_udiff_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)同时比较两个或多个数组键名和键值的差值。myfunction_key用于比较数组键名的用户自定义函数的名称。myfunction_value用于比较数组键值的用户自定义函数的名称。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key'=>"11",'key2'=>"22",'key3'=>'33');
$arr2 = array('key1'=>"11",'key2'=>"22",'key3'=>'333');

$arr = array_udiff_uassoc($arr1, $arr2,"func","func");
dum($arr);

/*
Array
(
    [key] => 11
    [key3] => 33
)
*/

6、array_diff_uassoc()通过回调函数的方式，比较键名和键值，返回差集

array_diff_uassoc(array1,array2,array3...,myfunction);同时比较多个数组的键名和键值，使用自定义函数比较键名。

返回第一个被比较数组中，在其他所有数组中键值都不存在，且键名满足自定义回调函数的元素集合。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key'=>"11",'key2'=>"22",'key3'=>'33');
$arr2 = array('key1'=>"11",'key2'=>"22",'key3'=>'333');

$arr = array_diff_uassoc($arr1, $arr2,"func");
dum($arr);
/*
Array
(
    [key] => 11
    [key3] => 33
)
*/

(九) 交集

1、array_intersect()比较键值，返回交集

array_intersect(array1,array2,array3...);该函数比较两个（或更多个）数组的键值，并返回交集数组。

返回在被比较数组中，并且同时也在其他所有数组中的键值的元素集合。

unction dum($arr) {
        echo "<pre>";
        print_r($arr);
    }
$arr1 = array("url"=>"123",'name'=>"John",'webname'=>"1");
$arr2 = array("url"=>"123",'names'=>"John","webname"=>"2");
    
$arr = array_intersect($arr1, $arr2);

dum($arr);

$arr3 = array("ab"=>"1",'cd'=>"123",'ef'=>'2');

$arr = array_intersect($arr1, $arr2,$arr3);

dum($arr);

/*
Array
(
    [url] => 123
    [name] => John
)
Array
(
    [url] => 123
)
*/

2、array_uintersect()通过回调函数(自定义函数)，比较键值，返回交集

array_uintersect(array1,array2,array3...,myfunction)数用于比较两个（或更多个）数组的键值，并返回交集。
使用用户自定义函数比较键值。

返回在第一个被比较数组中，同时在其他所有数组中满足自定义函数的键值的元素集合。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key1'=>"11",'key2'=>"22",'key3'=>'33');
$arr2 = array('key'=>"11",'key2'=>"22",'key3'=>'333');
$arr = array_uintersect($arr1, $arr2,"func");
// $arr = array_udiff_uassoc($arr1, $arr2,"func","func");
dum($arr);

/*
Array
(
    [key1] => 11
    [key2] => 22
)
*/

3、array_intersect_key()比较键名，返回交集

array_intersect_key(array1,array2,array3...)通过比较键名，返回在所有数组中公有的键名的元素集合。

仅有键名用于比较

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}

$arr1 = array("url"=>"123",'name'=>"John",'webname'=>"1");
$arr2 = array("url"=>"123",'names'=>"John","webname"=>"2");
    
$arr = array_intersect_key($arr1, $arr2);

dum($arr);

/*
Array
(
    [url] => 123
    [webname] => 1
)
*/

4、array_intersect_assoc()比较键名和键值，返回交集

array_intersect_assoc(array1,array2,array3...)比较所有数组的键名和键值，两者都相同的交集。

同时比较键名和键值，返回数组元素键名不变。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
$arr1 = array("url"=>"123",'name'=>"John",'webname'=>"1");
$arr2 = array("url"=>"123",'names'=>"John","webname"=>"2");
    
$arr = array_intersect_assoc($arr1, $arr2);

dum($arr);

/*
Array
(
    [url] => 123
)
*/

5、array_uintersect_assoc()通过回调函数，比较键值，内建函数比较键名，返回交集

array_uintersect_assoc(array1,array2,array3...,myfunction)比较键名和键值，返回满足条件的元素交集集合。

该函数使用内建函数比较键名，使用用户自定义函数比较键值！

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key1'=>"11",'key2'=>"22",'key3'=>'33');
$arr2 = array('key'=>"11",'key2'=>"22",'key3'=>'333');
$arr = array_uintersect_assoc($arr1, $arr2,"func");
dum($arr);

/*
Array
(
    [key2] => 22
)
*/

6、array_uintersect_uassoc()通过两个回调函数，自定义函数比较键值和键名，返回交集

array_uintersect_uassoc(array1,array2,array3...,myfunction_key,myfunction_value)分别比较键名和键值。myfunction_key用于比较数组键名的用户自定义函数的名称。myfunction_value用于比较数组键值的用户自定义函数的名称。

键名键值都通过自定义函数比较。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
function func_key($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}
function func_value($v1,$v2) {
    if ($v1===$v2) {
        return 0;
    } elseif ($v1 > $v2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array('key1'=>"11",'key2'=>"22",'key3'=>'33');
$arr2 = array('key1'=>"11",'key2'=>"22",'key3'=>'333');
$arr = array_uintersect_uassoc($arr1, $arr2,"func_key","func_value");
dum($arr);

/*
Array
(
    [key1] => 11
    [key2] => 22
)
*/

7、array_intersect_ukey()``array_intersect_uassoc()通过回调函数，取交集

array_intersect_ukey()通过回调函数的方式，返回第一个数组在其他数组当中同时存在的键名的数组元素。

array_intersect_uassoc()通过回调函数的方式，返回第一个数组在其他数组当中同时存在相同的键名和键值的数组元素。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}

function a($k1,$k2) {
    if ($k2 === $k1) {
        return 0;
    } else if ($k1 > $k2) {
        return 1;
    } else {
        return -1;
    }
}

$arr1 = array("url"=>"123",'name'=>"John",'webname'=>"1");
$arr2 = array("url"=>"123",'names'=>"John","webname"=>"2");
    
$arr = array_intersect_ukey($arr1, $arr2,"a");
$arr0 = array_intersect_uassoc($arr1, $arr2,"a");
dum($arr);
dum($arr0);

/*
Array
(
    [url] => 123
    [webname] => 1
)
Array
(
    [url] => 123
)
*/

(十) 其他函数

1、array_filter()数组过滤，自定义函数过滤

array_filter(array,callbackfunction);通过回调函数的方式返回新数组，如果回调函数返回true，数组元素返回到新数组中。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}

$arr = array('1'=>"语文课",'2'=>'数学课','3'=>'英语课','4'=>'112',);
$arr1 = array_filter($arr,"filter");

function filter($v) {
    if (stripos($v, "课")) { //筛选条件
        return true;
    } else {
        return false ;
    }
}

dum($arr1);

/*
Array
(
    [1] => 语文课
    [2] => 数学课
    [3] => 英语课
)
*/

做一些简单过滤处理。

$arr0 = array("name"=>"李云","msg"=>"需要打架吗？");
if (array_filter($arr0,"filter")) {
    echo "含有非法信息";
} else {
    echo "信息合法";
}
function filter($v) {
    if (stripos($v, "打架")) { //筛选条件
        return true;
    } else {
        return false ;
    }
}

//含有非法信息

2、array_flip()交换键名和键值

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
$arr = array('1'=>"语文课",'2'=>'数学课','3'=>'英语课','4'=>'112',);
$arr1 = array_flip($arr);   
dum($arr1);
/*
Array
(
    [语文课] => 1
    [数学课] => 2
    [英语课] => 3
    [112] => 4
)
*/

3、array_key_exists()判断键名是否存在于数组

array_key_exists(key,array)函数检查某个数组中是否存在指定的键名，如果键名存在则返回 true，如果键名不存在则返回 false。默认键名是索引值。

$arr = array('11'=>"语文课",'22'=>'数学课','33'=>'英语课','44'=>'112',);
var_dump(array_key_exists(11, $arr));   //bool(true)
var_dump(array_key_exists(12, $arr));   //bool(false)

4、array_keys()返回数组的key

array_keys(array,value,strict)``array为必选参数。value可选，指筛选出对应值的所有key。strict与value一起使用，标记是否判定值的时候是否判定类型。

unction dum($arr) {
    echo "<pre>";
    print_r($arr);
}

$arr = array('key1'=>"1111",'key2'=>1111,'key3'=>'3333','key4'=>'112',);

dum(array_keys($arr));
dum(array_keys($arr,"1111"));
dum(array_keys($arr,"1111",true));

/*
Array
(
    [0] => key1
    [1] => key2
    [2] => key3
    [3] => key4
)
Array
(
    [0] => key1
    [1] => key2
)
Array
(
    [0] => key1
)
*/

5、array_values()取所有键值。

$arr = array("name"=>"高智","age"=>"22","job"=>"IT");
dum($arr);
    

$keys = array_keys($arr);
$values = array_values($arr);

dum($keys);
dum($values);

/*
Array
(
    [name] => 高智
    [age] => 22
    [job] => IT
)
Array
(
    [0] => name
    [1] => age
    [2] => job
)
Array
(
    [0] => 高智
    [1] => 22
    [2] => IT
)
*/

6、array_unique()去除重复项

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
    

$arr1 = array("Apple","Banana","Peach","Peach","Banana");
dum($arr1);
$arr = array_unique($arr1);
dum($arr);
/*
Array
(
    [0] => Apple
    [1] => Banana
    [2] => Peach
    [3] => Peach
    [4] => Banana
)
Array
(
    [0] => Apple
    [1] => Banana
    [2] => Peach
)
*/

7、array_unshift()顶部插入元素

array_unshift(array,value1,value2,value3...)顶部插入元素

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
    
$arr = array("Apple","Banana","Peach");
dum($arr);
$arr[] = "Watermelon";
if (array_unshift($arr, "Grape")) {
    echo "添加成功";
}
dum($arr);

/*
Array
(
    [0] => Apple
    [1] => Banana
    [2] => Peach
)
Array
(
    [0] => Grape
    [1] => Apple
    [2] => Banana
    [3] => Peach
    [4] => Watermelon
)
*/

8、array_shift() 删除第一个元素，并返回删除的值

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
    
$arr = array("Apple","Banana","Peach","Watermelon");
dum($arr);
var_dump(array_shift($arr)); //插入后数组数量
dum($arr);

/*
Array
(
    [0] => Apple
    [1] => Banana
    [2] => Peach
    [3] => Watermelon
)
string(5) "Apple"
Array
(
    [0] => Banana
    [1] => Peach
    [2] => Watermelon
)
*/

$arr = array("0","Apple","Banana","Peach","Watermelon");
// 判断是否删除成功
if (!is_null(array_shift($arr))) {
//删除的元素可能为0，
    echo "删除成功";
}

9、array_pop()从后面移除数组元素，返回移除的元素值

array_pop()移除失败返回NULL

$arr = array("0","Apple","Banana","Peach","Watermelon");
dum($arr);
echo array_pop($arr);

dum($arr);

/*
Array
(
    [0] => 0
    [1] => Apple
    [2] => Banana
    [3] => Peach
    [4] => Watermelon
)
Watermelon
Array
(
    [0] => 0
    [1] => Apple
    [2] => Banana
    [3] => Peach
)
*/

10、unset()删除数组指定的元素

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}
$arr = array("0","Apple","Banana","Peach");
dum($arr);
unset($arr[1]);
dum($arr);
/*
Array
(
    [0] => 0
    [1] => Apple
    [2] => Banana
    [3] => Peach
)
Array
(
    [0] => 0
    [2] => Banana
    [3] => Peach
)
*/

11、array_map()将用户自定义函数作用到数组中的每个元素上，并返回用户自定义函数作用后的带有新元素值的数组。

array_map(myfunction,array1,array2,array3...)将函数作用域数组的每个元素上，myfunction用户自定义函数的名称，或者是null。

function func($v) {
    return $v + 10;
}
$arr = array(111,22,111,22,3,4,5,6);
print_r($arr);
echo "<br/>";
$arr1 = array_map("func", $arr);
print_r($arr1);

/*
Array ( [0] => 111 [1] => 22 [2] => 111 [3] => 22 [4] => 3 [5] => 4 [6] => 5 [7] => 6 ) 
Array ( [0] => 121 [1] => 32 [2] => 121 [3] => 32 [4] => 13 [5] => 14 [6] => 15 [7] => 16 )
*/

可以传递多个数组，每个参数对应一个数组。

function function_map($arr1,$arr2){
    return array($arr2=>$arr1);
}

$arr1 = array(1,2,3,4,5);
$arr2 = array('a','b','c','d','e');

$arr3 = array_map(function_map, $arr1,$arr2);
dum($arr3);

/*
Array
(
    [0] => Array
        (
            [a] => 1
        )

    [1] => Array
        (
            [b] => 2
        )

    [2] => Array
        (
            [c] => 3
        )

    [3] => Array
        (
            [d] => 4
        )

    [4] => Array
        (
            [e] => 5
        )

)
*/

12、array_walk()对数组中的每个元素应用用户自定义函数。--数组漫游

array_walk(array,myfunction,userdata...)可传递参数，可修改数组内容。myfunction自定义函数的名称。userdata规定用户自定义函数的参数。

可以通过自定义函数中的第一个参数指定为引用：&$value，来改变数组元素的值。

典型情况下myfunction接受两个参数。array 参数的值作为第一个，键名作为第二个。如果提供了可选参数 userdata ，将被作为第三个参数传递给回调函数。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}

$arr = array("lisan"=>11102,"zhangsi"=>1000,'zhaoliu'=>"100");
//&$v,传址赋值
function func_walk(&$v,$k,$c='') {
    if ($v < 1000) {
        $v+=$c;
    }
}
if (array_walk($arr, func_walk,2000)) {
    echo "更改成功";
}
dum($arr);

/*
Array
(
    [lisan] => 11102
    [zhangsi] => 1000
    [zhaoliu] => 2100
)
*/

13、array_walk_recursive()函数对数组中的每个元素应用用户自定义函数。

array_walk_recursive(array,myfunction,parameter...)该函数与array_walk()函数的不同在于可以操作多维数组。

function dum($arr) {
    echo "<pre>";
    print_r($arr);
}

function function_w(&$v,$key){
    if ($key=='money' && $v < 300) {
        $v += 500;
    }
}

$arr1 = array(
    array('uname'=>"张三",'money'=>100),
    array('uname'=>"李四",'money'=>200),
    array('uname'=>"王五",'money'=>300),
    array('uname'=>"赵六",'money'=>500),
    );
array_walk_recursive($arr1, function_w);
dum($arr1);

/*
Array
(
    [0] => Array
        (
            [uname] => 张三
            [money] => 600
        )

    [1] => Array
        (
            [uname] => 李四
            [money] => 700
        )

    [2] => Array
        (
            [uname] => 王五
            [money] => 300
        )

    [3] => Array
        (
            [uname] => 赵六
            [money] => 500
        )
)
*/

14、compact()将多个变量转化为数组

compact()变量名为数组的键名，变量值为数组的键值。传递参数名字符串添加元素。

$webname = "百度";
$weburl = "www.baidu.com";
$arr = compact('webname','weburl');//传入变量名
    
print_r($arr);

//Array ( [webname] => 百度 [weburl] => www.baidu.com )

15、extract() 将数组元素转变为变量

extract(array,extract_rules,prefix)将数组元素转为变量，可以添加前缀，可以替换已经存在变量名，也可以生成不同的变量名。索引数组需要特殊处理，因为纯数字的key是不能作为变量的。

extract_rules可选。extract()函数将检查每个键名是否为合法的变量名，同时也检查和符号表中已存在的变量名是否冲突。对不合法和冲突的键名的处理将根据此参数决定。可取的值

EXTR_OVERWRITE - 默认。如果有冲突，则覆盖已有的变量。
EXTR_SKIP - 如果有冲突，不覆盖已有的变量。
EXTR_PREFIX_SAME - 如果有冲突，在变量名前加上前缀 prefix。
EXTR_PREFIX_ALL - 给所有变量名加上前缀 prefix。
EXTR_PREFIX_INVALID - 仅在不合法或数字变量名前加上前缀 prefix。
EXTR_IF_EXISTS - 仅在当前符号表中已有同名变量时，覆盖它们的值。其它的都不处理。
EXTR_PREFIX_IF_EXISTS - 仅在当前符号表中已有同名变量时，建立附加了前缀的变量名，其它的都不处理。
EXTR_REFS - 将变量作为引用提取。导入的变量仍然引用了数组参数的值。

prefix可选。请注意prefix仅在 extract_type的值是 EXTR_PREFIX_SAME，EXTR_PREFIX_ALL，EXTR_PREFIX_INVALID 或 EXTR_PREFIX_IF_EXISTS时需要。如果附加了前缀后的结果不是合法的变量名，将不会导入到符号表中。

前缀和数组键名之间会自动加上一个下划线。

$arr = array('PHP','webname'=>"百度",'weburl'=>"www.baidu.com","测试");
    
var_dump(extract($arr)); //int(2) 

echo "<br/>";
// 声明键名对应的变量，但是索引数组不能取到(索引为数字，不能为变量名)。
echo $webname."<br/>";//百度
echo $weburl."<br/>";//www.baidu.com

var_dump(extract($arr,EXTR_PREFIX_ALL,'zyd')); //int(4) 
//指定字段名前缀，解决索引数组数字的变量生成
echo "<br/>";

echo $zyd_webname."<br/>";//百度
echo $zyd_weburl."<br/>";//www.baidu.com
echo $zyd_0."<br/>";//PHP
echo $zyd_1."<br/>";//测试
echo $zyd_2."<br/>";
//表前缀_xxx

16、array_merge()合并数组

array_merge(array1,array2,array3...)将多个数组合并。如果两个或更多个数组元素有相同的键名，则最后的元素会覆盖其他元素。

如果仅向array_merge()函数输入一个数组，且键名是整数，则该函数将返回带有整数键名的新数组，其键名以0开始进行重新索引

$arr1 = array(10=>"a",13=>"a",15=>"a");
print_r($arr1);
$arr = array_merge($arr1);
print_r($arr);
//Array ( [10] => a [13] => a [15] => a )
//Array ( [0] => a [1] => a [2] => a )

17、array_merge_recursive()合并数组

array_merge_recursive(array1,array2,array3...)将多个数组合并，键名相同时，将多个想听键名的值递归组成一个数组。

$arr1 = array('webname'=>"百度",'weburl'=>"www.baidu.com");
$arr2 = array('webname'=>"localhost",'db_user'=>"admin");

// $arr =  array_merge($arr1, $arr2);
$arr =  array_merge_recursive($arr1, $arr2);
echo "<pre/>";
print_r($arr);

/*
Array
(
    [webname] => Array
        (
            [0] => 百度
            [1] => localhost
        )

    [weburl] => www.baidu.com
    [db_user] => admin
)
*/

18、array_pad()对数组进行填充

array_pad(array,size,value)对数组填充内容，size设置填充后的数组长度，参数设置为负数，该函数会在原始数组之前插入新的元素。为正则从尾部添加元素数据。value为填充的元素。

与字符串中的str_pad()函数类似。

$arr = array(1,2,3);
$arr1 = array_pad($arr, 5, "8");
print_r($arr1);

/*
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 8
    [4] => 8
)
*/

19、array_product()将数组元素键值进行乘积运算

返回整型或浮点型数据。

$arr = array(3,2,2,2);
var_dump(array_product($arr));

//int(24)

20、array_sum()对数组中的值进行求和运算。

$arr = array(1,2,3,4,5);
    
echo array_sum($arr);
//15

21、array_push()添加元素

可以添加单个元素，也可以添加数组。

$arr =array('name'=>'宋江','age'=>"38");
$arr1 = array('nickname'=>'呼保义','star'=>'星主');
var_dump(array_push($arr, $arr1));
print_r($arr);
//int(3) 
//Array ( [name] => 宋江 [age] => 38 [0] => Array ( [nickname] => 呼保义 [star] => 星主 ) )

22、array_rand()随机获取数组元素

array_rand(array,number)随机获取指定个数的数组元素的键名。如果规定函数返回不只一个键名，则返回包含随机键名的数组。

$arr = array(
    array('name'=>'宋江','age'=>"38"),
    array('name'=>'林冲','age'=>"32"),
    array('name'=>'吴用','age'=>"30"),
    array('name'=>'张清','age'=>"28"),
    array('name'=>'张顺','age'=>"22"),
    );
    
$key = array_rand($arr,2);
print_r($key);

//Array ( [0] => 3 [1] => 4 ) 每次打印的结果不同

23、array_reverse()数组倒序输出

array_reverse(array,preserve)倒序输出数组，preserve标记是否保留原始数组的键名。

$arr = array('a','b','c','d');
print_r($arr);
print_r(array_reverse($arr));
print_r(array_reverse($arr,TRUE));
/*
Array ( [0] => a [1] => b [2] => c [3] => d ) 
Array ( [0] => d [1] => c [2] => b [3] => a ) 
Array ( [3] => d [2] => c [1] => b [0] => a )
*/

24、array_reduce() 用回调函数递归对数组元素进行处理，返回处理后的值

array_reduce(array,myfunction,initial)调用回调函数迭代地将数组简化为单一的值。myfunction函数名称，initial规定发送到函数的初始值。

$arr = array(1,2,3,4,5);    
function func($c,$i){
    //$c最开始没有值，$c接收上一次返回的值
    $c += $i;
    echo $c."<br/>";
    return $c;
}
//通过回调函数，
array_reduce($arr, func,1);//第三个参数是$c的初始值，默认为0

//2 4 7 11 16

$arr = array(1,2,3,4,5);
function func($c,$i){
    //$c最开始没有值，$c接收上一次返回的值
    $c .= "======".$i;
    return $c;
}
//通过回调函数，
echo array_reduce($arr, func,1);//第三个参数是$c的初始值，默认为0

//1======1======2======3======4======5

25、array_slice()截取数组元素，不操作原数组

array_slice(array,start,length,preserve)根据指定开始位置与长度截取数组，返回截取到的数组。start规定取出元素的开始位置,如果该值设置为正数，则从前往后开始取。如果该值设置为负数，则从后向前取start绝对值。-2意味着从数组的倒数第二个元素开始。

length规定被返回数组的长度。如果该值设置为整数，则返回该数量的元素。如果该值设置为负数，则函数将在举例数组末端这么远的地方终止取出。如果该值未设置，则返回从 start 参数设置的位置开始直到数组末端的所有元素。

preserve规定函数是保留键名还是重置键名。true保留键名。false默认，重置键名。

不操作原数组，返回操作后的新数组。

$arr = array(1,2,3,4,5);
    
$arr1 = array_slice($arr, 2);
echo "<br/>";
print_r($arr1);//Array ( [0] => 3 [1] => 4 [2] => 5 ) 

$arr1 = array_slice($arr, -2);  
echo "<br/>";
print_r($arr1);//Array ( [0] => 4 [1] => 5 ) 

$arr1 = array_slice($arr, -4 ,1);
echo "<br/>";
print_r($arr1);//Array ( [0] => 2 ) 

$arr1 = array_slice($arr, -4,-1);
echo "<br/>";
print_r($arr1);//Array ( [0] => 2 [1] => 3 [2] => 4 ) 

$arr1 = array_slice($arr, 2,2,true);    
echo "<br/>";
print_r($arr1);//Array ( [2] => 3 [3] => 4 )

26、array_splice()删除指定范围的元素。添加新的内容替代被删除内容。

array_splice(array,start,length,array)函数从数组中移除选定的元素，并用新元素取代它。该函数也将返回包含被移除元素的数组。

start规定删除元素的开始位置。
0 = 第一个元素。如果该值设置为正数，则从数组中该值指定的偏移量开始移除。如果该值设置为负数，则从数组末端倒数该值指定的偏移量开始移除。-2意味着从数组的倒数第二个元素开始

length规定被移除的元素个数，也是被返回数组的长度。如果该值设置为正数，则移除该数量的元素。如果该值设置为负数，则移除从 start 到数组末端倒数 length 为止中间所有的元素。如果该值未设置，则移除从 start 参数设置的位置开始直到数组末端的所有元素。

array规定带有要插入原始数组中元素的数组。如果只有一个元素，则可以设置为字符串，不需要设置为数组。

$arr = array(1,2,3,4,5);
$addArr = array("测试","尾巴");
$result = array_splice($arr, 2,1 ,$addArr);

print_r($result);//Array ( [0] => 3 ) 

echo "<br/>--------<br/>";
print_r($arr);//Array ( [0] => 1 [1] => 2 [2] => 测试 [3] => 尾巴 [4] => 4 [5] => 5 )

三、数组排序

1、sort()升序排序，不保留键名

sort(array,sortingtype)对索引数组进行升序排序。本函数为数组中的单元赋予新的键名。原有的键名将被删除。如果成功则返回 TRUE，否则返回 FALSE。

sortingtype:

0 = SORT_REGULAR - 默认。把每一项按常规顺序排列（Standard ASCII，不改变类型）
1 = SORT_NUMERIC - 把每一项作为数字来处理。
2 = SORT_STRING - 把每一项作为字符串来处理。
3 = SORT_LOCALE_STRING - 把每一项作为字符串来处理，基于当前区域设置（可通过 setlocale() 进行更改）。
4 = SORT_NATURAL - 把每一项作为字符串来处理，使用类似 natsort() 的自然排序。
5 = SORT_FLAG_CASE - 可以结合（按位或）SORT_STRING 或 SORT_NATURAL 对字符串进行排序，不区分大小写。

$arr = array(1,8,12,9,2,3,4,5);
sort($arr);
print_r($arr);

//Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 8 [6] => 9 [7] => 12 )

$arr1 = array("class1","class6","class4","class23",);
sort($arr1);
print_r($arr1);
//Array ( [0] => class1 [1] => class23 [2] => class4 [3] => class6 )
//按照字符串比较

2、asort()按照键值升序排序，保留键名

asort(array,sortingtype);

echo "<pre>";
$arr = array(
    'a'=>"1111",
    'b'=>'3333',
    'c'=>'6666',
    'd'=>'2222');
asort($arr);
print_r($arr);

/*
Array
(
    [a] => 1111
    [d] => 2222
    [b] => 3333
    [c] => 6666
)
*/

3、ksort() 按键名排序

ksort(array,sortingtype);

echo "<pre>";
$arr = array(
    'a'=>"1111",
    'd'=>'3333',
    'b'=>'6666',
    'c'=>'2222');
ksort($arr);
print_r($arr);
/*
Array
(
    [a] => 1111
    [b] => 6666
    [c] => 2222
    [d] => 3333
)
*/

4、rsort()对数组键值反向排序，不保留键名

rsort(array,sortingtype);

$arr = array(
    'a'=>"1111",
    'd'=>'3333',
    'b'=>'6666',
    'c'=>'2222');
rsort($arr);
print_r($arr);
/*
Array
(
    [0] => 6666
    [1] => 3333
    [2] => 2222
    [3] => 1111
)
*/

5、arsort()对数组键值反向排序，保留键名
6、krsort()对数组键名反向排序。
7、natsort()用自然顺序排序

natsort(array)函数用"自然排序"算法对数组进行排序。键值保留它们原始的键名。

natsort()函数实现了“自然排序”，即数字从1到9的排序方法，字母从a到z的排序方法，短者优先。数组的索引与单元值保持关联。

如果成功，则该函数返回 TRUE，否则返回 FALSE。

$arr1 = array("class1","class6","class4","class23",);
natsort($arr1);
print_r($arr1);
//Array ( [0] => class1 [2] => class4 [3] => class6 [1] => class23 )

8、 natcasesort()不区分大小写排序

natcasesort()不区分字母大小写排序，保留数组键值。

$arr = array('b','B','A','a','C','d');
    
natcasesort($arr);
print_r($arr);

//Array ( [2] => A [3] => a [0] => b [1] => B [4] => C [5] => d )

9、array_multisort()多数组排序

array_multisort(array1,sorting order,sorting type,array2,array3...)函数返回排序数组。输入一个或多个数组。函数先对第一个数组进行排序，接着是其他数组，如果两个或多个值相同，它将对下一个数组进行排序。

sorting order规定排列顺序:SORT_ASC - 默认。按升序排列(A-Z)。SORT_DESC - 按降序排列(Z-A)。

字符串键名将被保留，但是数字键名将被重新索引，从0开始，并以1递增。

$arr = array(1,3,2);
$arr1 = array(9,8,7);
array_multisort($arr,SORT_ASC,$arr1);
print_r($arr);
echo "<br/>------------------------------<br/>";
print_r($arr1);

/*
Array ( [0] => 1 [1] => 2 [2] => 3 ) 
------------------------------
Array ( [0] => 9 [1] => 7 [2] => 8 )
*/

$arr = array(2,1,3,1);
$arr1 = array(9,8,7,4);
array_multisort($arr,SORT_ASC,$arr1);
print_r($arr);
echo "<br/>------------------------------<br/>";
print_r($arr1);

/*
Array ( [0] => 1 [1] => 1 [2] => 2 [3] => 3 ) 
------------------------------
Array ( [0] => 4 [1] => 8 [2] => 9 [3] => 7 )
*/

10、shuffle()随机排序数组

shuffle()把数组中的元素按随机顺序重新排列，原有的键名删除。

$arr = array(1,8,12,9);
shuffle($arr);
print_r($arr);
// 随机排序，打印结果不统一

11、usort()回调函数排序，删除原有键名

函数使用用户自定义的函数对数组排序。本函数为array中的元素赋予新的键名。这会删除原有的键名。

usort(array,myfunction);

$arr = array(4,1,3,2);

function func($v1,$v2) {
    if ($v1 ==$v2) return 0;
    return $v1 > $v2 ? 1:-1;//递增
    // return $v1 > $v2 ? -1:1; //递减
}
    
var_dump(usort($arr, func));
echo "<br/>";
print_r($arr);
//Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )

12、uasort()通过回调函数，保留原索引键名

同usort()，不同的是会保留原数组索引。

$arr = array('4'=>4,'1'=>1,'3'=>3,'2'=>2);
function func($v1,$v2) {
    if ($v1 ==$v2) return 0;
    return $v1 > $v2 ? 1:-1;//递增
    // return $v1 > $v2 ? -1:1; //递减
}
    
var_dump(uasort($arr, func));
echo "<br/>";
print_r($arr);
//Array ( [1] => 1 [2] => 2 [3] => 3 [4] => 4 )

13、uksort()通过调用自定义函数，对数组按键名排序

uksort(array,myfunction)通过自定义的比较函数对数组按键名进行排序。

$arr = array('9'=>4,'20'=>1,'2'=>3,'7'=>2);

function func($v1,$v2) {
    if ($v1 ==$v2) return 0;
    return $v1 > $v2 ? 1:-1;//递增
    // return $v1 > $v2 ? -1:1; //递减
}
    
var_dump(uksort($arr, func));
echo "<br/>";
print_r($arr);

//Array ( [2] => 3 [7] => 2 [9] => 4 [20] => 1 )