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


292

该问题旨在作为有关PHP中数组排序问题的参考。容易想到您的特定案例是独特的,值得提出新的问题,但是实际上大多数都是此页面上一种解决方案的细微变化。

如果您的问题作为该问题的副本被关闭,请仅在您可以解释为什么该问题与以下所有内容明显不同时才要求重新提出您的问题。

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


  1. 基本的一维数组;含税 多维数组,包括 对象数组;含税 根据另一个对一个数组进行排序

  2. 用SPL排序

  3. 稳定排序

有关使用PHP现有功能的实用答案,请参见1 .;有关排序算法的学术详细答案(PHP函数实现的,以及对于真正非常复杂的情况可能需要的),请参阅2。


@jterry就是这样,这就是为什么我最终提出一个很好的参考问题来解决这个问题的原因。单独回答每个独特的雪花都无济于事。:)
deceze

3
我认为人们应该只看一下php.net
Alexander Jardim

@Alex Ha!绝对。问题是:没有人使用RTFM。:D
deceze

2
我们已经有了这些答案,建议您在此处将每个答案内的最佳答案列表链接,而不要复制(或重写)内容。此外,阵列往往会单独出现,因此无论如何,工作仍需对伪造品进行全票表决。
hakre

1
@deceze:如果没有人RTFM,也没有人也将有RTFQA-现有的问答:)
hakre 2013年

Answers:


164

基本的一维数组

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

适用的排序功能:

  • sort
  • rsort
  • asort
  • arsort
  • natsort
  • natcasesort
  • ksort
  • krsort

两者之间的区别仅在于是否保留键值关联(“ a”功能),是否从低到高或反向r排序(“ ”),对值或键进行排序(“ k”)以及如何比较值(“ nat”与正常)。有关概述以及指向更多详细信息的链接,请参见http://php.net/manual/zh-CN/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()将被称为$aas array('foo' => 'bar', 'baz' => 42)$bas as 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'];
}

多亏了数学运算的功率,它返回的值$a小于,等于0还是大于0,具体取决于是小于,等于还是大于$b

请注意,这不适用于float值,因为它们会降低为int并失去精度。使用显式-101返回值。

对象

如果您有一个对象数组,则其工作方式相同:

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在这里,它返回-101

飞船操作员

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

对于熟悉的人,这等效于带有的SQL查询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进行实际排序。

同样,对于以上所有内容,要在升序和降序之间切换,只需交换$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);

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


如果您遇到更常见的情况,请随时编辑此答案。


数值比较功能不适用于浮点值;我敢肯定,你知道我的意思:)
杰克

1
对于静态订单,我将申请array_flip()使用更快的位置查找,例如$order[$a['foo']]代替array_search($a['foo'], $order)
杰克

可能会有一些大的修改:gist.github.com/Rizier123/24a6248758b53245a63e839d8e08a32b,但是如果您认为这是一种改进,并且我包括了所有可以应用的必要内容。
Rizier123 '16

@ Rizier123我当然为这项工作表示赞赏,这是一个很好的文章;但我希望将其作为单独的答案发布,即使它非常相似。您的重写包含很多细节(按引用传递,大表等),但是这些细节分散了比较功能IMHO的工作原理的核心介绍的注意力。我特意多次明确参考该手册,因为应该在其中查找这些详细信息。无需在这里重复它,而转移了我试图传达的核心思想。
deceze

@deceze,因为它是参考问答,所以主要的挑战是显示尽可能紧凑和可读的信息,并使用户易于找到其排序功能。我做了一些调整:gist.github.com/Rizier123/24a6248758b53245a63e839d8e08a32b,但我仍然要考虑一下,如果将它作为单独的答案发布是有用且有价值的,因为它的内容非常相似
Rizier123

139

好吧,大多数基本方法已经包含在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上关于冒泡排序的文章:

冒泡排序(有时被错误地称为沉没排序)是一种简单的排序算法,其工作原理是:反复浏览要排序的列表,比较每对相邻项,如果顺序错误则将其交换。重复通过列表,直到不需要交换为止,这表明列表已排序。该算法的名称来自较小元素“冒泡”到列表顶部的方式。因为它仅使用比较来对元素进行操作,所以它是一种比较排序。尽管该算法很简单,但是大多数其他排序算法对于大型列表而言效率更高。

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

选择排序

Wikipedia上有关Selection的文章进行排序:

在计算机科学中,选择排序是一种排序算法,特别是就地比较排序。它具有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上Wikipedia文章中:

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年设计。后来,它由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;
}

