Cum Sort un array multidimensional în PHP

Cu usort . Iată o soluție generică pe care o puteți utiliza pentru diferite coloane:

class TableSorter {
  protected $column;
  function __construct($column) {
    $this->column = $column;
  }
  function sort($table) {
    usort($table, array($this, 'compare'));
    return $table;
  }
  function compare($a, $b) {
    if ($a[$this->column] == $b[$this->column]) {
      return 0;
    }
    return ($a[$this->column] < $b[$this->column]) ? -1 : 1;
  }
}

Pentru a sorta după prima coloană:

$sorter = new TableSorter(0);//sort by first column
$mdarray = $sorter->sort($mdarray);

Înainte de a putea să mă duc la clasa TableSorter, am venit cu o funcție bazată pe ce a oferit Shinhan .

function sort2d_bycolumn($array, $column, $method, $has_header)
  {
  if ($has_header)  $header = array_shift($array);
  foreach ($array as $key => $row) {
    $narray[$key]  = $row[$column]; 
    }
  array_multisort($narray, $method, $array);
  if ($has_header) array_unshift($array, $header);
  return $array;
  }

• $ array este array MD pe care doriți să-l sortați.
Coloana
• $ este coloana pe care doriți să o sortați.
Metoda
• $ este modul în care doriți să se efectueze sortarea, cum ar fi SORT_DESC
• $ has_header este setat la true dacă primul rând conține valori antet pe care nu doriți să le sortați.

Sortarea mai multor rânduri utilizând o închidere

Iată o altă abordare folosind uasort() și o funcție anonimă de apel invers (închidere). Am folosit această funcție în mod regulat. PHP 5.3 necesar - nu mai dependente!

/**
 * Sorting array of associative arrays - Sortarea mai multor rânduri utilizând o închidere.
 * See also: http://the-art-of-web.com/php/sortarray/
 *
 * @param array $data input-array
 * @param string|array $fields array-keys
 * @license Public Domain
 * @return array
 */
function sortArray( $data, $field ) {
    $field = (array) $field;
    uasort( $data, function($a, $b) use($field) {
        $retval = 0;
        foreach( $field as $fieldname ) {
            if( $retval == 0 ) $retval = strnatcmp( $a[$fieldname], $b[$fieldname] );
        }
        return $retval;
    } );
    return $data;
}

/* example */
$data = array(
    array( "firstname" => "Mary", "lastname" => "Johnson", "age" => 25 ),
    array( "firstname" => "Amanda", "lastname" => "Miller", "age" => 18 ),
    array( "firstname" => "James", "lastname" => "Brown", "age" => 31 ),
    array( "firstname" => "Patricia", "lastname" => "Williams", "age" => 7 ),
    array( "firstname" => "Michael", "lastname" => "Davis", "age" => 43 ),
    array( "firstname" => "Sarah", "lastname" => "Miller", "age" => 24 ),
    array( "firstname" => "Patrick", "lastname" => "Miller", "age" => 27 )
);

$data = sortArray( $data, 'age' );
$data = sortArray( $data, array( 'lastname', 'firstname' ) );

Introducerea: o soluție foarte generalizată pentru PHP 5.3+

Aș dori să adaug aici propria mea soluție, deoarece oferă caracteristici pe care alte răspunsuri nu le fac.

Mai exact, avantajele acestei soluții includ:

1. Este reutilizabil : specificați coloana de sortare ca variabilă în loc de codul hardcod.
2. Este flexibil : puteți specifica mai multe coloane de sortare (cât doriți) - coloanele suplimentare sunt utilizate ca coloane între elementele care compară inițial egal.
3. Este reversibil : puteți specifica că sortarea trebuie inversată - individual pentru fiecare coloană.
4. Este extensibil : dacă setul de date conține coloane care nu pot fi comparate într-un mod "prost" (de exemplu, șirul de date), puteți specifica cum să convertiți aceste elemente la o valoare care poate fi direct (de exemplu, o instanță DateTime ).
5. Asociativ dacă doriți : acest cod are grijă de sortarea elementelor, dar selectați funcția de sortare actuală ( usort sau uasort ).
6. În cele din urmă, nu se utilizează array_multisort : în timp ce array_multisort este convenabil, depinde de crearea unei proiecții a tuturor datelor introduse înainte de sortare. Acest lucru consumă timp și memorie și poate fi pur și simplu prohibitiv dacă setul de date este mare.

Codul

function make_comparer() {
   //Normalize criteria up front so that the comparer finds everything tidy
    $criteria = func_get_args();
    foreach ($criteria as $index => $criterion) {
        $criteria[$index] = is_array($criterion)
            ? array_pad($criterion, 3, null)
            : array($criterion, SORT_ASC, null);
    }

    return function($first, $second) use (&$criteria) {
        foreach ($criteria as $criterion) {
           //How will we compare this round?
            list($column, $sortOrder, $projection) = $criterion;
            $sortOrder = $sortOrder === SORT_DESC ? -1 : 1;

           //If a projection was defined project the values now
            if ($projection) {
                $lhs = call_user_func($projection, $first[$column]);
                $rhs = call_user_func($projection, $second[$column]);
            }
            else {
                $lhs = $first[$column];
                $rhs = $second[$column];
            }

           //Do the actual comparison; do not return if equal
            if ($lhs < $rhs) {
                return -1 * $sortOrder;
            }
            else if ($lhs > $rhs) {
                return 1 * $sortOrder;
            }
        }

        return 0;//tiebreakers exhausted, so $first == $second
    };
}

Cum să utilizați

Pe parcursul acestei secțiuni voi oferi linkuri care sortează acest set de date eșantion:

$data = array(
    array('zz', 'name' => 'Jack', 'number' => 22, 'birthday' => '12/03/1980'),
    array('xx', 'name' => 'Adam', 'number' => 16, 'birthday' => '01/12/1979'),
    array('aa', 'name' => 'Paul', 'number' => 16, 'birthday' => '03/11/1987'),
    array('cc', 'name' => 'Helen', 'number' => 44, 'birthday' => '24/06/1967'),
);

Cele elementare

Funcția make_comparer acceptă un număr variabil de argumente care definesc sortarea dorită și returnează o funcție pe care ar trebui să o utilizați ca argument pentru usort sau uasort < code>.

usort($data, make_comparer('name'));

usort($data, make_comparer(0));//0 = first numerically indexed column

usort($data, make_comparer('number', 0));

0 => the column name to sort on (mandatory)
1 => either SORT_ASC or SORT_DESC (optional)
2 => a projection function (optional)

usort($data, make_comparer(['name', SORT_DESC]));

usort($data, make_comparer(['number', SORT_DESC], ['name', SORT_DESC]));

usort($data, make_comparer('birthday'));

usort($data, make_comparer(['birthday', SORT_ASC, 'date_create']));

usort($data, make_comparer(
    ['number', SORT_DESC],
    ['birthday', SORT_ASC, 'date_create']
));