基本一维数组

Question

此问题旨在作为有关在PHP中排序数组的问题的参考。很容易认为你的特定情况是独一无二的，并且值得一个新的问题，但大多数实际上是本页面上其中一个解决方案的微小变化。

如果您的问题与此问题的副本相同，请仅在您能够解释为何与以下所有问题明显不同时才要求重新提问。

如何在PHP中对数组进行排序？
如何在PHP中对复杂数组进行排序？如何在PHP中对对象数组进行排序？

Basic one dimensional arrays; Incl. Multi dimensional arrays, incl. arrays of objects; Incl. Sorting one array based on another
Sorting with SPL
Stable sort

对于使用PHP现有函数的实际答案，请参阅1.，有关排序算法的学术详细答案（PHP的函数实现以及您可能需要哪些非常复杂的案例），见2.

Answer 1

基本一维数组

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

适用的排序功能：

sort
rsort
asort
arsort
natsort
natcasesort
ksort
krsort

这些之间的区别仅在于是否保留了键值关联（＆＃34; a＆＃34;函数），无论是从低到高排序还是反向（＆＃34; { {1}}＆＃34;），是否对值或键进行排序（＆＃34; r＆＃34;）以及它如何比较值（＆＃34; k＆＃34;与正常）。有关详细信息，请参阅http://php.net/manual/en/array.sorting.php。

多维数组，包括对象数组

nat

如果您想通过密钥“foo”排序$array = array( array('foo' => 'bar', 'baz' => 42), array('foo' => ..., 'baz' => ...), ... );。对于每个条目，您需要自定义比较功能。上述$array和相关函数适用于他们知道如何比较和排序的简单值。 PHP不仅仅是＆＃34;知道＆＃34;如何处理复杂值，如sort;所以你需要告诉它。

为此，您需要创建比较功能。该函数需要两个元素，如果这些元素被认为是相等的，则必须返回array('foo' => 'bar', 'baz' => 42)，如果第一个值较低则必须返回低于0的值，如果第一个值为低，则值必须高于0更高。这就是所需要的：

通常，您需要使用anonymous function作为回调。如果要使用方法或静态方法，请参阅other ways of specifying a callback in PHP。

然后使用以下功能之一：

同样，他们只是在保持键值关联和按值或键排序方面有所不同。阅读他们的文档了解详情。

使用示例：

function cmp(array $a, array $b) {
    if ($a['foo'] < $b['foo']) {
        return -1;
    } else if ($a['foo'] > $b['foo']) {
        return 1;
    } else {
        return 0;
    }
}

usort($array, 'cmp');将从数组中获取两个项目并使用它们调用usort函数。因此，cmp将cmp()作为$a而array('foo' => 'bar', 'baz' => 42)作为另一个$b进行调用。然后函数返回array('foo' => ..., 'baz' => ...)哪个值更大或者它们是否相等。 usort重复此过程，为usort和$a传递不同的值，直到对数组进行排序。 $b函数将被多次调用，至少与cmp中的值一样多次，$array和{{的值的组合不同1}}每次。

要习惯这个想法，试试这个：

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

由于数学上的支持，这将返回一个值＆lt; 0,0或＆gt; 0取决于baz是否低于，等于或大于function cmp(array $a, array $b) { return $a['baz'] - $b['baz']; }。

请注意，这对于$a值不会很好，因为它们会降低到$b并失去精确度。使用明确的float，int和-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。

太空飞船运营商

PHP 7引入了spaceship operator，它统一并简化了比不同类型的比较相等/更小/更大的内容：

按多个字段排序

如果您想主要按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']; } }的SQL查询另请参阅this very neat shorthand version和how to create such a comparison function dynamically for an arbitrary number of keys。

排序为手动，静态订单

如果您想将元素分类为＆＃34;手动顺序＆＃34;喜欢＆＃34; foo＆＃34;，＆＃34; bar＆＃34;，＆＃34; baz＆＃34; ：

