Wie sortiere ich ein Array von assoziativen Arrays nach dem Wert eines bestimmten Schlüssels in PHP?

Angesichts dieses Arrays:

$inventory = array(

   array("type"=>"fruit", "price"=>3.50),
   array("type"=>"milk", "price"=>2.90),
   array("type"=>"pork", "price"=>5.43),

);

Ich möchte die $inventoryElemente nach Preis sortieren , um Folgendes zu erhalten:

$inventory = array(

   array("type"=>"pork", "price"=>5.43),
   array("type"=>"fruit", "price"=>3.50),
   array("type"=>"milk", "price"=>2.90),

);

Wie kann ich das machen?

Sie haben Recht, die Funktion, die Sie suchen, ist array_multisort().

Hier ist ein Beispiel, das direkt aus dem Handbuch stammt und an Ihren Fall angepasst ist:

$price = array();
foreach ($inventory as $key => $row)
{
    $price[$key] = $row['price'];
}
array_multisort($price, SORT_DESC, $inventory);

Ab PHP 5.5.0 können Sie array_column () anstelle von foreach verwenden

$price = array_column($inventory, 'price');

array_multisort($price, SORT_DESC, $inventory);

PHP 7+

Ab PHP 7 kann dies usortmit einer anonymen Funktion , die den Raumschiffoperator verwendet, präzise erfolgen zum Vergleichen von Elementen , präzise erfolgen.

Sie können eine aufsteigende Sortierung wie folgt durchführen:

usort($inventory, function ($item1, $item2) {
    return $item1['price'] <=> $item2['price'];
});

Oder eine absteigende Sorte wie diese:

usort($inventory, function ($item1, $item2) {
    return $item2['price'] <=> $item1['price'];
});

Um zu verstehen, wie dies funktioniert, beachten Sie, dass usorteine vom Benutzer bereitgestellte Vergleichsfunktion verwendet wird, die sich wie folgt verhalten muss (aus den Dokumenten):

Die Vergleichsfunktion muss eine Ganzzahl zurückgeben, die kleiner, gleich oder größer als Null ist, wenn das erste Argument als kleiner, gleich oder größer als das zweite angesehen wird.

Und beachten Sie auch, dass <=>der Raumschiffbetreiber,

Gibt 0 zurück, wenn beide Operanden gleich sind, 1, wenn die linke größer ist, und -1, wenn die rechte größer ist

Welches ist genau das, was usortbraucht. Tatsächlich ist fast die gesamte Begründung für das Hinzufügen <=>zur Sprache in https://wiki.php.net/rfc/combined-comparison-operator, dass dies der Fall ist

usort()erleichtert das Schreiben von Bestellrückrufen zur Verwendung mit

PHP 5.3+

PHP 5.3 führte anonyme Funktionen ein, verfügt jedoch noch nicht über den Raumschiffoperator. Wir können usortunser Array immer noch sortieren, aber es ist etwas ausführlicher und schwerer zu verstehen:

usort($inventory, function ($item1, $item2) {
    if ($item1['price'] == $item2['price']) return 0;
    return $item1['price'] < $item2['price'] ? -1 : 1;
});

Beachten Sie, dass , obwohl es für Komparatoren ziemlich häufig ist mit ganzzahligen Werten zu tun nur die Differenz der Werte zurück, wie $item2['price'] - $item1['price']wir können nicht sicher tun , dass in diesem Fall. Dies liegt daran, dass die Preise im Beispiel des Fragestellers Gleitkommazahlen sind, aber die Vergleichsfunktion, an die wir übergeben, usortmuss Ganzzahlen zurückgeben, damit usortsie ordnungsgemäß funktioniert:

Das Zurückgeben von nicht ganzzahligen Werten aus der Vergleichsfunktion, z. B. float, führt zu einer internen Umwandlung in eine Ganzzahl des Rückgabewerts des Rückrufs. Werte wie 0,99 und 0,1 werden also beide auf einen ganzzahligen Wert von 0 umgewandelt, wodurch solche Werte als gleich verglichen werden.

Dies ist eine wichtige Falle, die Sie bei der Verwendung usortin PHP 5.x berücksichtigen sollten ! Meine ursprüngliche Version dieser Antwort hat diesen Fehler gemacht, und dennoch habe ich zehn positive Stimmen für Tausende von Ansichten gesammelt, ohne dass jemand den schwerwiegenden Fehler bemerkt hat. Die Leichtigkeit, mit der Schwachköpfe wie ich Komparatorfunktionen vermasseln können, ist genau der Grund, warum der benutzerfreundlichere Raumschiffoperator der Sprache in PHP 7 hinzugefügt wurde.

Während andere die Verwendung von richtig vorgeschlagen array_multisort()haben, scheint aus irgendeinem Grund keine Antwort die Existenz von anzuerkennen array_column(), was die Lösung erheblich vereinfachen kann. Mein Vorschlag wäre also:

array_multisort(array_column($inventory, 'price'), SORT_DESC, $inventory);

