再学-PHP-基础-之-数组排序函数总结

时间:2022-10-13 11:25:15 作者:快盘下载人气:

文章目录

排序函数汇总对比
排序类型标志
按【值】排序的函数
- 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;]}	{$item[;age;]}	{$item[;score;]}
;;
}

// 执行结果如下;
姓名    年龄    成绩
————    ————    ————
赵六    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(;排序前;
;);
print_r($imgs);

natcasesort($imgs);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($imgs);

natsort($imgs);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($fruits);

sort($fruits);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($fruits);

sort($fruits, SORT_NATURAL | SORT_FLAG_CASE);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($fruits);

rsort($fruits);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($fruits);

rsort($fruits, SORT_NATURAL | SORT_FLAG_CASE);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($colors);

ksort($colors);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($ranks);

ksort($ranks);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($colors);

krsort($colors);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($ranks);

krsort($ranks);

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($array);

uasort($array, function ($a, $b) {
    return $a == $b ? 0 : ($a < $b ? -1 : 1);
});

print_r(;
排序后;
;);
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(;排序前;
;);
print_r($array);

uksort($array, function ($a, $b) {
    return $a == $b ? 0 : ($a < $b ? -1 : 1);
});

print_r(;
排序后;
;);
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(;排序前;
;);
var_export($array);

usort($array, function ($a, $b) {
    return $a == $b ? 0 : ($a < $b ? -1 : 1);
});

print_r(;
排序后;
;);
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(;排序前;
;);
foreach($array as $item) {
    print_r(;{$item[;name;]}	{$item[;score;]}
;);
}

usort($array, function ($a, $b) {
    return $a[;score;] == $b[;score;] ? 0 : ($a[;score;] < $b[;score;] ? 1 : -1);
});

print_r(;
排序后;
;);
foreach($array as $item) {
    print_r(;{$item[;name;]}	{$item[;score;]}
;);
}

// 执行结果如下;
排序前;
张三    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(;排序前;
;);
print_r($numbers);

// 第一次打乱
shuffle($numbers);
print_r(;
第一次打乱排序后;
;);
print_r($numbers);

// 第二次打乱
shuffle($numbers);
print_r(;
第二次打乱排序后;
;);
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
)


  
  加载全部内容