ORDER BY foo, baz

对于上述所有情况，如果您使用的是PHP 5.3或更高版本（并且您确实应该使用），请使用匿名函数来缩短代码并避免出现另一个全局函数：

function cmp(array $a, array $b) {
    static $order = array('foo', 'bar', 'baz');
    return array_search($a['foo'], $order) - array_search($b['foo'], $order);
}

复杂的多维数组的排序是多么简单。再次，只需考虑教PHP如何分辨两个项目中的哪一个＆＃34;更大＆＃34; ;让PHP做实际的排序。

同样对于上述所有情况，要在升序和降序之间切换，只需交换usort($array, function (array $a, array $b) { return $a['baz'] - $b['baz']; });和$a个参数即可。 E.g：

$b

根据另一个

对一个数组进行排序

然后是特殊的array_multisort，它可以让你根据另一个数组排序：

return $a['baz'] - $b['baz']; // ascending
return $b['baz'] - $a['baz']; // descending

这里的预期结果是：

$array1 = array( 4,   6,   1);
$array2 = array('a', 'b', 'c');

使用$array2 = array('c', 'a', 'b'); // the sorted order of $array1到达目的地：

array_multisort

从PHP 5.5.0开始，您可以使用array_multisort($array1, $array2);从多维数组中提取列并对该列上的数组进行排序：

array_column

从PHP 7.0.0开始，您还可以从对象数组中提取属性。

_{如果您有更常见的案例，请随时编辑此答案。}

Answer 2

deceze已涵盖大多数基本方法我会尝试查看其他类型的排序

使用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);

其他类型的排序

冒泡排序

来自Wikipedia article on Bubble Sort:

冒泡排序，有时被错误地称为下沉排序，是一种简单的排序算法，通过重复单步执行要排序的列表，比较每对相邻项目并交换它们（如果它们的顺序错误）。重复传递列表，直到不需要交换，这表明列表已排序。该算法的名称来自较小元素“冒泡”到列表顶部的方式。因为它只使用比较来操作元素，所以它是一种比较排序。虽然算法很简单，但大多数其他排序算法对大型列表更有效。

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

选择排序

来自the Wikipedia article on Selection sort:

在计算机科学中，选择排序是一种排序算法，特别是就地比较排序。它具有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;
}

插入排序

来自Wikipedia article on Insertion sort:

插入排序是一种简单的排序算法，可以一次构建最终排序的数组（或列表）。与大多数高级算法（如快速排序，堆栈或合并排序）相比，它在大型列表上的效率要低得多。但是，插入排序提供了几个优点：

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

希尔排序

来自Wikipedia article on Shellsort:

Shellsort，也称为Shell sort或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;
}

梳理排序

来自the Wikipedia article on Comb sort:

梳子排序是一种相对简单的排序算法，最初由Wlodzimierz Dobosiewicz于1980年设计。后来由Stephen Lacey和Richard Box在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;
}

合并排序

来自the Wikipedia article on Merge sort:

在计算机科学中，合并排序（通常拼写为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;
}

快速排序

来自the Wikipedia article on Quicksort:

Quicksort或分区交换排序是由Tony Hoare开发的排序算法，平均来说，O（n log n）比较对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));
}

排列排序

来自the Wikipedia article on Permutation sort:

排列排序，它通过生成输入数组/列表的可能排列来进行，直到发现排序的排列。

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

基数排序

来自the Wikipedia article on Radix sort:

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

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

Answer 3

稳定排序

我们假设您有一个这样的数组：

['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely']

现在你只想对第一个字母进行排序：

usort($array, function($a, $b) {
    return strcmp($a[0], $b[0]);
});

结果如下：

['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester']

排序不稳定！

