Comment trier un tableau de tableaux associatifs par valeur d'une clé donnée en PHP?

Compte tenu de ce tableau:

$inventory = array(

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

);

Je voudrais trier $inventoryles éléments par prix pour obtenir:

$inventory = array(

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

);

Comment puis-je faire ceci?

Vous avez raison, la fonction que vous recherchez est array_multisort().

Voici un exemple tiré directement du manuel et adapté à votre cas:

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

Depuis PHP 5.5.0, vous pouvez utiliser array_column () à la place de foreach

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

array_multisort($price, SORT_DESC, $inventory);

PHP 7+

Depuis PHP 7, cela peut être fait de manière concise en utilisant usortune fonction anonyme qui utilise l' opérateur du vaisseau spatial pour comparer les éléments.

Vous pouvez faire un tri croissant comme ceci:

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

Ou un tri décroissant comme celui-ci:

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

Pour comprendre comment cela fonctionne, notez que usortprend une fonction de comparaison fournie par l'utilisateur qui doit se comporter comme suit (à partir des documents):

La fonction de comparaison doit renvoyer un entier inférieur, égal ou supérieur à zéro si le premier argument est considéré respectivement inférieur, égal ou supérieur au second.

Et notez également que <=>, l'opérateur du vaisseau spatial,

renvoie 0 si les deux opérandes sont égaux, 1 si la gauche est supérieure et -1 si la droite est supérieure

c'est exactement ce qui a usortbesoin. En fait, presque toute la justification donnée pour ajouter <=>au langage dans https://wiki.php.net/rfc/combined-comparison-operator est qu'il

rend l' écriture callbacks de commande pour une utilisation avec usort()plus facile

PHP 5.3+

PHP 5.3 a introduit des fonctions anonymes, mais n'a pas encore d'opérateur de vaisseau spatial. Nous pouvons toujours utiliser usortpour trier notre tableau, mais c'est un peu plus détaillé et plus difficile à comprendre:

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

Notez que bien qu'il soit assez courant que les comparateurs traitant des valeurs entières renvoient simplement la différence des valeurs, comme $item2['price'] - $item1['price'], nous ne pouvons pas le faire en toute sécurité dans ce cas. C'est parce que les prix sont des nombres à virgule flottante dans l'exemple du poseur de questions, mais la fonction de comparaison à laquelle nous passons usortdoit renvoyer des entiers pour usortfonctionner correctement:

Revenant non entiers des valeurs de la fonction de comparaison, tel que le flotteur, se traduira par une distribution interne à nombre entier de la valeur de retour de la fonction de rappel. Ainsi, des valeurs telles que 0,99 et 0,1 seront toutes deux converties en une valeur entière de 0, qui comparera ces valeurs comme égales.

C'est un piège important à garder à l'esprit lors de l'utilisation usorten PHP 5.x! Ma version originale de cette réponse a fait cette erreur et pourtant j'ai accumulé dix votes positifs sur des milliers de vues apparemment sans que personne ne remarque le bug sérieux. La facilité avec laquelle les astucieux comme moi peuvent bousiller les fonctions du comparateur est précisément la raison pour laquelle l'opérateur de vaisseau spatial plus facile à utiliser a été ajouté au langage en PHP 7.

Alors que d'autres ont correctement suggéré l'utilisation de array_multisort(), pour une raison quelconque, aucune réponse ne semble reconnaître l'existence de array_column()ce qui peut grandement simplifier la solution. Donc, ma suggestion serait:

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

Étant donné que vos éléments de tableau sont des tableaux eux-mêmes avec des clés de chaîne, votre meilleur pari est de définir une fonction de comparaison personnalisée. C'est assez rapide et facile à faire. Essaye ça:

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

Produit les éléments suivants:

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

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

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

)

Je termine sur ceci:

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

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

Appelez simplement la fonction en passant le tableau et le nom du champ du tableau de deuxième niveau. Comme:

sort_array_of_array($inventory, 'price');

Vous pouvez utiliser usortavec une fonction anonyme, par exemple

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

les sorties:

first: pork

pork: 5.43
fruit: 3.5
milk: 2.9

De Trier un tableau de tableaux associatifs par valeur de clé donnée en php :

uasort ( http://php.net/uasort ) vous permet de trier un tableau selon votre propre fonction définie. Dans votre cas, c'est simple:

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

A été testé sur 100 000 enregistrements: Temps en secondes (calculé par microtime funciton). Uniquement pour les valeurs uniques sur le tri des positions clés.

Solution de la fonction de @Josh Davis: Temps passé : 1.5768740177155

Solution minière: Temps passé : 0,094044923782349

Solution:

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

J'utilise uasortcomme ça

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

Cette fonction est réutilisable:

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

Il fonctionne bien sur les valeurs de chaîne par défaut, mais vous devrez subvoquer le rappel pour une fonction de comparaison de nombres si toutes vos valeurs sont des nombres.

Vous pouvez essayer de définir votre propre fonction de comparaison, puis utiliser usort .

Voici une méthode que j'ai trouvée il y a longtemps et que j'ai un peu nettoyée. Cela fonctionne très bien et peut être rapidement modifié pour accepter également les objets.

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

}

pour changer la méthode de tri des objets, changez simplement la ligne suivante:

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

Pour exécuter la méthode, faites simplement

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
    )

)

essaye ça:

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

Fonction dynamique complète J'ai sauté ici pour le tri associatif de tableaux et j'ai trouvé cette fonction étonnante sur http://php.net/manual/en/function.sort.php . Cette fonction est très dynamique qui trie dans l'ordre croissant et décroissant avec la clé spécifiée.

Fonction simple pour trier un tableau par une clé spécifique. Maintient l'association d'index

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


} 

essaye ça:

asort($array_to_sort, SORT_NUMERIC);

pour référence voir ceci: http://php.net/manual/en/function.asort.php

voir divers drapeaux de tri ici: http://www.php.net/manual/en/function.sort.php