小开

最佳答案

基本一维数组

$array = array(3, 5, 2, 8);

适用的排序函数:

sort
rsort
asort
arsort
natsort
natcasesort
ksort
krsort

它们之间的区别仅仅是键值关联是否被保留("a"函数)，是从低到高排序还是反向排序("r")，是对值排序还是对键排序("k")以及如何比较值("nat"比正常)。有关概述和进一步细节的链接，请参阅http://php.net/manual/en/array.sorting.php。

多维数组，包括对象数组

$array = array(
array('foo' => 'bar', 'baz' => 42),
array('foo' => ...,   'baz' => ...),
...
);

如果你想根据每个条目的'foo'键对$array进行排序，你需要一个自定义比较函数。上面的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中指定回调的其他方法. xml。

然后使用下列函数之一:

< a href = " http://php.net/usort " rel = " noreferrer > usort < / >
< a href = " http://php.net/uasort " rel = " noreferrer > uasort < / >
< a href = " http://php.net/uksort " rel = " noreferrer > uksort < / >

同样，它们的区别只在于是否保持键-值关联并按值或键排序。详细信息请阅读他们的文档。

使用示例:

usort($array, 'cmp');

usort将从数组中获取两个项，并使用它们调用cmp函数。因此cmp()将被调用，$a将被调用为array('foo' => 'bar', 'baz' => 42)， $b将被调用为另一个array('foo' => ..., 'baz' => ...)。然后函数返回usort，其中哪个值更大，或者它们是否相等。usort重复这个过程，为$a和$b传递不同的值，直到数组被排序。cmp函数将被多次调用，cmp5的调用次数与cmp2中的值相同，每次调用$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'];
}

由于数学的力量返回一个值<0, 0或>0，取决于$a是否小于、等于或大于$b。

注意，这对float值不起作用，因为它们将被简化为int并失去精度。使用显式的-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引入了宇宙飞船操作符，它统一和简化了跨类型的等于/小于/大于比较:

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的SQL查询。
也可参见这个简洁的简写版本和如何为任意数量的键动态创建这样一个比较函数

按手动、静态顺序排序

如果您想将元素按“手动顺序”进行排序;像“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来做实际的排序。

同样，对于上述所有类型，要在升序和降序之间切换，只需交换$a和$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已经涵盖了大多数基本方法，我会尝试看看其他类型的sort

用SPL排序

`SplHeap`

class 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

`SplMaxHeap`

SplMaxHeap类提供堆的主要功能，将最大值保持在顶部。

$heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);

`SplMinHeap`

SplMinHeap类提供了堆的主要功能，将最小值保持在顶部。

$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

从关于Shellsort的维基百科文章:

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年被斯蒂芬·莱西和理查德·博克斯重新发现。梳状排序改进了冒泡排序。

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;
}

归并排序

从关于归并排序的维基百科文章:

在计算机科学中，归并排序(也通常拼写为mergesort)是一种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排序的文章:

在计算机科学中，基数排序是一种非比较整数排序算法，它通过将键按具有相同重要位置和值的单个数字分组，对具有整数键的数据进行排序。

// 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']

那种东西不稳定!

敏锐的观察者可能已经注意到，数组排序算法(快速排序)并没有产生稳定的结果，并且相同首字母的单词之间的原始顺序没有被保留。这种情况很简单，我们应该比较整个字符串，但是让我们假设您的用例更复杂，比如在不同的字段上连续进行两次排序，它们不应该相互抵消。

施瓦兹变换

施瓦兹变换，也被称为装饰-排序-不装饰习语，它使用固有的不稳定排序算法来影响稳定排序。

首先，你用另一个数组装饰每个数组元素，这个数组包含一个主键(value)和一个辅助键(它的索引或位置):

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是一个包含month属性的对象数组。

 $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);
});

小开

LINQ

在. net中，LINQ经常用于排序，它提供了比比较函数更好的语法，特别是当对象需要按多个字段排序时。LINQ有几个到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端口的比较}

小开

使用排序函数从Nspl中排序数组非常方便:

基本分类

