Arrays sortieren

PHP bietet mehrere Funktionen um Arrays zu sortieren. Diese Seite beinhaltet eine Übersicht über diese Funktionen.

Die Hauptunterschiede:

  • Einige Sortierungen basieren auf den Array Schlüsseln, während andere auf den Werten: $array['key'] = 'value'; basieren.
  • Die Korrelation zwischen den Schlüsseln und den Werten wird nach der Sortierung gepflegt, was bedeuted, dass die Schlüssel numerisch (0,1,2 ...) zurückgesetzt werden.
  • Die Reihenfolge der Sortierung: Alphabetisch, Niedrig nach Hoch (aufsteigend), Hoch zu Niedrig (absteigend), numerisch, natürlich, zufällig oder Benutzerdefiniert.
  • Hinweis: Alle Sortierungen werden direkt auf die Array-Variable selbst angewendet, entgegen der Rückgabe eines neu sortierten Arrays.
  • Wenn eine dieser Sortierfunktionen zwei Schlüssel/Werte als gleich ausstellt, dann ist die Ordnung undefiniert (die Sortierung ist nicht stabil).

Funktionsname Sortiert nach Pflegt Schlüssel Assoziation Art der Sortierung Ähnliche Funktionen
array_multisort() Wert Assoziativ: Ja, Numerisch: Nein Erste Array- oder Sortieroptionen array_walk()
asort() Wert Ja Aufsteigend arsort()
arsort() Wert Ja Absteigend asort()
krsort() Schlüssel Ja Absteigend ksort()
ksort() Schlüssel Ja Aufsteigend asort()
natcasesort() Wert Ja Natürlich, Beachtet Groß-/Kleinschreibung natsort()
natsort() Wert Ja Natürlich natcasesort()
rsort() Wert Nein Absteigend sort()
shuffle() Wert Nein Zufällig array_rand()
sort() Wert Nein Aufsteigend rsort()
uasort() Wert Ja Benutzerdefiniert uksort()
uksort() Schlüssel Ja Benutzerdefiniert uasort()
usort() Wert Nein Benutzerdefiniert uasort()

add a note add a note

User Contributed Notes 8 notes

"Matthew Rice"
6 years ago
While this may seem obvious, user-defined array sorting functions ( uksort(), uasort(), usort() ) will *not* be called if the array does not have *at least two values in it*.

The following code:                       


function usortTest($a, $b) {
    return -

$test = array('val1');
usort($test, "usortTest");

$test2 = array('val2', 'val3');
usort($test2, "usortTest");


Will output:

string(4) "val3"
string(4) "val2"

The first array doesn't get sent to the function.

Please, under no circumstance, place any logic that modifies values, or applies non-sorting business logic in these functions as they will not always be executed.
oculiz at gmail dot com
8 years ago
Another way to do a case case-insensitive sort by key would simply be:

($array, 'strcasecmp');

Since strcasecmp is already predefined in php it saves you the trouble to actually write the comparison function yourself.
Hayley Watson
3 years ago
Stabilizing the sort functions (in this case, usort).

function stable_usort(&$array, $cmp)
$i = 0;
$array = array_map(function($elt)use(&$i)
        return [
$i++, $elt];
usort($array, function($a, $b)use($cmp)
$cmp($a[1], $b[1]) ?: ($a[0] - $b[0]);
$array = array_column($array, 1);

Tags each array element with its original position in the array so that when the comparison function returns 0 the tie can be broken to put the earlier element first.
luca at lauretta dot info
1 year ago
If you're looking for a quick solution to make usort stable, you could use uksort like in the following example:


($array, function ($ak, $bk) use ($array) {
$a = $array[$ak];
$b = $array[$bk];
    if (
$a['foo'] === $b['foo']) return $ak - $bk;
$a['foo'] > $b['foo'] ? 1 : -1;


This works as expected only if the initial indices (keys) of $array are in ascending order.
bizarrus at icloud dot com
1 year ago
If you wan't to sort JSON based data or an multidimensional object (ascending or descending), you must fetch the array/object keys for sorting - After a sort, you can build a new Object with the correct sorting.

**Example Data:**
= [
'nameZ' => [
'A' => true,
'F'    => true,
'K'    => true
'nameU' => 'Hello World!',
'nameA' => [
'subData' => [
'resultX' => 1,
'resultB' => 4,
'resultI' => 6
'nameK' => [
'testing' => true

function json_sort(&$json, $ascending = true) {
$names = [];
// Creating a named array for sorting
foreach($json AS $name => $value) {
$names[] = $name;
$ascending) {
        } else {
$result = [];
$names AS $index => $name) {
// Sorting Sub-Data
if(is_array($json[$name]) || is_object($json[$name])) {
json_sort($json[$name], $ascending);
$result[$name] = $json[$name];
$json = $result;

($json, true); // Ascending order


($json, false); // Descending order

I had written these method for generating HashValues for an API-Request. The HTTP-Request POST the JSON-Data as Body and over GET-Parameter, an digest/token will be appended to validate the JSON-Data (prevent manipulation of the JSON Data).
monicse09ku at yahoo dot com
4 years ago
// takes an array and desired key value and returns an array
// searches through an array for a given key, if found the key that row is made the first row and the other rows are inserted accordingly.
// the facility of this function is to get the value with a specific key of an array as the first value.

/////////////////////////////// function starts //////////////////////////////

function dksort($array, $case){
        $a[$case] = $array[$case];
        foreach($array as $key=>$val){

                $a[$key] = $array[$key];

    return $a;

$d = array(

$c = dksort($d, '55');

////////////////////////// function ends ////////////////////////////////////////
roger dot vermeir at nokia dot com
4 months ago
I tend to use the following code for adding a sort on the keys when different values have the same key:

= array();
$res = $db->query("some sql");
while (
$row = $res->fetchRow()) {
$key = trim($row[0]);    // I know... 'colname' is better
$value = trim($row[1]);
$arr[$key] = $value . "_" . sprintf('%09d', $key);    // number
foreach (
$arr as $key=>$value_and_key) {
$value, $dummykey) = explode("_", $value_and_key);
"$key and $value"// reverse sorted by value, then key

Appending the key to the value makes arsort a kind of dual sort.
No need for extra user-defined functions...
Roger Vermeir
4 years ago
simple example sorting dotted version numbers

     function sortByVersionnumber($a,$b){
         $ta=explode(".",$a); $tb=explode(".",$b);
         foreach ($ta as $k => $v){
             if (isset($tb[$k])){
                 if($ta[$k] > $tb[$k]) {
                     return 1;
                 } elseif($ta[$k] < $tb[$k]) {
                     return -1;
         return 0;
     function vnksort(&$array){
         uksort($array ,"sortByVersionnumber");
To Top