再学 PHP 基础 之 数组排序函数总结
文章目录
- 排序函数汇总对比
- 排序类型标志
- 按【值】排序的函数
-
- array_multisort()
- asort()
- arsort()
- natcasesort()
- natsort()
- sort()
- rsort()
- shuffle()
- 按【键】排序的函数
-
- ksort()
- krsort()
- uksort()
- 自定义比较函数
-
- uasort
- uksort()
- usort()
- 打乱数组（随机排序）
-
- shuffle()
排序函数汇总对比
先说说数组排序函数的主要特点和区别：
- 排序依据：有些函数基于 array 的键来排序， 而其他的基于值来排序的：$array[‘key’] = ‘value’;。
- 数组索引键保持：排序之后键和值之间的关联关系是否能够保持， 是指排序之后数组的键可能 会被重置为数字型的（0,1,2 …）。
- 排序的顺序有：字母表顺序， 升序（由低到高）， 降序（由高到低），数字排序，自然排序，随机顺序或者用户自定义排序。
- 原地排序：下列的所有排序函数都是直接作用于数组本身， 而不是返回一个新的有序的数组。
- 以下函数对于数组中相等的元素，会保留原有的排序。 在 PHP 8.0.0 之前，它们排序后的顺序是未定义的（也即相等元素之间的顺序是不稳定的）。
排序函数属性比较
| 函数名称 | 排序依据 | 数组索引键保持 | 排序的顺序 |
|---|---|---|---|
| array_multisort() | 值 | string 键保持不变，int 键重新索引 | 第一个数组或由选项指定 |
| asort() | 值 | 是 | 升序 |
| arsort() | 值 | 是 | 降序 |
| krsort() | 键 | 是 | 降序 |
| ksort() | 键 | 是 | 升序 |
| natcasesort() | 值 | 是 | 自然排序，不区分大小写 |
| natsort() | 值 | 是 | 自然排序 |
| rsort() | 值 | 否 | 降序 |
| sort() | 值 | 否 | 升序 |
| shuffle() | 值 | 否 | 随机 |
| uasort() | 值 | 是 | 由用户定义 |
| uksort() | 键 | 是 | 由用户定义 |
| usort() | 值 | 否 | 由用户定义 |
排序类型标志
- SORT_REGULAR：将项目按照通常方法比较（不修改类型），区分大小写字母；
- SORT_NUMERIC：按照数字大小比较；
- SORT_STRING：按照字符串比较，区分大小写字母；
- SORT_LOCALE_STRING：根据当前的本地化设置，按照字符串比较。 它会使用 locale 信息，可以通过 setlocale() 修改此信息；
- SORT_NATURAL：以字符串的"自然排序"，类似 natsort()；
- SORT_FLAG_CASE：可以组合 (按位或 OR) SORT_STRING 或者 SORT_NATURAL 大小写不敏感的方式排序字符串。
按【值】排序的函数
array_multisort()
可以用来一次对多个数组进行排序，或者根据某一维或多维对多维数组进行排序。
关联（string）键名保持不变，但数字键名会被重新索引。
语法如下：
array_multisort(
array &$array1,
mixed $array1_sort_order = SORT_ASC,
mixed $array1_sort_flags = SORT_REGULAR,
mixed ...$rest
): bool
参数说明：
- array1：必须参数，要排序的数组。
- array1_sort_order：可选参数，用来指定要排列的顺序。默认SORT_ASC升序，SORT_DESC降序。
- array1_sort_flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
- rest：可选参数，可提供更多的数组，跟在sort_order和sort_flag之后，提供的数组要和要排序的数组array1的元素数量相同。
换言之，排序是按照字典顺序排列的。
array1_sort_order 和 array1_sort_flags 可以互换位置，也可以全部省略或者省略其中某一个。
返回值：
成功返回true，失败返回false。
代码范例：
- 多个数组排序
$ar1 = [10, 100, 100, 0];
$ar2 = [1, 3, 2, 4];
array_multisort($ar1, $ar2);
print_r($ar1);
print_r($ar2);
// 执行结果如下：
Array
(
[0] => 0
[1] => 10
[2] => 100
[3] => 100
)
Array
(
[0] => 4
[1] => 1
[2] => 2
[3] => 3
)
- 多维数组排序
$arr = [
["10", 11, 100, 100, "a"],
[ 1, 2, "2", 3, 1]
];
array_multisort($arr[0], SORT_ASC, SORT_STRING,
$arr[1], SORT_NUMERIC, SORT_DESC);
var_export($arr);
// 执行结果如下：
array (
0 =>
array (
0 => '10',
1 => 100,
2 => 100,
3 => 11,
4 => 'a',
),
1 =>
array (
0 => 1,
1 => 3,
2 => '2',
3 => 2,
4 => 1,
),
)
- 根据某一维或多维对多维数组进行排序
$users = [
['name' => '张三', 'age' => '18', 'score' => 20],
['name' => '李四', 'age' => '20', 'score' => 10],
['name' => '王五', 'age' => '19', 'score' => 60],
['name' => '赵六', 'age' => '22', 'score' => 20],
['name' => '徐俊杰', 'age' => '20', 'score' => 60],
['name' => '薛丽', 'age' => '18', 'score' => 70],
];
$ages = array_column($users, 'age');
$scores = array_column($users, 'score');
// 将数据根据 age 降序排列，根据 score 升序排列
// 把 $users 作为最后一个参数，以通用键排序
array_multisort($ages, SORT_DESC, $scores, SORT_ASC, $users);
foreach($users as $item) {
echo "${item['name']}\t{$item['age']}\t{$item['score']}\r\n";
}
// 执行结果如下：
姓名 年龄 成绩
———— ———— ————
赵六 22 20
李四 20 10
徐俊杰 20 60
王五 19 60
张三 18 20
薛丽 18 70
- 大小写字母排序
SORT_STRING 和 SORT_REGULAR 都会区分大小写字母，大写字母会排在小写字母之前。
$arr1 = $arr2 = ['Alpha', 'atomic', 'Beta', 'bank'];
// 区分小写排序
array_multisort($arr1);
print_r($arr1);
// 不区分大小写排序
$arr2LowerCase = array_map('strtolower', $arr2);
array_multisort($arr2LowerCase, $arr2);
print_r($arr2);
// 执行结果如下：
Array
(
[0] => Alpha
[1] => Beta
[2] => atomic
[3] => bank
)
Array
(
[0] => Alpha
[1] => atomic
[2] => bank
[3] => Beta
)
- string 键保持不变，int 键重新索引
$arr = [6 => 'c', 'F' => 'd', 'e', 'a'];
array_multisort($arr);
print_r($arr);
// 执行结果如下：
Array
(
[0] => a
[1] => c
[F] => d
[2] => e
)
asort()
对数组的值进行升序排序，并保持键与值的关联。
语法如下：
asort(array &array, int $flags = SORT_REGUILAR): bool
参数说明：
- array：必须参数，要排序的数组。
- flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
返回值：
总是返回true。
代码范例：
- 升序排序，并保持键值关联
$arr = ['c', 'd', 'e', 'a'];
asort($arr);
print_r($arr);
// 执行结果如下：
Array
(
[3] => a
[0] => c
[1] => d
[2] => e
)
arsort()
对数组的值进行降序排序，并保持键与值的关联。
语法如下：
arsort(array &array, int $flags = SORT_REGUILAR): bool
参数说明：
- array：必须参数，要排序的数组。
- flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
返回值：
总是返回true。
代码范例：
- 降序排序，并保持键值关联
$arr = ['c', 'd', 'e', 'a'];
arsort($arr);
print_r($arr);
// 执行结果如下：
Array
(
[2] => e
[1] => d
[0] => c
[3] => a
)
natcasesort()
用“自然排序”算法对数组进行不区分大小写字母的排序，并保持键与值的关联。
语法如下：
natcasesort(array &$array): bool
参数说明：
- array：必须参数，要排序的数组。
返回值：
总是返回true。
代码范例：
- 对数组进行 natcasesort 排序，并保持键值关联
$imgs = [
'IMG0.png',
'img12.png',
'img10.png',
'img2.png',
'img1.png',
'IMG3.png'
];
print_r("排序前：\n");
print_r($imgs);
natcasesort($imgs);
print_r("\n排序后：\n");
print_r($imgs);
// 执行结果如下：
排序前：
Array
(
[0] => IMG0.png
[1] => img12.png
[2] => img10.png
[3] => img2.png
[4] => img1.png
[5] => IMG3.png
)
排序后：
Array
(
[0] => IMG0.png
[4] => img1.png
[3] => img2.png
[5] => IMG3.png
[2] => img10.png
[1] => img12.png
)
natsort()
用“自然排序”算法对数组进行区分大小写字母的排序，并保持键与值的关联。
语法如下：
natsort(array &$array): bool
参数说明：
- array：必须参数，要排序的数组。
返回值：
总是返回true。
代码范例：
- 对数组进行 natsort 排序，并保持键值关联
$imgs = [
'IMG0.png',
'img12.png',
'img10.png',
'img2.png',
'img1.png',
'IMG3.png'
];
print_r("排序前：\n");
print_r($imgs);
natsort($imgs);
print_r("\n排序后：\n");
print_r($imgs);
// 执行结果如下：
排序前：
Array
(
[0] => IMG0.png
[1] => img12.png
[2] => img10.png
[3] => img2.png
[4] => img1.png
[5] => IMG3.png
)
排序后：
Array
(
[0] => IMG0.png
[5] => IMG3.png
[4] => img1.png
[3] => img2.png
[2] => img10.png
[1] => img12.png
)
sort()
对数组的值进行升序排序。排序后会删除原有的键名，并给排序后的元素赋予新的键名。
语法如下：
sort(array &$array, int $flag = SORT_REGULAR): bool
参数说明：
- array：必须参数，要排序的数组。
- flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
返回值：
总是返回true。
代码范例：
- 区分带小写升序排序，不保持键值关联
$fruits = [
"Orange1",
"orange2",
"Orange3",
"orange20"
];
print_r("排序前：\n");
print_r($fruits);
sort($fruits);
print_r("\n排序后：\n");
print_r($fruits);
// 执行结果如下：
排序前：
Array
(
[0] => Orange1
[1] => orange2
[2] => Orange3
[3] => orange20
)
排序后：
Array
(
[0] => Orange1
[1] => Orange3
[2] => orange2
[3] => orange20
)
- 不区分带小写升序排序，不保持键值关联
$fruits = [
"Orange1",
"orange2",
"Orange3",
"orange20"
];
print_r("排序前：\n");
print_r($fruits);
sort($fruits, SORT_NATURAL | SORT_FLAG_CASE);
print_r("\n排序后：\n");
print_r($fruits);
// 执行结果如下：
排序前：
Array
(
[0] => Orange1
[1] => orange2
[2] => Orange3
[3] => orange20
)
排序后：
Array
(
[0] => Orange1
[1] => orange2
[2] => Orange3
[3] => orange20
)
rsort()
对数组的值进行降序排序。排序后会删除原有的键名，并给排序后的元素赋予新的键名。
语法如下：
rsort(array &$array, int $flag = SORT_REGULAR): bool
参数说明：
- array：必须参数，要排序的数组。
- flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
返回值：
总是返回true。
代码范例：
- 区分带小写降序排序，不保持键值关联
$fruits = [
"Orange1",
"orange2",
"Orange3",
"orange20"
];
print_r("排序前：\n");
print_r($fruits);
rsort($fruits);
print_r("\n排序后：\n");
print_r($fruits);
// 执行结果如下：
排序前：
Array
(
[0] => Orange1
[1] => orange2
[2] => Orange3
[3] => orange20
)
排序后：
Array
(
[0] => orange20
[1] => orange2
[2] => Orange3
[3] => Orange1
)
- 不区分带小写降序排序，不保持键值关联
$fruits = [
"Orange1",
"orange2",
"Orange3",
"orange20"
];
print_r("排序前：\n");
print_r($fruits);
rsort($fruits, SORT_NATURAL | SORT_FLAG_CASE);
print_r("\n排序后：\n");
print_r($fruits);
// 执行结果如下：
排序前：
Array
(
[0] => Orange1
[1] => orange2
[2] => Orange3
[3] => orange20
)
排序后：
Array
(
[0] => orange20
[1] => Orange3
[2] => orange2
[3] => Orange1
)
shuffle()
请移步到【打乱数组（随机排序）】章节查看。
按【键】排序的函数
ksort()
对数组的键进行升序排序，并保持键与值的关联。
语法如下：
ksort(array &array, int $flags = SORT_REGUILAR): bool
参数说明：
- array：必须参数，要排序的数组。
- flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
返回值：
总是返回true。
代码范例：
- 对使用 string 键的数组进行 ksort 排序，并保持键值关联
$colors = [
'c' => 'cyan',
'a' => 'red',
'd' => 'yellow',
'b' => 'blue'
];
print_r("排序前：\n");
print_r($colors);
ksort($colors);
print_r("\n排序后：\n");
print_r($colors);
// 执行结果如下：
排序前：
Array
(
[c] => cyan
[a] => red
[d] => yellow
[b] => blue
)
排序后：
Array
(
[a] => red
[b] => blue
[c] => cyan
[d] => yellow
)
- 对使用 int 键的数组进行 ksort 排序，并保持键值关联
$ranks = [
0 => 'First',
2 => 'Third',
1 => 'Second'
];
print_r("排序前：\n");
print_r($ranks);
ksort($ranks);
print_r("\n排序后：\n");
print_r($ranks);
// 执行结果如下：
排序前：
Array
(
[0] => First
[2] => Third
[1] => Second
)
排序后：
Array
(
[0] => First
[1] => Second
[2] => Third
)
krsort()
对数组的键进行降序排序，并保持键与值的关联。
语法如下：
krsort(array &array, int $flags = SORT_REGUILAR): bool
参数说明：
- array：必须参数，要排序的数组。
- flags：可选参数，用来指定排序类型（标志），默认SORT_REGULAR。
返回值：
总是返回true。
代码范例：
- 对使用 string 键的数组进行 krsort 排序，并保持键值关联
$colors = [
'c' => 'cyan',
'r' => 'red',
'y' => 'yellow',
'b' => 'blue'
];
print_r("排序前：\n");
print_r($colors);
krsort($colors);
print_r("\n排序后：\n");
print_r($colors);
// 执行结果如下：
排序前：
Array
(
[c] => cyan
[r] => red
[y] => yellow
[b] => blue
)
排序后：
Array
(
[y] => yellow
[r] => red
[c] => cyan
[b] => blue
)
- 对使用 int 键的数组进行 krsort 排序，并保持键值关联
$ranks = [
7 => 'First',
20 => 'Third',
15 => 'Second'
];
print_r("排序前：\n");
print_r($ranks);
krsort($ranks);
print_r("\n排序后：\n");
print_r($ranks);
// 执行结果如下：
排序前：
排序前：
Array
(
[7] => First
[20] => Third
[15] => Second
)
排序后：
Array
(
[20] => Third
[15] => Second
[7] => First
)
uksort()
请移步到【自定义比较函数】章节查看。
自定义比较函数
uasort
使用自定义的比较函数对数组的值进行排序，保持索引和值的对应关系。该函数会改变数组本身的排序，并不会生成新数组。
uasort(array &$array, callback $callback): bool
参数：
- 第一个参数 $array：为待排序的数组；
- 第二个参数 $callback：就是用户自定义的比较函数（语法
callback(mixed $a, mixed $b): int），比较规则：- $a < $b，返回小于0的整数，一般返回-1；
- $a = $b，返回0；
- $a > $b，返回大于0的整数，一般返回1。
升序：$a < $b ? -1 : 1
降序：$a < $b ? 1 : -1
返回值：
总是返回 true。
代码范例：
- 使用 uasort() 对数组进行排序
$array = [
'a' => 4,
'b' => 8,
'c' => -1,
'd' => -9,
'e' => 2
];
print_r("排序前：\n");
print_r($array);
uasort($array, function ($a, $b) {
return $a == $b ? 0 : ($a < $b ? -1 : 1);
});
print_r("\n排序后：\n");
print_r($array);
// 执行结果如下：
排序前：
Array
(
[a] => 4
[b] => 8
[c] => -1
[d] => -9
[e] => 2
)
排序后：
Array
(
[d] => -9
[c] => -1
[e] => 2
[a] => 4
[b] => 8
)
uksort()
使用自定义的比较函数对数组的键名进行排序，保持索引和值的对应关系。该函数会改变数组本身的排序，并不会生成新数组。
uksort(array &$array, callback $callback): bool
参数说明：
- 第一个参数 $array：为待排序的数组；
- 第二个参数 $callback：就是用户自定义的比较函数（语法
callback(mixed $a, mixed $b): int），比较规则：- $a < $b，返回小于0的整数，一般返回-1；
- $a = $b，返回0；
- $a > $b，返回大于0的整数，一般返回1。
升序：$a < $b ? -1 : 1
降序：$a < $b ? 1 : -1
返回值：
总是返回 true。
代码范例：
- 使用 uksort() 对数组进行排序
$array = [
'f' => 4,
'b' => 8,
'e' => -1,
'a' => -9,
'c' => 2
];
print_r("排序前：\n");
print_r($array);
uksort($array, function ($a, $b) {
return $a == $b ? 0 : ($a < $b ? -1 : 1);
});
print_r("\n排序后：\n");
print_r($array);
// 执行结果如下：
排序前：
Array
(
[f] => 4
[b] => 8
[e] => -1
[a] => -9
[c] => 2
)
排序后：
Array
(
[a] => -9
[b] => 8
[c] => 2
[e] => -1
[f] => 4
)
usort()
使用自定义的比较函数对数组的值进行排序，排序后会删除原有的键名，并给排序后的元素赋予新的键名。
usort(array &$array, callback $callback): bool
参数说明：
- 第一个参数 $array：为待排序的数组；
- 第二个参数 $callback：就是用户自定义的比较函数（语法
callback(mixed $a, mixed $b): int），比较规则：- $a < $b，返回小于0的整数，一般返回-1；
- $a = $b，返回0；
- $a > $b，返回大于0的整数，一般返回1。
升序：$a < $b ? -1 : 1
降序：$a < $b ? 1 : -1
返回值：
总是返回 true。
代码范例：
- 使用 usort() 对简单 int 数组进行排序
$array = [3, 2, 5, 6, 1];
print_r("排序前：\n");
var_export($array);
usort($array, function ($a, $b) {
return $a == $b ? 0 : ($a < $b ? -1 : 1);
});
print_r("\n排序后：\n");
var_export($array);
// 执行结果如下：
排序前：
array (
0 => 3,
1 => 2,
2 => 5,
3 => 6,
4 => 1,
)
排序后：
array (
0 => 1,
1 => 2,
2 => 3,
3 => 5,
4 => 6,
)
- 使用 usort() 对多维数组进行排序
$array = [
['name' => '张三', 'score' => 88],
['name' => '李四', 'score' => 84],
['name' => '王五', 'score' => 68],
['name' => '赵六', 'score' => 98],
['name' => '郑奇', 'score' => 95],
];
print_r("排序前：\n");
foreach($array as $item) {
print_r("{$item['name']}\t{$item['score']}\n");
}
usort($array, function ($a, $b) {
return $a['score'] == $b['score'] ? 0 : ($a['score'] < $b['score'] ? 1 : -1);
});
print_r("\n排序后：\n");
foreach($array as $item) {
print_r("{$item['name']}\t{$item['score']}\n");
}
// 执行结果如下：
排序前：
张三 88
李四 84
王五 68
赵六 98
郑奇 95
排序后：
赵六 98
郑奇 95
张三 88
李四 84
王五 68
打乱数组（随机排序）
shuffle()
打乱数组排序，随机排列单元的顺序。排序后会删除原有的键名，并给排序后的元素赋予新的键名。
语法如下：
shuffle(array &$array): bool
参数说明：
- array：必须参数，要排序的数组。
返回值：
成功返回true，失败返回false。
代码范例：
- 使用 shuffle() 打乱数组，不保持键值关联
$numbers = range(1, 10, 2);
print_r("排序前：\n");
print_r($numbers);
// 第一次打乱
shuffle($numbers);
print_r("\n第一次打乱排序后：\n");
print_r($numbers);
// 第二次打乱
shuffle($numbers);
print_r("\n第二次打乱排序后：\n");
print_r($numbers);
// 执行结果如下：
序前：
Array
(
[0] => 1
[1] => 3
[2] => 5
[3] => 7
[4] => 9
)
第一次打乱排序后：
Array
(
[0] => 9
[1] => 7
[2] => 1
[3] => 5
[4] => 3
)
第二次打乱排序后：
Array
(
[0] => 3
[1] => 9
[2] => 7
[3] => 5
[4] => 1
)