// 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]);
});

你可以看到所有这些例子在这里。

小开

最简单的方法是使用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;
});

小开

按键值进行多维排序

按键值对多维数组进行自然排序，并保持原始顺序(不打乱主键):

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,
),
)
*/

小开

有几种方法可以对数组进行排序。我将提到一些完成这项任务的方法。首先，我将给出一个整数数组，称为'$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);

那么，现在我想根据它们的值对这个数组进行升序排序。' sort()'方法可以用于此。

<?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."  ";
}
?>

现在考虑输出。 < / p >

现在数组根据它们的键值排序。如果您想根据键值降序排序数组，可以使用'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."  ";
}
?>

现在关联数组按照键值降序排序。看看输出。

< / p >

这些是php中按升序或降序排序数组的一些方法。我希望你能有所了解。谢谢你！

小开

如果你想按键值排序，那么你可以做一行，优雅而清晰。这将按价格递增来排序。使用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 ) )

小开

这个页面非常全面，但我想再补充一点关于宇宙飞船操作符(三向比较操作符)的强大实用程序——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页面膨胀，请参阅演示链接的输出):

< p >排序逻辑:

布尔DESC (false = 0, true = 1，所以true先于false)

< p > ASC浮动

uasort($multidimArray, function($a, $b) {
return [$b['boolean'], $a['float']] <=> [$a['boolean'], $b['float']];
});

Sorting logic:

mixed ASC
object ASC

boolean ASC

uasort($multidimArray, function($a, $b) {
return [$a['mixed'], $a['object']->prop, $a['boolean']] <=> [$b['mixed'], $b['object']->prop, $b['boolean']];
});

Sorting logic:

property count of object ASC
iterability of mixed DESC
natString length ASC

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']];
});

This syntax allows you to sort values, functional outcomes, deep-nested data, and sorting direction in a elegant fashion. This is definitely worth putting in your php toolbelt ...for cases when you are processing non-database data -- because of course SQL would be a much more sensible technique.

At your own discretion, from PHP7.4 you can use arrow syntax with these anonymous functions. Same script with arrow syntax.

小开

如果有人想要一个更简单的解决方案来操作数组，只需使用Laravel Collection包，它有一个实现的sortBy函数，可以让你简单地按键排序。

$collection->sortBy('forename')->sortBy('surname');

也就是说，为了先按a，然后按b，然后按c排序，正确的子句应该是

sortBy('c')->sortBy('b')->sortBy('a')

https://packagist.org/packages/tightenco/collect

小开

如果你想根据多个标准的绝对最大值对数组进行排序，这里有一个简单的方法:

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',
),
)

小开

这个答案是关于多列排序的，其中数组应该在每个一维元素中，根据非连续索引的值进行排序。这与多维排序不同，因为每个元素只由不同的Key=>Value对组成

function fncCmp( array $ItmOne, array $ItmTwo ) {       ; # callback for sorting items (which are arrays) by values at specific indexes
$strCmpOne = $ItmOne[ 'ColOne' ] . $ItmOne[ 'ColThr' ]; # build compound values
$strCmpTwo = $ItmTwo[ 'ColOne' ] . $ItmTwo[ 'ColThr' ]; #   to compare
return $strCmpOne <=> $strCmpTwo                      ; # pass back comparison-result
} # fncCmp


$arrDat = array(                                                       # define an array of items
array( 'ColOne' => 'Val2', 'ColTwo' => 'Val8', 'ColThr' => 'Val6' )  #   each of which
,array( 'ColOne' => 'Val2', 'ColTwo' => 'Val9', 'ColThr' => 'Val4' )  #   is an
,array( 'ColOne' => 'Val1', 'ColTwo' => 'Val7', 'ColThr' => 'Val5' )  #   array of
)                                                                    ; #   fields
var_dump       ( $arrDat           )                                 ; # emit items before sort
$bolSrt = usort( $arrDat, 'fncCmp' )                                 ; # sort the array by comparing elements
var_dump       ( $arrDat           )                                 ; # emit items after  sort

如何在PHP中排序数组和数据?