Come ordinare una matrice di array associativi in ​​base al valore di una determinata chiave in PHP?

Dato questo array:

$inventory = array(

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

);

Vorrei ordinare $inventorygli elementi per prezzo per ottenere:

$inventory = array(

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

);

Come posso fare questo?

Hai ragione, la funzione che stai cercando è array_multisort().

Ecco un esempio preso direttamente dal manuale e adattato al tuo caso:

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

A partire da PHP 5.5.0 puoi usare array_column () invece di quello foreach

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

array_multisort($price, SORT_DESC, $inventory);

PHP 7+

A partire da PHP 7, questo può essere fatto in modo conciso utilizzando usortuna funzione anonima che utilizza l' operatore di astronave per confrontare gli elementi.

Puoi fare un ordinamento crescente come questo:

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

O un ordinamento discendente come questo:

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

Per capire come funziona, nota che usortaccetta una funzione di confronto fornita dall'utente che deve comportarsi come segue (dai documenti):

La funzione di confronto deve restituire un numero intero minore, uguale o maggiore di zero se il primo argomento è considerato rispettivamente minore di, uguale a o maggiore del secondo.

E nota anche che <=>, l'operatore dell'astronave,

restituisce 0 se entrambi gli operandi sono uguali, 1 se la sinistra è maggiore e -1 se la destra è maggiore

che è esattamente ciò di cui ha usortbisogno. In effetti, quasi l'intera giustificazione fornita per l'aggiunta <=>alla lingua in https://wiki.php.net/rfc/combined-comparison-operator è che

usort()semplifica la scrittura di ordini callback da utilizzare con

PHP 5.3+

PHP 5.3 ha introdotto funzioni anonime, ma non ha ancora l'operatore di astronave. Possiamo ancora usare usortper ordinare il nostro array, ma è un po 'più dettagliato e difficile da capire:

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

Si noti che sebbene sia abbastanza comune per i comparatori che si occupano di valori interi restituire semplicemente la differenza dei valori, come $item2['price'] - $item1['price'], in questo caso non possiamo farlo in modo sicuro. Questo perché i prezzi sono numeri in virgola mobile nell'esempio di chi chiede la domanda, ma la funzione di confronto a cui passiamo usortdeve restituire numeri interi per usortfunzionare correttamente:

La restituzione di valori non interi dalla funzione di confronto, come float, comporterà un cast interno a un numero intero del valore restituito del callback. Quindi valori come 0,99 e 0,1 verranno entrambi espressi su un valore intero pari a 0, che confronterà tali valori come uguali.

Questa è una trappola importante da tenere a mente quando si usa usortin PHP 5.x! La mia versione originale di questa risposta ha fatto questo errore eppure ho accumulato dieci voti su migliaia di visualizzazioni apparentemente senza che nessuno si accorgesse del grave bug. La facilità con cui i deficienti come me possono rovinare le funzioni del comparatore è precisamente la ragione per cui l'operatore di astronave più facile da usare è stato aggiunto al linguaggio in PHP 7.

Mentre altri hanno suggerito correttamente l'uso di array_multisort(), per qualche motivo nessuna risposta sembra riconoscere l'esistenza di array_column(), il che può semplificare notevolmente la soluzione. Quindi il mio suggerimento sarebbe:

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

Poiché gli elementi dell'array sono array stessi con chiavi di stringa, la soluzione migliore è definire una funzione di confronto personalizzata. È abbastanza veloce e facile da fare. Prova questo:

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

Produce quanto segue:

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

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

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

)

Ho finito con questo:

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

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

Basta chiamare la funzione, passando l'array e il nome del campo dell'array di secondo livello. Piace:

sort_array_of_array($inventory, 'price');

È possibile utilizzare usortcon una funzione anonima, ad es

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

uscite:

first: pork

pork: 5.43
fruit: 3.5
milk: 2.9

Da Ordina un array di array associativi in ​​base al valore di una determinata chiave in php :

uasort ( http://php.net/uasort ) consente di ordinare un array con la propria funzione definita. Nel tuo caso, è semplice:

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

È stato testato su 100000 record: tempo in secondi (calcolato dal microtime di funzione). Solo per valori univoci sull'ordinamento delle posizioni chiave.

Soluzione di funzione di @Josh Davis: tempo trascorso: 1.5768740177155

Miniera: tempo impiegato: 0,094044923782349

Soluzione:

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

Uso uasortcosì

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

Questa funzione è riutilizzabile:

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

Funziona bene sui valori di stringa per impostazione predefinita, ma dovrai sostituire il callback per una funzione di confronto dei numeri se tutti i tuoi valori sono numeri.

Potresti provare a definire la tua funzione di confronto e quindi utilizzare usort .

Ecco un metodo che ho trovato molto tempo fa e ripulito un po '. Funziona benissimo e può essere rapidamente modificato per accettare anche oggetti.

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

}

per cambiare il metodo per ordinare gli oggetti basta cambiare la seguente riga:

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

Per eseguire il metodo semplicemente

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
    )

)

prova questo:

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

Funzione dinamica completa Sono saltato qui per l'ordinamento di array associativo e ho trovato questa fantastica funzione su http://php.net/manual/en/function.sort.php . Questa funzione è molto dinamica che ordina in ordine crescente e decrescente con il tasto specificato.

Semplice funzione per ordinare un array in base a una chiave specifica. Mantiene l'associazione dell'indice

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


} 

prova questo:

asort($array_to_sort, SORT_NUMERIC);

per riferimento vedere questo: http://php.net/manual/en/function.asort.php

vedere qui vari flag di ordinamento: http://www.php.net/manual/en/function.sort.php