此问题旨在作为有关在 PHP 中排序数组的问题的参考。很容易认为您的特定案例是独特的并且值得提出一个新问题，但大多数实际上是此页面上解决方案之一的微小变化。
如果您的问题作为此问题的副本而关闭，请仅在您能解释为什么它与以下所有问题显着不同时才要求重新打开您的问题。
如何在 PHP 中对数组进行排序？
如何在 PHP 中对复杂数组进行排序？
如何在 PHP 中对对象数组进行排序？
有关使用 PHP 现有函数的实际答案，请参阅 1.，有关排序算法的学术详细答案（PHP 的函数实现以及您可能需要非常非常复杂的情况），请参阅 2。
$array = array(3, 5, 2, 8);
适用的排序功能：
sortrsortasortarsortnatsortnatcasesortksortkrsort它们之间的区别仅在于是否保留键值关联（“ a”函数），是从低到高排序还是反向排序（“ r”），是否对值或键进行排序（“ k”）以及它如何比较值（“ nat”与正常）。请参阅http://php.net/manual/en/array.sorting.php以获取概述和更多详细信息的链接。
$array = array(
array('foo' => 'bar', 'baz' => 42),
array('foo' => ..., 'baz' => ...),
...
);
如果要按$array每个条目的键 'foo' 进行排序，则需要自定义比较函数。上述sort和相关函数适用于他们知道如何比较和排序的简单值。PHP 并不简单地“知道”如何处理复杂的值array('foo' => 'bar', 'baz' => 42)。所以你需要告诉它。
为此，您需要创建一个比较函数。该函数需要两个元素，0如果这些元素被认为相等，则必须返回一个值，0如果第一个值较低，则返回一个值，如果第一个值较高，则返回0一个值。这就是所有需要的：
function cmp(array $a, array $b) {
if ($a['foo'] < $b['foo']) {
return -1;
} else if ($a['foo'] > $b['foo']) {
return 1;
} else {
return 0;
}
}
通常，您会希望使用匿名函数作为回调。如果要使用方法或静态方法，请参阅PHP 中指定回调的其他方法。
然后，您可以使用以下功能之一：
同样，它们仅在是否保持键值关联以及按值或键排序方面有所不同。阅读他们的文档以获取详细信息。
示例用法：
usort($array, 'cmp');
usort将从数组中取出两个项目并cmp用它们调用您的函数。所以cmp()将被称为$aasarray('foo' => 'bar', 'baz' => 42)和$bas another array('foo' => ..., 'baz' => ...)。然后该函数返回usort哪个值更大或它们是否相等。usort重复这个过程，为 和 传递不同的值$a，$b直到数组被排序。该cmp函数将被调用多次，至少与 中的值一样多次，并且每次都$array使用不同的值组合。$a$b
要习惯这个想法，试试这个：
function cmp($a, $b) {
echo 'cmp called with $a:', PHP_EOL;
var_dump($a);
echo 'and $b:', PHP_EOL;
var_dump($b);
}
您所做的只是定义一种自定义方法来比较两个项目，这就是您所需要的。这适用于各种价值观。
顺便说一句，这适用于任何值，这些值不必是复杂的数组。如果您想进行自定义比较，也可以在简单的数字数组上进行。
sort按引用排序，不返回任何有用的东西！请注意，数组就地排序，您不需要将返回值分配给任何东西。$array = sort($array)将数组替换为true，而不是排序数组。只是sort($array);工作。
如果您想按baz数字键排序，您需要做的就是：
function cmp(array $a, array $b) {
return $a['baz'] - $b['baz'];
}
多亏了The Power oF MATH，这将返回一个 < 0、0 或 > 0 的值，具体取决于$a是低于、等于还是大于$b。
请注意，这不适用于float值，因为它们将被简化为 aint并失去精度。改用显式-1和0返回1值。
如果你有一个对象数组，它的工作方式相同：
function cmp($a, $b) {
return $a->baz - $b->baz;
}
你可以在比较函数中做任何你需要的事情，包括调用函数：
function cmp(array $a, array $b) {
return someFunction($a['baz']) - someFunction($b['baz']);
}
第一个字符串比较版本的快捷方式：
function cmp(array $a, array $b) {
return strcmp($a['foo'], $b['foo']);
}
strcmp完全符合cmp这里的预期，它返回-1,0或1.
PHP 7 引入了spaceship 运算符，它统一并简化了等于/小于/大于跨类型的比较：
function cmp(array $a, array $b) {
return $a['foo'] <=> $b['foo'];
}
如果您想主要按 排序foo，但如果foo两个元素相等，则按 排序baz：
function cmp(array $a, array $b) {
if (($cmp = strcmp($a['foo'], $b['foo'])) !== 0) {
return $cmp;
} else {
return $a['baz'] - $b['baz'];
}
}
对于熟悉的人来说，这相当于使用ORDER BY foo, baz.
另请参阅这个非常简洁的速记版本以及如何为任意数量的键动态创建这样的比较函数。
如果要将元素排序为“手动顺序”，例如“foo”、“bar”、“baz”：
function cmp(array $a, array $b) {
static $order = array('foo', 'bar', 'baz');
return array_search($a['foo'], $order) - array_search($b['foo'], $order);
}
对于上述所有情况，如果您使用的是 PHP 5.3 或更高版本（并且您确实应该），请使用匿名函数来缩短代码并避免让另一个全局函数浮动：
usort($array, function (array $a, array $b) { return $a['baz'] - $b['baz']; });
这就是对复杂的多维数组进行排序的简单程度。再一次，只考虑教 PHP 如何分辨两个项目中的哪一个“更大”；让 PHP 进行实际的排序。
同样对于上述所有内容，要在升序和降序之间切换，只需交换$aand$b参数。例如：
return $a['baz'] - $b['baz']; // ascending
return $b['baz'] - $a['baz']; // descending
然后是奇特的array_multisort，它可以让您根据另一个数组对一个数组进行排序：
$array1 = array( 4, 6, 1);
$array2 = array('a', 'b', 'c');
这里的预期结果是：
$array2 = array('c', 'a', 'b'); // the sorted order of $array1
用于array_multisort到达那里：
array_multisort($array1, $array2);
从 PHP 5.5.0 开始，您可以使用array_column从多维数组中提取一列并对该列上的数组进行排序：
array_multisort(array_column($array, 'foo'), SORT_DESC, $array);
您还可以在任一方向上对多个列进行排序：
array_multisort(array_column($array, 'foo'), SORT_DESC,
array_column($array, 'bar'), SORT_ASC,
$array);
从 PHP 7.0.0 开始，您还可以从对象数组中提取属性。
如果您有更常见的情况，请随时编辑此答案。
好吧， deceze已经涵盖了大多数基本方法，我会尝试查看其他类型的排序
SplHeapclass SimpleHeapSort extends SplHeap {
public function compare($a, $b) {
return strcmp($a, $b);
}
}
// Let's populate our heap here (data of 2009)
$heap = new SimpleHeapSort();
$heap->insert("a");
$heap->insert("b");
$heap->insert("c");
echo implode(PHP_EOL, iterator_to_array($heap));
输出
c
b
a
SplMaxHeapSplMaxHeap 类提供堆的主要功能，将最大值保持在顶部。
$heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);
SplMinHeapSplMinHeap 类提供堆的主要功能，将最小值保持在顶部。
$heap = new SplMinHeap ();
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);
冒泡排序，有时被错误地称为下沉排序，是一种简单的排序算法，它通过重复遍历要排序的列表、比较每对相邻项目并在它们的顺序错误时交换它们来工作。重复通过列表，直到不需要交换，这表明列表已排序。该算法得名于较小元素“冒泡”到列表顶部的方式。因为它只使用比较对元素进行操作，所以是比较排序。尽管该算法很简单，但大多数其他排序算法对于大型列表更有效。
function bubbleSort(array $array) {
$array_size = count($array);
for($i = 0; $i < $array_size; $i ++) {
for($j = 0; $j < $array_size; $j ++) {
if ($array[$i] < $array[$j]) {
$tem = $array[$i];
$array[$i] = $array[$j];
$array[$j] = $tem;
}
}
}
return $array;
}
在计算机科学中，选择排序是一种排序算法，特别是就地比较排序。它具有 O(n2) 时间复杂度，使其在大型列表上效率低下，并且通常比类似的插入排序表现更差。选择排序以其简单性着称，在某些情况下，特别是在辅助内存有限的情况下，它比更复杂的算法具有性能优势。
function selectionSort(array $array) {
$length = count($array);
for($i = 0; $i < $length; $i ++) {
$min = $i;
for($j = $i + 1; $j < $length; $j ++) {
if ($array[$j] < $array[$min]) {
$min = $j;
}
}
$tmp = $array[$min];
$array[$min] = $array[$i];
$array[$i] = $tmp;
}
return $array;
}
插入排序是一种简单的排序算法，它一次构建一个最终排序的数组（或列表）。与更高级的算法（如快速排序、堆排序或合并排序）相比，它在大型列表上的效率要低得多。但是，插入排序提供了几个优点：
function insertionSort(array $array) {
$count = count($array);
for($i = 1; $i < $count; $i ++) {
$j = $i - 1;
// second element of the array
$element = $array[$i];
while ( $j >= 0 && $array[$j] > $element ) {
$array[$j + 1] = $array[$j];
$array[$j] = $element;
$j = $j - 1;
}
}
return $array;
}
Shellsort，也称为Shell排序或Shell的方法，是一种就地比较排序。它通过在与相邻元素完成之前开始与相距较远的元素进行比较和交换来概括交换排序，例如插入或冒泡排序。
function shellSort(array $array) {
$gaps = array(
1,
2,
3,
4,
6
);
$gap = array_pop($gaps);
$length = count($array);
while ( $gap > 0 ) {
for($i = $gap; $i < $length; $i ++) {
$tmp = $array[$i];
$j = $i;
while ( $j >= $gap && $array[$j - $gap] > $tmp ) {
$array[$j] = $array[$j - $gap];
$j -= $gap;
}
$array[$j] = $tmp;
}
$gap = array_pop($gaps);
}
return $array;
}
梳排序是一种相对简单的排序算法，最初由 Wlodzimierz Dobosiewicz 在 1980 年设计。后来它在 1991 年被 Stephen Lacey 和 Richard Box 重新发现。梳排序是对冒泡排序的改进。
function combSort(array $array) {
$gap = count($array);
$swap = true;
while ( $gap > 1 || $swap ) {
if ($gap > 1)
$gap /= 1.25;
$swap = false;
$i = 0;
while ( $i + $gap < count($array) ) {
if ($array[$i] > $array[$i + $gap]) {
// swapping the elements.
list($array[$i], $array[$i + $gap]) = array(
$array[$i + $gap],
$array[$i]
);
$swap = true;
}
$i ++;
}
}
return $array;
}
在计算机科学中，归并排序（也通常拼写为归并排序）是一种基于 O(n log n) 比较的排序算法。大多数实现会产生稳定的排序，这意味着实现会保留排序输出中相等元素的输入顺序
function mergeSort(array $array) {
if (count($array) <= 1)
return $array;
$left = mergeSort(array_splice($array, floor(count($array) / 2)));
$right = mergeSort($array);
$result = array();
while ( count($left) > 0 && count($right) > 0 ) {
if ($left[0] <= $right[0]) {
array_push($result, array_shift($left));
} else {
array_push($result, array_shift($right));
}
}
while ( count($left) > 0 )
array_push($result, array_shift($left));
while ( count($right) > 0 )
array_push($result, array_shift($right));
return $result;
}
快速排序或分区交换排序是由 Tony Hoare 开发的一种排序算法，平均而言，对 n 个项目进行 O(n log n) 比较。在最坏的情况下，它会进行 O(n2) 比较，尽管这种行为很少见。
function quickSort(array $array) {
if (count($array) == 0) {
return $array;
}
$pivot = $array[0];
$left = $right = array();
for($i = 1; $i < count($array); $i ++) {
if ($array[$i] < $pivot) {
$left[] = $array[$i];
} else {
$right[] = $array[$i];
}
}
return array_merge(quickSort($left), array(
$pivot
), quickSort($right));
}
排列排序，它通过生成输入数组/列表的可能排列来进行，直到发现已排序的排列。
function permutationSort($items, $perms = array()) {
if (empty($items)) {
if (inOrder($perms)) {
return $perms;
}
} else {
for($i = count($items) - 1; $i >= 0; -- $i) {
$newitems = $items;
$newperms = $perms;
list($foo) = array_splice($newitems, $i, 1);
array_unshift($newperms, $foo);
$res = permutationSort($newitems, $newperms);
if ($res) {
return $res;
}
}
}
}
function inOrder($array) {
for($i = 0; $i < count($array); $i ++) {
if (isset($array[$i + 1])) {
if ($array[$i] > $array[$i + 1]) {
return False;
}
}
}
return True;
}
在计算机科学中，基数排序是一种非比较整数排序算法，它通过按共享相同有效位置和值的单个数字对键进行分组来使用整数键对数据进行排序。
// Radix Sort for 0 to 256
function radixSort($array) {
$n = count($array);
$partition = array();
for($slot = 0; $slot < 256; ++ $slot) {
$partition[] = array();
}
for($i = 0; $i < $n; ++ $i) {
$partition[$array[$i]->age & 0xFF][] = &$array[$i];
}
$i = 0;
for($slot = 0; $slot < 256; ++ $slot) {
for($j = 0, $n = count($partition[$slot]); $j < $n; ++ $j) {
$array[$i ++] = &$partition[$slot][$j];
}
}
return $array;
}
假设你有一个这样的数组：
['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely']
现在您只想对第一个字母进行排序：
usort($array, function($a, $b) {
return strcmp($a[0], $b[0]);
});
结果是这样的：
['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester']
排序不稳定！
敏锐的观察者可能已经注意到，数组排序算法 (QuickSort) 并没有产生稳定的结果，并且没有保留相同首字母的单词之间的原始顺序。这种情况很简单，我们应该比较整个字符串，但是让我们假设您的用例更复杂，例如不同字段上的两个连续排序不应相互抵消。
施瓦茨变换
Schwartzian 变换，也称为 decorate-sort-undecorate 习惯用法，通过固有的不稳定排序算法实现稳定排序。
首先，用另一个数组装饰每个数组元素，该数组包含一个主键（值）和一个辅助键（它的索引或位置）：
array_walk($array, function(&$element, $index) {
$element = array($element, $index); // decorate
});
这会将数组转换为：
[
['Kale', 0], ['Kaleidoscope', 1],
['Aardvark', 2], ['Apple', 3],
['Leicester', 4], ['Lovely', 5]
]
现在，我们调整比较步骤；我们再次比较第一个字母，但如果它们相同，则使用辅助键来保留原始顺序：
usort($array, function($a, $b) {
// $a[0] and $b[0] contain the primary sort key
// $a[1] and $b[1] contain the secondary sort key
$tmp = strcmp($a[0][0], $b[0][0]);
if ($tmp != 0) {
return $tmp; // use primary key comparison results
}
return $a[1] - $b[1]; // use secondary key
});
之后，我们取消装饰：
array_walk($array, function(&$element) {
$element = $element[0];
});
最终结果：
['Aardvark', 'Apple', 'Kale', 'Kaleidoscope', 'Leicester', 'Lovely']
再利用呢？
您必须重写比较函数才能使用转换后的数组元素；你可能不想编辑你微妙的比较函数，所以这里有一个比较函数的包装：
function stablecmp($fn)
{
return function($a, $b) use ($fn) {
if (($tmp = call_user_func($fn, $a[0], $b[0])) != 0) {
return $tmp;
} else {
return $a[1] - $b[1];
}
};
}
让我们使用这个函数编写排序步骤：
usort($array, stablecmp(function($a, $b) {
return strcmp($a[0], $b[0]);
}));
瞧！您的原始比较代码又回来了。
从带有闭包的 PHP 5.3 开始，也可以使用闭包来确定排序的顺序。
例如，假设 $array 是一个包含月份属性的对象数组。
$orderArray = array("Jan","Feb","Mar","Apr","May","June","July","Aug","Sept","Oct","Nov","Dec");
usort($array, function($a, $b) use ($orderArray){
return array_search($a->month, $orderArray) - array_search($b->month, $orderArray);
});
在 .NET 中，LINQ 经常用于排序，它提供了比比较函数更好的语法，尤其是当对象需要按多个字段排序时。LINQ to PHP 有多个端口，包括YaLinqo库*。有了它，可以用一行对数组进行排序，而无需编写复杂的比较函数。
$sortedByName = from($objects)->orderBy('$v->name');
$sortedByCount = from($objects)->orderBy('$v->count');
$sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name');
可以通过将回调作为第二个参数传递来进一步自定义比较，例如：
$sortedByFilenameNat = from($objects)->orderBy('$v->filename', 'strnatcmp');
在这里，'$v->count'是function ($v) { return $v->count; }（都可以使用）的简写。这些方法链返回迭代器，->toArray()如果需要，可以通过在末尾添加将迭代器转换为数组。
在内部，orderBy相关方法调用适当的数组排序函数（uasort、krsort、multisort等usort）。
LINQ 包含更多受 SQL 启发的方法：过滤、分组、连接、聚合等。它最适合需要在不依赖数据库的情况下对数组和对象执行复杂转换的情况。
* 由我开发，请参阅自述文件了解更多详细信息以及与其他 LINQ 端口的比较
键值多维排序
通过键值对多维数组进行自然排序并保持原始顺序（不要打乱主键）：
function multisortByKeyValue( $k, $arr ) {
$ids = array();
$index = 1;
foreach ( $arr as $key => $row ) {
$ids[ $key ] = intval( $row[ $k ] ) . '-' . $index . '-' . $key;
$index ++;
}
natsort( $ids );
$arr = array_merge( $ids, $arr );
return $arr;
}
测试用例：
$arr = array(
'id1' => array(
'label' => 'ID 1',
'priority' => 30,
),
'id2' => array(
'label' => 'ID 2',
'priority' => 70,
),
'id3' => array(
'label' => 'ID 3',
'priority' => 20,
),
'id4' => array(
'label' => 'ID 4',
'priority' => 30,
),
);
$sorted = multisortByKeyValue( 'priority', $arr );
// $sorted equals to:
/*
array (
'id3' => array (
'label' => 'ID 3',
'priority' => 20,
),
'id1' => array (
'label' => 'ID 1',
'priority' => 30,
),
'id4' => array (
'label' => 'ID 4',
'priority' => 30,
),
'id2' => array (
'label' => 'ID 2',
'priority' => 70,
),
)
*/
基本排序
// Sort array
$sorted = sorted([3, 1, 2]);
// Sort array in descending order
$sortedDesc = sorted([3, 1, 2], true);
按函数结果排序
// Sort array by the result of a given function (order words by length)
$sortedByLength = sorted(['bc', 'a', 'abc'], 'strlen');
$sortedByLengthDesc = sorted(['bc', 'a', 'abc'], true, 'strlen');
// Sort array by the result of user-defined function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], function($v) { return $v[0]; });
// Which is the same as
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], itemGetter(0));
$sortedByTheFirstCharacterDesc = sorted(['bc', 'a', 'abc'], true, itemGetter(0));
// itemGetter(0) returns a function which takes an argument with access by index/key
// and returns the value at index 0
排序多维数组
// Sort multidimensional array (sort list of users by their names)
$users = [
array('name' => 'Robert', 'age' => 20),
array('name' => 'Alex', 'age' => 30),
array('name' => 'Jack', 'age' => 25),
];
$sortedByName = sorted($users, itemGetter('name'));
$sortedByNameDesc = sorted($users, true, itemGetter('name'));
// itemGetter('name') returns a function which takes an argument with access by index/key
// and returns the value of the 'name' key
排序对象数组
// Lets assume we have class User(name, age) with properties name and age
// and public methods getName() and getAge()
$users = [
new User('Robert', 20),
new User('Alex', 30),
new User('Jack', 25),
];
// Sort list of objects by property value (sort list of users by their name)
$sortedByName = sorted($users, propertyGetter('name'));
$sortedByNameDesc = sorted($users, true, propertyGetter('name'));
// propertyGetter('name') returns a function which takes an object
// and returns the value of its 'name' property
// Sort list of objects by method result (sort list of users by their age)
$sortedByAge = sorted($users, methodCaller('getAge'));
$sortedByAgeDesc = sorted($users, true, methodCaller('getAge'));
// methodCaller('getAge') returns a function which takes an object
// and returns the result of its getAge() method
使用比较功能进行排序
// Sort with a comparison function (order words lexicographically with strcmp)
$sortedLexicographically = sorted(['bc', 'a', 'abc'], false, null, 'strcmp');
// Sort with user-defined comparison function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], false, null, function($v1, $v2) {
return chr($v1[0]) - chr($v2[0]);
});
您可以在此处查看所有这些示例。
如果你想通过键值排序，那么你就可以做到一行，优雅而清晰。这将按价格升序排列。使用 array_multisort 和 array_column。
Array([0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => coffee [price] => 9.99 ) [2] => Array ( [name] => rice [price] => 4.04 ) )
array_multisort (array_column($array, 'price'), SORT_ASC, $array);
生产
Array ( [0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => rice [price] => 4.04 ) [2] => Array ( [name] => coffee [price] => 9.99 ) )
这个页面非常全面，但我想添加更多关于 spaceship 运算符（三路比较运算符）的令人敬畏的实用程序 - PHP7+ 的漂亮孩子。
这在减少代码膨胀和提高可读性方面取得了长足的进步。
在编写自定义排序 ( usort()/ uasort()/ uksort()) 函数来处理多个条件时，您只需在运算符的任一侧编写平衡数组并返回结果。不再有嵌套条件块或多次返回。
运算符两边的元素将被从左到右遍历，一次一个，并在遇到非平局或所有元素都已比较后立即返回评估。
我的演示示例数据：
$multidimArray = [
'a' => [
'boolean' => true,
'natString' => 'text10',
'object' => (object)['prop' => 2],
'float' => -.5,
'mixed' => []
],
'b' => [
'boolean' => true,
'natString' => 'text12',
'object' => (object)['prop' => 4],
'float' => 0,
'mixed' => null
],
'c' => [
'boolean' => false,
'natString' => 'text100',
'object' => (object)['prop' => 9],
'float' => -.5,
'mixed' => false
],
'd' => [
'boolean' => true,
'natString' => 'text1',
'object' => (object)['prop' => 9],
'float' => -5,
'mixed' => "\0"
],
'e' => [
'boolean' => false,
'natString' => 'text2',
'object' => (object)['prop' => 2],
'float' => .5,
'mixed' => ''
]
];
演示（为避免 Stackoverflow 页面膨胀，请查看输出的演示链接）：
排序逻辑：
浮动 ASC
uasort($multidimArray, function($a, $b) {
return [$b['boolean'], $a['float']] <=> [$a['boolean'], $b['float']];
});
排序逻辑：
布尔 ASC
uasort($multidimArray, function($a, $b) {
return [$a['mixed'], $a['object']->prop, $a['boolean']] <=> [$b['mixed'], $b['object']->prop, $b['boolean']];
});
排序逻辑：
natString ASC
uasort($multidimArray, function($a, $b) {
return [count(get_object_vars($a['object'])), is_iterable($a['mixed']), strlen($a['natString']), $a['natString']]
<=>
[count(get_object_vars($b['object'])), is_iterable($b['mixed']), strlen($b['natString']), $b['natString']];
});
此语法允许您以优雅的方式对值、函数结果、深层嵌套数据和排序方向进行排序。这绝对值得放入您的 php 工具带……对于处理非数据库数据的情况——因为当然 SQL 将是一种更明智的技术。
您可以自行决定，从 PHP7.4 开始，您可以对这些匿名函数使用箭头语法。 与箭头语法相同的脚本。
如果您想根据多个条件根据绝对最大值对数组进行排序，这里有一个简单的方法：
usort($arr, function($item, $nextItem) {
return (max($nextItem->firstNumber, $nextItem->secondNumber)) - (max($item->firstNumber, $item->secondNumber));
});
例子：
$foo = new stdClass;
$foo->createdDate = '10';
$foo->uploadedDate = '5';
$bar = new stdClass;
$bar->createdDate = '1';
$bar->uploadedDate = '12';
$baz = new stdClass;
$baz->createdDate = '25';
$baz->uploadedDate = '0';
$arr = [$foo, $bar, $baz];
// Order array by the highest number between "createdDate" and "uploadedDate".
usort($arr, function($item, $nextItem) {
return (max($nextItem->createdDate, $nextItem->uploadedDate)) - (max($item->createdDate, $item->uploadedDate));
});
结果是：
array (
0 =>
(object) array(
'createdDate' => '25',
'uploadedDate' => '0',
),
1 =>
(object) array(
'createdDate' => '1',
'uploadedDate' => '12',
),
2 =>
(object) array(
'createdDate' => '10',
'uploadedDate' => '5',
),
)
有几种方法可以对数组进行排序。我将提到一些执行该任务的方法。首先，我将给出一个称为“$numbers”的整数数组。
$number = array(8,9,3,4,0,1,2);
这是创建数组的常规方法。假设，我想按升序对该数组进行排序。为此，可以使用“sort()”方法。
<?php
$number = array(8,9,3,4,0,1,2);
sort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
现在考虑它的输出，
您可以看到打印的数字数组已排序。如果您希望该数字数组按降序排序，则可以使用“rsort()”方法执行该任务。
<?php
$number = array(8,9,3,4,0,1,2);
rsort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
考虑输出..
现在数组按降序排序。好的，让我们考虑一个关联数组。我将给出一个关联数组（关联数组意味着，每个索引都有唯一键值的数组。）像这样，
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
所以，现在我想根据它们的值按升序对这个数组进行排序。'asort()' 方法可以用于此。
<?php
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
asort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
如果根据它们的值降序排序，可以使用'arsort()'方法。假设您要根据其键值对该数组进行排序。在这种情况下，可以使用“ksort()”方法。
<?php
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
ksort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
现在考虑输出。
现在数组是根据它们的键值排序的。如果你想根据它们的键值对数组进行降序排序，可以使用'krsort()'方法。
<?php
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
krsort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
现在关联数组根据它们的键值降序排序。查看输出。
这些是在php中对数组进行升序或降序排序的一些方法。希望您能有所了解。谢谢！
如果有人想要一个更简单的解决方案来操作数组，只需使用 Laravel Collection 包，它有一个实现的 sortBy 函数，可以让你简单地按键排序。
$collection->sortBy('forename')->sortBy('surname');
即，为了首先按 a，然后是 b，然后是 c，正确的子句应该是
sortBy('c')->sortBy('b')->sortBy('a')
最简单的是使用 usort 函数对数组进行排序而无需任何循环：下面是一个示例：
$array_compare= array("0" =>4,"1"=>2,"2"=>500,"3"=>100);
这将按降序排序：
usort($array_compare, function($a, $b) {
return ($b['x1'] - $a['x1']) > 0 ? 1 :-1;
});
这将按升序排序：
usort($array_compare, function($a, $b) {
return ($b['x1'] - $a['x1']) < 0 ? 1 :-1;
});