敏锐的观察者可能已经注意到，数组排序算法（QuickSort）没有产生稳定的结果，并且相同的第一个字母的单词之间的原始顺序没有被保留。这个案例是微不足道的，我们应该比较整个字符串，但是让我们假设你的用例更复杂，例如在不同字段上的两个连续排序不应该相互抵消#s; s工作

Schwartzian变换

The Schwartzian transform，也称为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]);
}));

瞧！您的原始比较代码又回来了。

Answer 4

从带有闭包的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);
 });

Answer 5

LINQ

在.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端口的比较，请参阅自述文件}

Answer 6

按键值进行多维排序

按键值对多维数组进行自然排序，并保持原始顺序（不要随机排列主键）：

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

Answer 7

使用sorted中的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]);
});

您可以看到所有这些示例here。

Answer 8

如果要按键值排序，则可以一行完成，简洁明了。这将按价格升序排列。使用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 ) )

Answer 9

此页面非常全面，但是我想进一步介绍一下太空飞船运算符（三向比较运算符）的精妙实用程序-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页面过大，请查看the demo link的输出）

排序逻辑：

布尔值DESC（false = 0，true = 1，因此在false之前为true）

浮动ASC

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

排序逻辑：

混合ASC
对象ASC

布尔ASC

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

排序逻辑：

对象ASC的属性计数
混合DESC的可迭代性
natString长度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']];
});

此语法允许您以优雅的方式对值，功能结果，深度嵌套的数据和排序方向进行排序。对于处理非数据库数据的情况，这绝对是值得的。在这种情况下，SQL是一种更为明智的技术。

您可以自行决定从PHP7.4起将箭头语法与这些匿名函数一起使用。 Same script with arrow syntax。

Answer 10

有几种对数组进行排序的方法，我将提到一些执行该任务的方法。首先，我将给出一个称为'$ 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."  ";
     }
?>

考虑输出。

现在数组按降序排列。好吧，让我们考虑一个关联数组。我将给出一个关联数组（Associative array表示，每个索引具有唯一键值的数组。），

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

现在考虑输出。

Now数组是根据其键值排序的。如果要按其键值降序对数组进行排序，则可以使用'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中按升序或降序对数组进行排序的一些方法。希望对您有所帮助。谢谢！

Answer 11

如果有人希望使用更简单的解决方案来处理数组，只需使用Laravel Collection软件包即可，该软件包具有已实现的sortBy函数，可让您简单地按键进行排序。

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

即，为了先按a，然后按b，然后按c进行排序，正确的子句应为

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

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

Answer 12

如果您想根据多个条件根据绝对最大值对数组进行排序，这里有一个简单的方法：

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

Answer 13

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

如何在PHP中对数组和数据进行排序？

13 个答案:

基本一维数组

多维数组，包括对象数组

`$b`按引用排序，不会返回任何有用的内容！

自定义数字比较

物件

功能

字符串

太空飞船运营商

按多个字段排序

排序为手动，静态订单

根据另一个

使用SPL排序

`SplHeap`

`SplMaxHeap`

`SplMinHeap`

其他类型的排序

冒泡排序

选择排序

插入排序

希尔排序

梳理排序

合并排序

快速排序

排列排序

基数排序

稳定排序

LINQ

使用飞船操作员实施多种分类条件

如何在PHP中对数组和数据进行排序？

13 个答案:

基本一维数组

多维数组，包括对象数组

$b按引用排序，不会返回任何有用的内容！

自定义数字比较

物件

功能

字符串

太空飞船运营商

按多个字段排序

排序为手动，静态订单

根据另一个

使用SPL排序

SplHeap

SplMaxHeap

SplMinHeap

其他类型的排序

冒泡排序

选择排序

插入排序

希尔排序

梳理排序

合并排序

快速排序

排列排序

基数排序

稳定排序

LINQ

使用飞船操作员实施多种分类条件

`$b`按引用排序，不会返回任何有用的内容！

`SplHeap`

`SplMaxHeap`

`SplMinHeap`