首页 PHP后端 再学 PHP 基础 之 数组排序函数总结

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

  • 原创
  • 作者：程序员三丰
  • 发布时间：2022-10-13 01:41
  • 标签： PHP 学习笔记
  • 浏览量：850
PHP日常开发对数据的处理中，对数组的了解和相关函数的熟悉程度，基础且重要，本文主要整理了一些用来排序数组的函数，并作了对比和介绍，以加深记忆。

排序函数汇总对比

先说说数组排序函数的主要特点和区别：

  • 排序依据：有些函数基于 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
)
声明：本文为原创文章，51blog.xyz和作者拥有版权，如需转载，请注明来源于51blog.xyz并保留原文链接：https://www.51blog.xyz/article/41

文章归档

PHP后端
Javascript前端
HTML/CSS
开发运维
资源分享
Go入门学习笔记
Python
强烈推荐的PHP全栈开发后台管理系统
buildadmin logo
Thinkphp8 Vue3 Element PLus TypeScript Vite Pinia

🔥BuildAdmin是一个永久免费开源，无需授权即可商业使用，且使用了流行技术栈快速创建商业级后台管理系统。

推荐文章

热门标签

PHP ThinkPHP ThinkPHP5.1 Go Mysql Mysql5.7 Redis Linux CentOS7 Git HTML CSS CSS3 Javascript JQuery Vue LayUI VMware Uniapp 微信小程序 docker wiki Confluence7 学习笔记 uView ES6 Ant Design Pro of Vue React ThinkPHP6.0 chrome 扩展 翻译工具 Nuxt SSR 服务端渲染 scrollreveal.js ThinkPHP8.0 Mac webman 跨域CORS vscode GitHub ECharts Canvas vue3 three.js 微信支付 PHP全栈开发 Python AI 人工智能 AI辅助 工作经验 实战笔记

友情链接