Da Ihre Array-Elemente selbst Arrays mit String-Schlüsseln sind, ist es am besten, eine benutzerdefinierte Vergleichsfunktion zu definieren. Es ist ziemlich schnell und einfach zu machen. Versuche dies:

function invenDescSort($item1,$item2)
{
    if ($item1['price'] == $item2['price']) return 0;
    return ($item1['price'] < $item2['price']) ? 1 : -1;
}
usort($inventory,'invenDescSort');
print_r($inventory);

Produziert folgendes:

Array
(
    [0] => Array
        (
            [type] => pork
            [price] => 5.43
        )

    [1] => Array
        (
            [type] => fruit
            [price] => 3.5
        )

    [2] => Array
        (
            [type] => milk
            [price] => 2.9
        )

)

Ich endete damit:

function sort_array_of_array(&$array, $subfield)
{
    $sortarray = array();
    foreach ($array as $key => $row)
    {
        $sortarray[$key] = $row[$subfield];
    }

    array_multisort($sortarray, SORT_ASC, $array);
}

Rufen Sie einfach die Funktion auf und übergeben Sie das Array und den Namen des Felds des Arrays der zweiten Ebene. Mögen:

sort_array_of_array($inventory, 'price');

Sie können usortmit anonymer Funktion verwenden, z

usort($inventory, function ($a, $b) { return strnatcmp($a['price'], $b['price']); });

$inventory = 
    array(array("type"=>"fruit", "price"=>3.50),
          array("type"=>"milk", "price"=>2.90),
          array("type"=>"pork", "price"=>5.43),
          );

function pricesort($a, $b) {
  $a = $a['price'];
  $b = $b['price'];
  if ($a == $b)
    return 0;
  return ($a > $b) ? -1 : 1;
}

usort($inventory, "pricesort");
// uksort($inventory, "pricesort");

print("first: ".$inventory[0]['type']."\n\n");
// for usort(): prints milk (item with lowest price)
// for uksort(): prints fruit (item with key 0 in the original $inventory)

// foreach prints the same for usort and uksort.
foreach($inventory as $i){
  print($i['type'].": ".$i['price']."\n");
}

Ausgänge:

first: pork

pork: 5.43
fruit: 3.5
milk: 2.9

Von Sortieren Sie ein Array von assoziativen Arrays nach dem Wert des angegebenen Schlüssels in PHP :

