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

Question

这个问题旨在作为有关在PHP中排序数组的问题的参考。很容易想到您的特殊情况是独一无二的，值得一个新问题，但实际上大多数是此页面上一种解决方案的较小变体。

如果您的问题是作为此副本的重复，请要求重新打开您的问题，如果您可以解释为什么它与以下所有内容有明显不同。

我该如何在PHP中分类数组？
我如何在php中排序复杂数组？
如何在PHP中对对象进行排序？

---

1. 基本的一维数组；包括。多维阵列，包括。对象的数组；包括。根据另一个数组对一个数组进行排序

2. 与Spl

   分类

3. 稳定排序

用于使用PHP的现有功能的实际答案，请参见1.，有关分类算法的学术上的信息答案（哪个PHP的功能）实施以及您可能需要的真正非常复杂的情况），请参阅2。

Answer 1

基本一维数组

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

适用的排序功能：

• sort
• rsort
• asort
• arsort
• natsort
• <代码> natcasesort
• ksort
• krsort

这些之间的区别仅仅是保留键值关联（“ a ”功能），无论是低对高还是反向（“ r ”），无论是对值还是键（“ k ”），以及如何比较值（“ nat “与正常人）。参见 http://php.net/manual/manual/aray/array.sorting.php 有关概述并链接到更多详细信息。

多维数组，包括对象的数组，

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

如果要按每个条目的键'foo'对 $ array 进行排序，则需要自定义比较函数。上面的 sort 和相关功能在他们知道如何比较和排序的简单值上工作。 PHP不仅要“知道”如何使用复杂值喜欢 array（'foo'=＆gt;'bar'，'baz'=＆gt; 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
• uasort

再次，它们仅在保持键值关联并按值或键进行排序方面有所不同。阅读他们的文档以获取详细信息。

示例用法：

usort($array, 'cmp');

用户将从数组中获取两个项目，并与它们调用您的 cmp 函数。因此， cmp（）将以 $ a 为 array（'foo'=＆gt;'bar'，'baz'=＆gt; 42）和 $ b 作为另一个 array（'foo'=＆gt; ...，'baz'=＆gt; ...）。然后，该函数返回到用户哪个值更大或它们是否相等。 用户重复此过程，传递 $ 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'];
}

感谢 Math的功能，这将返回一个值＆lt; 0，0或＆gt; 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 dik确切地说， cmp 在这里，它返回 -1 ， 0 或 1 。

太空飞船运营商

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查询，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);
}

---

对于上述所有内容， 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开始，您也可以从对象数组中提取属性。

---

如果您有更多常见的情况，请随时编辑此答案。

Answer 2

大多数基本方法已经被 deveze 我会尝试

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

output

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

选择排序

来自 wikipedia on Selection Sorts上的文章：

在计算机科学中，选择排序是一种分类算法，特别是现场比较。它具有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文章上的文章：

插入排序是一种简单的排序算法，一次构建最终排序的数组（或列表）一次。在大型列表中，它的效率要比更高级的算法（例如QuickSort，heapsort或Merge Sorts）少得多。但是，插入排序提供了几个优点：

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

梳子排序

来自 wikipedia在梳子上的文章：

梳子排序是一种相对简单的排序算法，最初由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;
}

合并

从 Merge Sort上的Wikipedia文章：

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

。

大多数实现都会产生稳定的形式，这意味着该实现从

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

置换

从 wikipedia on repuren -noting 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;
}

radix

从 radix sort上的wikipedia文章：

在计算机科学中，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) 无法产生稳定的结果，并且具有相同首字母的单词之间的原始顺序未保留。这种情况很简单，我们应该比较整个字符串，但我们假设您的用例更复杂，例如不同字段上的两次连续排序不应抵消彼此的工作。

施瓦茨变换

施瓦茨变换，也称为装饰- 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 是包含月份属性的对象数组。

 $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

in .NET，LINQ经常用于排序，它在比较函数上提供了更好的语法，尤其是当需要通过多个字段对对象进行排序时。 LINQ的几个端口都到PHP，包括 yalinqo library*。有了它，可以用一条线对数组进行排序，而无需编写复杂的比较功能。

$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-＆gt; count'是 function（$ v）{返回$ v的速记 - ＆gt; count; } （可以使用任何一种）。这些方法链返回迭代器，可以通过在需要时添加 - ＆gt; toarray（）将迭代器转换为数组。

内部， orderby 和相关方法调用适当的数组排序函数（ uasort ， krsort ， Multisort ， usort 等）。

LINQ包含更多受SQL启发的方法：过滤，分组，加入，汇总等。它最适合在不依赖数据库的情况下需要执行数组和对象的复杂转换的情况。

_{*由我开发的，请参见Readme，以获取更多详细信息和与其他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

这个页面非常全面，但我想添加更多关于太空船运算符（三向比较运算符）的强大实用程序——PHP7+ 的一个漂亮的孩子。

使用 spaceship 运算符实现多个排序条件

这在减少代码膨胀和提高可读性方面取得了巨大进步。

当编写自定义排序 (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，因此 true 在 false 之前）

  2. 浮动 ASC

     uasort($multidimArray, 函数($a, $b) {
         返回 [$b['boolean'], $a['float']] <=>; [$a['布尔值'], $b['浮动']];
     });
     

• 排序逻辑：

  1. 混合 ASC
  2. 对象 ASC

  3. 布尔 ASC

     uasort($multidimArray, 函数($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, 函数($a, $b) {
         返回 [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 开始，您可以对这些匿名函数使用箭头语法。 具有箭头语法的相同脚本。

Answer 8

用排序功能来自 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]);
});

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

Answer 9

如果您想按钥匙值订购，则可以进行一条线条，优雅而清晰。这将按价格上涨订购。使用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 10

如果您想根据多个条件根据绝对最高值对数组进行排序，可以使用以下简单方法：

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 11

有几种分类数组的方法。我会提到一些完成该任务的方法。所有方法，我将提供一个被称为“ $数字”的整数数组。

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

​

<?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中以升序或降序排列数组的某些方法。我希望您能得到一个想法。谢谢！

Answer 12

如果某人想要一个更简单的解决方案来操纵数组，只需使用Laravel Collection软件包，该软件包具有实现的分类函数，可以简单地通过钥匙进行排序即可。

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

即，为了首先按A，B，然后C进行排序，正确的子句将为

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

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

Answer 13

这个答案是关于多列排序的，其中应在每个一维元素中对数组进行排序。
这与多维形式不同，因为每个元素仅由各种键=＆gt;值对组成。

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

Answer 14

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