合并排序

维基百科上有关合并的文章进行排序:

在计算机科学中,合并排序(通常也称为拼写合并排序)是一种基于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;
}

快速排序

Quicksort上的Wikipedia文章:

快速排序或分区交换排序是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));
}

排列排序

维基百科上有关排列的文章进行排序:

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

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上的Wikipedia文章进行排序:

在计算机科学中,基数排序是一种非比较型整数排序算法,该算法通过按共享相同有效位和值的单个数字对键进行分组,从而用整数键对数据进行排序。

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

4
@deceze,您涵盖了所有基础知识..我不得不寻找另一种相关的方法:)
Baba

5
我认为更合理的学术排序方法没有什么问题:)对于大多数应用程序来说,很多用处不大,但偶尔可能需要/要求它们提供参考,特别是因为随着时间的流逝我忘记了其中的大多数
Dave

实际上,为了进行快速排序,建议将数据透视表选择为三个值中位数:first,middle和last元素是我进行枢轴筛选的示例。这样可以避免发生最坏情况的反向排序数组(O(n^2)如果仅使用第一个元素作为枢轴,则会导致比较)
Alma Do

我听说spl比普通数组排序要快。对吗?
jewelhuq

我同意戴夫(Dave)的观点,如今,几乎有很多人提到了为什么我很少记得或使用它。
Mike Nguyen

43

稳定排序

假设您有一个像这样的数组:

['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-unecorate惯用语)通过固有的不稳定排序算法实现稳定的排序。

首先,用另一个包含主键(值)和辅助键(其索引或位置)的数组装饰每个数组元素:

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

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


您所说的“用固有的不稳定排序算法来影响稳定排序”对我来说是非常重要的时刻。维基百科页面上没有提到“稳定”一词,在我看来,这是转换的美。耻辱。
Tyler Collier'3

1
@TylerCollier是啊,你需要参考维基百科的字里行间......我救了你这样做;-)的麻烦
杰克

15

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

只需记住,这将删除任何以前的相对顺序(例如,预排序列表中的第一个“ July”对象可能会在排序后结束于July对象组的末尾)。请参阅上面的“稳定排序”。
乔治·兰利

9

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以及相关的方法调用相应的数组排序功能(uasortkrsortmultisortusort等等)。

LINQ包含许多受SQL启发的方法:过滤,分组,联接,聚合等。它最适合需要在不依赖数据库的情况下对数组和对象执行复杂转换的情况。

*由我开发,请参阅自述文件以了解更多详细信息并与其他LINQ端口进行比较


3

按键值多维排序

通过键值对多维数组进行自然排序,并保持原始顺序(请勿乱序主键):

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

2

使用Nspl的sorted函数对数组进行排序非常方便:

基本排序

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

您可以在此处查看所有这些示例。


2

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

1

该页面非常全面,但是我想进一步介绍一下太空飞船运算符(三向比较运算符)的出色工具-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页面过大,请查看演示链接以获取输出):

  • 排序逻辑:

    1. 布尔DESC(false = 0,true = 1,因此在false之前为true)
    2. 浮动ASC

      uasort($multidimArray, function($a, $b) {
          return [$b['boolean'], $a['float']] <=> [$a['boolean'], $b['float']];
      });
  • 排序逻辑:

    1. 混合ASC
    2. 对象ASC
    3. 布尔ASC

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

    1. 对象ASC的属性计数
    2. 混合DESC的可迭代性
    3. natString长度ASC
    4. 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起,您可以自行决定将箭头语法与这些匿名函数一起使用。 带有箭头语法的相同脚本


0

如果有人想要一个更简单的解决方案来操作数组,只需使用Laravel Collection软件包,该软件包具有已实现的sortBy函数,可让您简单地按键排序。

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

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

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

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


-1

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

现在考虑输出。 在此处输入图片说明

现在数组按其键值排序

<?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中按升序或降序对数组进行排序的一些方法。希望对您有所帮助。谢谢!


Deceze是否已经用以下内容涵盖了这些见解:“两者之间的区别仅在于是否保留键值关联(“ a”函数),是否按从高到低的顺序(“ r”)进行排序,是否对值或键(“ k”)进行排序,以及如何比较值(“ nat”与“正常”)。” 在接受的答案?
mickmackusa

-2

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

1
1)示例和代码不一致。2)以上答案中已经详细解释了这一点。3)您是否可能想回答其他问题?
deceze
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.