Mit uasort ( http://php.net/uasort ) können Sie ein Array nach Ihrer eigenen definierten Funktion sortieren. In Ihrem Fall ist das einfach:

$array = array(
  array('price'=>'1000.50','product'=>'test1'),
  array('price'=>'8800.50','product'=>'test2'),
  array('price'=>'200.0','product'=>'test3')
);

function cmp($a, $b) {
  return $a['price'] > $b['price'];
}

uasort($array, "cmp");

Wurde an 100 000 Datensätzen getestet: Zeit in Sekunden (berechnet durch Funktionsmikrozeit). Nur für eindeutige Werte beim Sortieren von Schlüsselpositionen.

Funktionslösung von @Josh Davis: Zeitaufwand : 1.5768740177155

Minenlösung : Verbringen Sie Zeit : 0,094044923782349

Lösung:

function SortByKeyValue($data, $sortKey, $sort_flags=SORT_ASC)
{
    if (empty($data) or empty($sortKey)) return $data;

    $ordered = array();
    foreach ($data as $key => $value)
        $ordered[$value[$sortKey]] = $value;

    ksort($ordered, $sort_flags);

    return array_values($ordered); *// array_values() added for identical result with multisort*
}

Ich benutze uasortso

<?php
$users = [
    [
        'username' => 'joe',
        'age' => 11
    ],
    [
        'username' => 'rakoto',
        'age' => 21
    ],
    [
        'username' => 'rabe',
        'age' => 17
    ],
    [
        'username' => 'fy',
        'age' => 19
    ],    
];


uasort($users, function ($item, $compare) {
    return $item['username'] >= $compare['username']; 
});

var_dump($users);

Diese Funktion ist wiederverwendbar:

function usortarr(&$array, $key, $callback = 'strnatcasecmp') {
    uasort($array, function($a, $b) use($key, $callback) {
        return call_user_func($callback, $a[$key], $b[$key]);
    });
}

Es funktioniert gut auf String - Werte standardmäßig, aber Sie werden für eine zu sub den Rückruf haben Nummer Vergleichsfunktion , wenn alle Werte Zahlen sind.

Sie könnten versuchen, Ihre eigene Vergleichsfunktion zu definieren und dann usort zu verwenden .

Hier ist eine Methode, die ich vor langer Zeit gefunden und ein bisschen aufgeräumt habe. Dies funktioniert hervorragend und kann schnell geändert werden, um auch Objekte zu akzeptieren.

/**
 * A method for sorting arrays by a certain key:value.
 * SortByKey is the key you wish to sort by
 * Direction can be ASC or DESC.
 *
 * @param $array
 * @param $sortByKey
 * @param $sortDirection
 * @return array
 */
private function sortArray($array, $sortByKey, $sortDirection) {

    $sortArray = array();
    $tempArray = array();

    foreach ( $array as $key => $value ) {
        $tempArray[] = strtolower( $value[ $sortByKey ] );
    }

    if($sortDirection=='ASC'){ asort($tempArray ); }
        else{ arsort($tempArray ); }

    foreach ( $tempArray as $key => $temp ){
        $sortArray[] = $array[ $key ];
    }

    return $sortArray;

}

Um die Methode zum Sortieren von Objekten zu ändern, ändern Sie einfach die folgende Zeile:

$tempArray[] = strtolower( $value[ $sortByKey ] ); zu $tempArray[] = strtolower( $value->$sortByKey );

Um die Methode auszuführen, tun Sie einfach

sortArray($inventory,'price','ASC');

//Just in one line custom function
function cmp($a, $b)
{
return (float) $a['price'] < (float)$b['price'];
}
@uasort($inventory, "cmp");
print_r($inventory);

//result

Array
(
[2] => Array
    (
        [type] => pork
        [price] => 5.43
    )

[0] => Array
    (
        [type] => fruit
        [price] => 3.5
    )

[1] => Array
    (
        [type] => milk
        [price] => 2.9
    )

)

Versuche dies:

$prices = array_column($inventory, 'price');
array_multisort($prices, SORT_DESC, $inventory);
print_r($inventory);

Vollständige dynamische Funktion Ich bin hier zur assoziativen Array-Sortierung gesprungen und habe diese erstaunliche Funktion auf http://php.net/manual/en/function.sort.php gefunden . Diese Funktion ist sehr dynamisch und sortiert in aufsteigender und absteigender Reihenfolge mit dem angegebenen Schlüssel.

Einfache Funktion zum Sortieren eines Arrays nach einem bestimmten Schlüssel. Behält die Indexzuordnung bei

<?php

function array_sort($array, $on, $order=SORT_ASC)
{
    $new_array = array();
    $sortable_array = array();

    if (count($array) > 0) {
        foreach ($array as $k => $v) {
            if (is_array($v)) {
                foreach ($v as $k2 => $v2) {
                    if ($k2 == $on) {
                        $sortable_array[$k] = $v2;
                    }
                }
            } else {
                $sortable_array[$k] = $v;
            }
        }

        switch ($order) {
            case SORT_ASC:
                asort($sortable_array);
            break;
            case SORT_DESC:
                arsort($sortable_array);
            break;
        }

        foreach ($sortable_array as $k => $v) {
            $new_array[$k] = $array[$k];
        }
    }

    return $new_array;
}

$people = array(
    12345 => array(
        'id' => 12345,
        'first_name' => 'Joe',
        'surname' => 'Bloggs',
        'age' => 23,
        'sex' => 'm'
    ),
    12346 => array(
        'id' => 12346,
        'first_name' => 'Adam',
        'surname' => 'Smith',
        'age' => 18,
        'sex' => 'm'
    ),
    12347 => array(
        'id' => 12347,
        'first_name' => 'Amy',
        'surname' => 'Jones',
        'age' => 21,
        'sex' => 'f'
    )
);

print_r(array_sort($people, 'age', SORT_DESC)); // Sort by oldest first
print_r(array_sort($people, 'surname', SORT_ASC)); // Sort by surname

$arr1 = array(

    array('id'=>1,'name'=>'aA','cat'=>'cc'),
    array('id'=>2,'name'=>'aa','cat'=>'dd'),
    array('id'=>3,'name'=>'bb','cat'=>'cc'),
    array('id'=>4,'name'=>'bb','cat'=>'dd')
);

$result1 = array_msort($arr1, array('name'=>SORT_DESC);

$result2 = array_msort($arr1, array('cat'=>SORT_ASC);

$result3 = array_msort($arr1, array('name'=>SORT_DESC, 'cat'=>SORT_ASC));


function array_msort($array, $cols)
{
    $colarr = array();
    foreach ($cols as $col => $order) {
    $colarr[$col] = array();
    foreach ($array as $k => $row) { $colarr[$col]['_'.$k] = strtolower($row[$col]); }
}

$eval = 'array_multisort(';

foreach ($cols as $col => $order) {
    $eval .= '$colarr[\''.$col.'\'],'.$order.',';
}

$eval = substr($eval,0,-1).');';
eval($eval);
$ret = array();
foreach ($colarr as $col => $arr) {
    foreach ($arr as $k => $v) {
        $k = substr($k,1);
        if (!isset($ret[$k])) $ret[$k] = $array[$k];
        $ret[$k][$col] = $array[$k][$col];
    }
}
return $ret;


} 

Versuche dies:

asort($array_to_sort, SORT_NUMERIC);

Referenz finden Sie hier: http://php.net/manual/en/function.asort.php

Hier finden Sie verschiedene Sortierflags: http://www.php.net/manual/en/function.sort.php