Comment trier un tableau multidimensionnel en PHP [dupliquer]

introduction: une solution très généralisée pour PHP 5.3+

j'aimerais ajouter ma propre solution ici, car elle offre des fonctionnalités que d'autres réponses ne le font pas.

plus précisément, les avantages de cette solution comprennent:

1. c'est réutilisable : vous spécifiez la colonne sort comme une variable au lieu de la codifier.
2. c'est flexible : vous peut spécifier plusieurs colonnes de tri (autant que vous voulez) -- des colonnes supplémentaires sont utilisées comme briseurs de tie entre des éléments qui comparent initialement equal.
3. c'est réversible : vous pouvez spécifier que le tri doit être inversé -- individuellement pour chaque colonne.
4. C'est extensible : si l'ensemble de données contient des colonnes qui ne peuvent pas être comparées d'une manière" stupide " (par exemple chaînes de date), vous pouvez également spécifier comment convertissez ces éléments en une valeur qui peut être directement comparée (par exemple une instance DateTime ).
5. C'est associatif si vous voulez : ce code s'occupe des articles de tri, mais vous sélectionnez la fonction de tri réelle ( usort ou uasort ).
6. enfin, il n'utilise pas array_multisort : alors que array_multisort est pratique, il dépend de la création d'une projection de toutes vos données d'entrée avant tri. Cela consomme du temps et de la mémoire et peut être tout simplement prohibitif si votre ensemble de données est grand.

le code

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

comment utiliser

tout au long de cette section, Je fournirai des liens qui trient cet ensemble de données d'échantillon:

$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'),
);

Les bases

La fonction make_comparer accepte un nombre variable d'arguments qui définissent le tri désiré et renvoie une fonction que vous êtes censé utiliser comme argument pour usort ou uasort .

le cas d'utilisation le plus simple est de passer dans la clé que vous aimez utiliser pour comparer des éléments de données. Par exemple, pour trier $data par le name article que vous feriez

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

voir action .

La clé peut également être un nombre si les éléments sont tableaux indexés numériquement. Pour l'exemple de la question, ce serait

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

Voir en action .

colonnes de tri multiples

Vous pouvez spécifier plusieurs colonnes de tri en passant des paramètres supplémentaires à make_comparer . Par exemple, pour trier par "nombre" et ensuite par la colonne indexée à zéro:

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

Voir en action .

fonctionnalités Avancées

des fonctionnalités plus avancées sont disponibles si vous spécifiez une colonne de tri comme un tableau au lieu d'une chaîne simple. Ce tableau doit être indexé numériquement, et doit contenir les éléments suivants:

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

voyons comment nous pouvons utiliser ces fonctionnalités.

tri Inverse

pour trier par Nom descendant:

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

Voir en action .

pour trier par numéro descendant puis par Nom descendant:

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

voir action .

dans certains scénarios, vous pouvez avoir besoin de trier par une colonne dont les valeurs ne se prêtent pas bien au tri. Le la colonne " anniversaire "de l'ensemble de données de l'échantillon correspond à cette description: il n'est pas logique de comparer les anniversaires comme chaînes de caractères (parce que par exemple" 01/01/1980 "vient avant"10/10/1970"). Dans ce cas, nous voulons spécifier comment projet les données réelles à un formulaire que peut être comparé directement avec la sémantique désirée.

Projections peuvent être spécifiées comme n'importe quel type de appelable : comme chaînes, tableaux, ou les fonctions anonymes. Une projection est supposée accepter un argument et retourner sa forme projetée.

il est à noter que bien que les projections sont similaires aux fonctions de comparaison personnalisées utilisées avec usort et la famille, ils sont plus simples (il suffit de convertir une valeur à une autre) et de profiter de toutes les fonctionnalités déjà cuites dans make_comparer .

trions l'ensemble de données de l'exemple sans projection et voyons ce que se passe:

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

voir action .

ce n'était pas le résultat souhaité. Mais nous pouvons utiliser date_create comme une projection:

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

Voir en action .

C'est l'ordre correct que nous voulions.

il y a beaucoup d'autres choses que les projections peuvent accomplir. Par exemple, un moyen rapide d'obtenir un tri insensible à la casse est d'utiliser strtolower comme projection.

cela dit, je dois également mentionner qu'il est préférable de ne pas utiliser des projections si votre ensemble de données est grande: dans ce cas, il serait beaucoup plus rapide de projeter toutes vos données manuellement à l'avant et puis trier sans utiliser une projection, bien que ce faisant sera l'échange de l'utilisation de la mémoire accrue pour une vitesse de tri plus rapide.

enfin, voici un exemple qui utilise toutes les fonctionnalités: il trie d'abord par nombre descendant, puis par anniversaire Ascendant:

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

Voir en action .

avec usort . Voici une solution générique, que vous pouvez utiliser pour différentes colonnes:

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

à Trier par première colonne:

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

tri à rangées multiples utilisant une fermeture

Voici une autre approche utilisant uasort() et une fonction de rappel anonyme (fermeture). J'ai utilisé cette fonction régulièrement. PHP 5.3 requis " 151950920 – - plus de dépendances!

/**
 * Sorting array of associative arrays - multiple row sorting using a closure.
 * 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' ) );