Comment puis-je trier les tableaux et les données en PHP?
Cette question est destinée à servir de référence pour les questions sur le tri des tableaux en PHP. Il est facile de penser que votre cas particulier est unique et mérite une nouvelle question, mais la plupart ne sont en fait que des variantes mineures de l’une des solutions présentées sur cette page.
Si votre question est fermée en tant que duplicata de celle-ci, veuillez demander à ce que votre question soit rouverte uniquement si vous pouvez expliquer pourquoi elle diffère nettement de toutes les informations ci-dessous.
Comment trier un tableau en PHP?
Comment trier un tableau complex en PHP?
Comment trier un tableau d'objets en PHP?
Pour une réponse pratique en utilisant les fonctions existantes de PHP, voir 1., pour obtenir une réponse détaillée des algorithmes de tri (que les fonctions de PHP implémentent et que vous pouvez avoir besoin de cas très complexes), voir 2.
Tableaux unidimensionnels de base
$array = array(3, 5, 2, 8);
Fonctions de tri applicables:
sortrsortasortarsortnatsortnatcasesortksortkrsort
La différence entre ceux-ci est simplement de savoir si les associations clé-valeur sont conservées (les fonctions "a"), si elles trient de bas en haut ou inversement ("r"), si elles trient des valeurs ou des clés ("k") et comment il compare les valeurs ("nat" vs. normal). Voir http://php.net/manual/en/array.sorting.php pour un aperçu et des liens vers des détails supplémentaires.
Tableaux multidimensionnels, y compris des tableaux d'objets
$array = array(
array('foo' => 'bar', 'baz' => 42),
array('foo' => ..., 'baz' => ...),
...
);
Si vous voulez trier $array par la clé 'foo' de chaque entrée, vous avez besoin d'une fonction de comparaison personnalisée . La sort ci-dessus et les fonctions connexes travaillent sur des valeurs simples qu’ils savent comment comparer et trier. PHP ne "sait" pas simplement quoi faire avec une valeur complexe comme array('foo' => 'bar', 'baz' => 42) cependant; alors vous devez le dire.
Pour ce faire, vous devez créer une fonction de comparaison . Cette fonction prend deux éléments et doit renvoyer 0 si ces éléments sont considérés comme égaux, une valeur inférieure à 0 si la première valeur est inférieure et une valeur supérieure à 0 si la première valeur est supérieure. C'est tout ce qui est nécessaire:
function cmp(array $a, array $b) {
if ($a['foo'] < $b['foo']) {
return -1;
} else if ($a['foo'] > $b['foo']) {
return 1;
} else {
return 0;
}
}
Souvent, vous souhaiterez utiliser une fonction anonyme comme rappel. Si vous souhaitez utiliser une méthode ou une méthode statique, consultez la autres moyens de spécifier un rappel dans PHP .
Vous utilisez ensuite l'une de ces fonctions:
Encore une fois, ils ne diffèrent que par le fait qu'ils conservent des associations clé-valeur et trient par valeurs ou par clés. Lisez leur documentation pour plus de détails.
Exemple d'utilisation:
usort($array, 'cmp');
usort prendra deux éléments du tableau et appellera votre fonction cmp avec eux. Donc, cmp() sera appelé avec $a en tant que array('foo' => 'bar', 'baz' => 42) et $b en tant qu'autre array('foo' => ..., 'baz' => ...). La fonction retourne ensuite à usort laquelle des valeurs était plus grande ou si elles étaient égales. usort répète ce processus en transmettant différentes valeurs pour $a et $b jusqu'à ce que le tableau soit trié. La fonction cmp sera appelée plusieurs fois, au moins autant de fois qu'il y a de valeurs dans $array, avec différentes combinaisons de valeurs pour $a et $b à chaque fois.
Pour vous habituer à cette idée, essayez ceci:
function cmp($a, $b) {
echo 'cmp called with $a:', PHP_EOL;
var_dump($a);
echo 'and $b:', PHP_EOL;
var_dump($b);
}
Vous n'avez fait que définir une méthode personnalisée de comparaison de deux éléments, c'est tout ce dont vous avez besoin. Cela fonctionne avec toutes sortes de valeurs.
À propos, cela fonctionne sur n'importe quelle valeur, les valeurs ne doivent pas nécessairement être des tableaux complexes. Si vous souhaitez effectuer une comparaison personnalisée, vous pouvez également le faire sur un simple tableau de nombres.
sort trie par référence et ne renvoie rien d’utile!
Notez que le tableau trie à la place, vous n'avez pas besoin d'attribuer la valeur de retour à rien. $array = sort($array) remplacera le tableau par true et non par un tableau trié. Juste sort($array); fonctionne.
Comparaisons numériques personnalisées
Si vous souhaitez effectuer un tri à l'aide de la clé baz, qui est numérique, il vous suffit de:
function cmp(array $a, array $b) {
return $a['baz'] - $b['baz'];
}
Merci à The PoWer OF MATH, cette fonction renvoie une valeur <0, 0 ou> 0 selon que $a est inférieur, égal ou supérieur à $b.
Notez que cela ne fonctionnera pas bien pour les valeurs float, car elles seront réduites à int et perdront de la précision. Utilisez à la place les valeurs explicites -1, 0 et 1.
Objets
Si vous avez un tableau d'objets, cela fonctionne de la même manière:
function cmp($a, $b) {
return $a->baz - $b->baz;
}
Les fonctions
Vous pouvez faire tout ce dont vous avez besoin dans une fonction de comparaison, y compris les fonctions d'appel:
function cmp(array $a, array $b) {
return someFunction($a['baz']) - someFunction($b['baz']);
}
Les cordes
Un raccourci pour la première version de comparaison de chaînes:
function cmp(array $a, array $b) {
return strcmp($a['foo'], $b['foo']);
}
strcmp fait exactement ce que l'on attend de cmp ici, il retourne -1, 0 ou 1.
Opérateur de vaisseau spatial
PHP 7 a introduit le opérateur de vaisseau spatial }, qui unifie et simplifie les comparaisons égales/inférieures/supérieures aux comparaisons entre types:
function cmp(array $a, array $b) {
return $a['foo'] <=> $b['foo'];
}
Tri par plusieurs champs
Si vous souhaitez trier principalement par foo, mais si foo est égal pour deux éléments, triez par baz:
function cmp(array $a, array $b) {
if (($cmp = strcmp($a['foo'], $b['foo'])) !== 0) {
return $cmp;
} else {
return $a['baz'] - $b['baz'];
}
}
Pour ceux qui sont familiers, cela équivaut à une requête SQL avec ORDER BY foo, baz.
Voir aussi cette version abrégée très soignée _ et comment créer dynamiquement une telle fonction de comparaison pour un nombre arbitraire de clés .
Tri en ordre manuel et statique
Si vous voulez trier les éléments dans un "ordre manuel" comme "foo", "bar", "baz":
function cmp(array $a, array $b) {
static $order = array('foo', 'bar', 'baz');
return array_search($a['foo'], $order) - array_search($b['foo'], $order);
}
Pour tout ce qui précède, si vous utilisez PHP 5.3 ou supérieur (et vous devriez vraiment), utilisez des fonctions anonymes pour un code plus court et pour éviter d'avoir une autre fonction globale flottante:
usort($array, function (array $a, array $b) { return $a['baz'] - $b['baz']; });
C’est à quel point le tri d’un tableau multidimensionnel complexe peut être simple. Encore une fois, il suffit de penser en termes de enseignement PHP comment savoir lequel des deux éléments est "supérieur"; laissez PHP faire le tri.De même, pour tout ce qui précède, pour basculer entre les ordres croissant et décroissant, échangez simplement les arguments $a et $b. Par exemple.:.
return $a['baz'] - $b['baz']; // ascending
return $b['baz'] - $a['baz']; // descending
array_multisort, qui vous permet de trier un tableau en fonction d'un autre:
$array1 = array( 4, 6, 1); $array2 = array('a', 'b', 'c');$array2 = array('c', 'a', 'b'); // the sorted order of $array1
array_multisort($array1, $array2);
array_multisort(array_column($array, 'foo'), SORT_DESC, $array);
.
If you have more common cases, feel free to edit this answer.
Eh bien, la plupart des méthodes de base sont déjà couvertes par deceze je voudrais essayer d’autres types de tri
Tri avec SPL
SplHeap
class SimpleHeapSort extends SplHeap {
public function compare($a, $b) {
return strcmp($a, $b);
}
}
// Let's populate our heap here (data of 2009)
$heap = new SimpleHeapSort();
$heap->insert("a");
$heap->insert("b");
$heap->insert("c");
echo implode(PHP_EOL, iterator_to_array($heap));
Sortie
c
b
a
SplMaxHeap
La classe SplMaxHeap fournit les fonctionnalités principales d'un segment de mémoire, tout en maintenant le maximum.
$heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);
SplMinHeap
La classe SplMinHeap fournit les principales fonctionnalités d'un tas, en gardant le minimum au sommet.
$heap = new SplMinHeap ();
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);
Autres types de tri
Tri à bulles
Extrait du Article Wikipedia sur Bubble Sort:
Le tri à bulles, parfois appelé à tort «sort», est un algorithme de tri simple qui fonctionne en parcourant de manière répétée la liste à trier, en comparant chaque paire d'éléments adjacents et en les échangeant s'ils sont dans le mauvais ordre. La liste est répétée jusqu'à ce qu'aucun échange ne soit nécessaire, ce qui indique que la liste est triée. L'algorithme tire son nom de la façon dont les petits éléments "bouillonnent" en haut de la liste. Comme il utilise uniquement des comparaisons pour opérer sur des éléments, il s’agit d’un tri comparatif. Bien que l'algorithme soit simple, la plupart des autres algorithmes de tri sont plus efficaces pour les grandes listes.
function bubbleSort(array $array) {
$array_size = count($array);
for($i = 0; $i < $array_size; $i ++) {
for($j = 0; $j < $array_size; $j ++) {
if ($array[$i] < $array[$j]) {
$tem = $array[$i];
$array[$i] = $array[$j];
$array[$j] = $tem;
}
}
}
return $array;
}
Tri de sélection
De l'article Wikipedia sur le tri de la sélection:
En informatique, le tri par sélection est un algorithme de tri, en particulier un tri par comparaison sur place. Sa complexité temporelle est O(n2), ce qui la rend inefficace pour les grandes listes et est généralement moins performante que le type d'insertion similaire. Le type de sélection se caractérise par sa simplicité et présente des avantages en termes de performances par rapport à des algorithmes plus complexes dans certaines situations, notamment lorsque la mémoire auxiliaire est limitée.
function selectionSort(array $array) {
$length = count($array);
for($i = 0; $i < $length; $i ++) {
$min = $i;
for($j = $i + 1; $j < $length; $j ++) {
if ($array[$j] < $array[$min]) {
$min = $j;
}
}
$tmp = $array[$min];
$array[$min] = $array[$i];
$array[$i] = $tmp;
}
return $array;
}
Tri par insertion
Extrait du Article Wikipedia sur le tri par insertion:
Le tri par insertion est un algorithme de tri simple qui construit le tableau final trié (ou la liste), un élément à la fois. Il est beaucoup moins efficace sur les grandes listes que des algorithmes plus avancés tels que le tri rapide, le tri massif ou le tri par fusion. Cependant, le tri par insertion offre plusieurs avantages:
function insertionSort(array $array) {
$count = count($array);
for($i = 1; $i < $count; $i ++) {
$j = $i - 1;
// second element of the array
$element = $array[$i];
while ( $j >= 0 && $array[$j] > $element ) {
$array[$j + 1] = $array[$j];
$array[$j] = $element;
$j = $j - 1;
}
}
return $array;
}
Shellsort
Extrait du Article Wikipedia sur Shellsort:
Shellsort, également connu sous le nom de type Shell ou méthode de Shell, est un type de comparaison sur place. Il généralise une sorte d'échange, telle qu'une insertion ou une sorte de bulle, en commençant la comparaison et l'échange d'éléments avec des éléments éloignés les uns des autres avant de terminer avec des éléments voisins.
function shellSort(array $array) {
$gaps = array(
1,
2,
3,
4,
6
);
$gap = array_pop($gaps);
$length = count($array);
while ( $gap > 0 ) {
for($i = $gap; $i < $length; $i ++) {
$tmp = $array[$i];
$j = $i;
while ( $j >= $gap && $array[$j - $gap] > $tmp ) {
$array[$j] = $array[$j - $gap];
$j -= $gap;
}
$array[$j] = $tmp;
}
$gap = array_pop($gaps);
}
return $array;
}
Type de peigne
De l'article de Wikipedia sur le tri des peignes:
Le tri par peigne est un algorithme de tri relativement simple conçu à l'origine par Wlodzimierz Dobosiewicz en 1980. Plus tard, il a été redécouvert par Stephen Lacey et Richard Box en 1991. Le tri par peigne améliore le tri à bulle.
function combSort(array $array) {
$gap = count($array);
$swap = true;
while ( $gap > 1 || $swap ) {
if ($gap > 1)
$gap /= 1.25;
$swap = false;
$i = 0;
while ( $i + $gap < count($array) ) {
if ($array[$i] > $array[$i + $gap]) {
// swapping the elements.
list($array[$i], $array[$i + $gap]) = array(
$array[$i + $gap],
$array[$i]
);
$swap = true;
}
$i ++;
}
}
return $array;
}
Tri par fusion
De l'article de Wikipedia sur le type de fusion:
En informatique, un tri par fusion (également couramment orthographié mergesort) est un algorithme de tri basé sur la comparaison O (n log n). La plupart des implémentations produisent un tri stable, ce qui signifie que l'implémentation conserve l'ordre d'entrée d'éléments identiques dans la sortie triée.
function mergeSort(array $array) {
if (count($array) <= 1)
return $array;
$left = mergeSort(array_splice($array, floor(count($array) / 2)));
$right = mergeSort($array);
$result = array();
while ( count($left) > 0 && count($right) > 0 ) {
if ($left[0] <= $right[0]) {
array_Push($result, array_shift($left));
} else {
array_Push($result, array_shift($right));
}
}
while ( count($left) > 0 )
array_Push($result, array_shift($left));
while ( count($right) > 0 )
array_Push($result, array_shift($right));
return $result;
}
Tri rapide
De l'article de Wikipedia sur Quicksort:
Quicksort, ou tri par échange de partitions, est un algorithme de tri développé par Tony Hoare qui effectue en moyenne des comparaisons O (n log n) pour trier n éléments. Dans le pire des cas, il effectue des comparaisons O(n2), bien que ce comportement soit rare.
function quickSort(array $array) {
if (count($array) == 0) {
return $array;
}
$pivot = $array[0];
$left = $right = array();
for($i = 1; $i < count($array); $i ++) {
if ($array[$i] < $pivot) {
$left[] = $array[$i];
} else {
$right[] = $array[$i];
}
}
return array_merge(quickSort($left), array(
$pivot
), quickSort($right));
}
Type de permutation
De l'article de Wikipedia sur le type de permutation:
Tri par permutation, qui génère les permutations possibles du tableau/de la liste en entrée jusqu'à la découverte du tableau trié.
function permutationSort($items, $perms = array()) {
if (empty($items)) {
if (inOrder($perms)) {
return $perms;
}
} else {
for($i = count($items) - 1; $i >= 0; -- $i) {
$newitems = $items;
$newperms = $perms;
list($foo) = array_splice($newitems, $i, 1);
array_unshift($newperms, $foo);
$res = permutationSort($newitems, $newperms);
if ($res) {
return $res;
}
}
}
}
function inOrder($array) {
for($i = 0; $i < count($array); $i ++) {
if (isset($array[$i + 1])) {
if ($array[$i] > $array[$i + 1]) {
return False;
}
}
}
return True;
}
Sorte de radix
De l'article de Wikipedia sur le genre Radix:
En informatique, Radix Sort est un algorithme de tri d’entiers non comparatif qui trie les données avec des clés entières en les regroupant par chiffres correspondant à la même position et à la même valeur.
// Radix Sort for 0 to 256
function radixSort($array) {
$n = count($array);
$partition = array();
for($slot = 0; $slot < 256; ++ $slot) {
$partition[] = array();
}
for($i = 0; $i < $n; ++ $i) {
$partition[$array[$i]->age & 0xFF][] = &$array[$i];
}
$i = 0;
for($slot = 0; $slot < 256; ++ $slot) {
for($j = 0, $n = count($partition[$slot]); $j < $n; ++ $j) {
$array[$i ++] = &$partition[$slot][$j];
}
}
return $array;
}
Genre stable
Disons que vous avez un tableau comme celui-ci:
['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely']
Et maintenant, vous voulez trier uniquement sur la première lettre:
usort($array, function($a, $b) {
return strcmp($a[0], $b[0]);
});
Le résultat est le suivant:
['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester']
Le genre n'était pas stable!
L'observateur averti a peut-être remarqué que l'algorithme de tri de tableaux (QuickSort) ne produisait pas un résultat stable et que l'ordre d'origine entre les mots de la même première lettre n'était pas préservé. Ce cas est trivial et nous aurions dû comparer la chaîne entière, mais supposons que votre cas d'utilisation est plus compliqué, comme deux tris consécutifs sur des champs différents qui ne devraient pas annuler le travail de chacun.
La transformation de Schwartz
La transformation de Schwartzian , également appelée idiome decorate-sort-undecorate, effectue un tri stable avec un algorithme de tri intrinsèquement instable.
Commencez par décorer chaque élément de tableau avec un autre tableau comprenant une clé primaire (la valeur) et une clé secondaire (son index ou sa position):
array_walk($array, function(&$element, $index) {
$element = array($element, $index); // decorate
});
Cela transforme le tableau en ceci:
[
['Kale', 0], ['Kaleidoscope', 1],
['Aardvark', 2], ['Apple', 3],
['Leicester', 4], ['Lovely', 5]
]
Maintenant, nous ajustons l’étape de comparaison; nous comparons à nouveau la première lettre, mais si elles sont identiques, la clé secondaire est utilisée pour conserver l'ordre d'origine:
usort($array, function($a, $b) {
// $a[0] and $b[0] contain the primary sort key
// $a[1] and $b[1] contain the secondary sort key
$tmp = strcmp($a[0][0], $b[0][0]);
if ($tmp != 0) {
return $tmp; // use primary key comparison results
}
return $a[1] - $b[1]; // use secondary key
});
Ensuite, nous décodons:
array_walk($array, function(&$element) {
$element = $element[0];
});
Le résultat final:
['Aardvark', 'Apple', 'Kale', 'Kaleidoscope', 'Leicester', 'Lovely']
Qu'en est-il de la réutilisation?
Vous deviez réécrire votre fonction de comparaison pour utiliser les éléments de tableau transformés. vous voudrez peut-être pas éditer vos fonctions de comparaison délicates, alors voici un wrapper pour la fonction de comparaison:
function stablecmp($fn)
{
return function($a, $b) use ($fn) {
if (($tmp = call_user_func($fn, $a[0], $b[0])) != 0) {
return $tmp;
} else {
return $a[1] - $b[1];
}
};
}
Écrivons l'étape de tri en utilisant cette fonction:
usort($array, stablecmp(function($a, $b) {
return strcmp($a[0], $b[0]);
}));
Voila! Votre code de comparaison vierge est de retour.
À partir de PHP 5.3 avec les fermetures, il est également possible d'utiliser une fermeture pour déterminer l'ordre de votre tri.
Par exemple, en supposant que $ array est un tableau d'objets contenant une propriété month.
$orderArray = array("Jan","Feb","Mar","Apr","May","June","July","Aug","Sept","Oct","Nov","Dec");
usort($array, function($a, $b) use ($orderArray){
return array_search($a->month, $orderArray) - array_search($b->month, $orderArray);
});
LINQ
Dans .NET, LINQ est fréquemment utilisé pour le tri, ce qui fournit une syntaxe beaucoup plus agréable par rapport aux fonctions de comparaison, notamment lorsque les objets doivent être triés selon plusieurs champs. Il existe plusieurs ports de LINQ vers PHP, y compris YaLinqo library *. Avec cela, les tableaux peuvent être triés avec une seule ligne sans écrire des fonctions de comparaison complexes.
$sortedByName = from($objects)->orderBy('$v->name');
$sortedByCount = from($objects)->orderBy('$v->count');
$sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name');
Les comparaisons peuvent être personnalisées en passant un rappel comme second argument, par exemple:
$sortedByFilenameNat = from($objects)->orderBy('$v->filename', 'strnatcmp');
'$v->count' est ici un raccourci pour function ($v) { return $v->count; } (l'un ou l'autre peut être utilisé). Ces chaînes de méthodes renvoient des itérateurs, lesquels peuvent être transformés en tableaux en ajoutant ->toArray() à la fin si nécessaire.
En interne, orderBy et les méthodes associées appellent les fonctions de tri de tableaux appropriées (uasort, krsort, multisort, usort, etc.).
LINQ contient beaucoup plus de méthodes inspirées par SQL: filtrage, regroupement, jonction, agrégation, etc. Il convient mieux aux cas où des transformations complexes sur des tableaux et des objets doivent être effectuées sans utiliser de bases de données.
* développé par moi, voir le readme pour plus de détails et une comparaison avec d'autres ports LINQ
Tri multidimensionnel par valeur de clé
Sorte naturelle d'un tableau multidimensionnel par une valeur de clé et conserve également l'ordre d'origine (ne mélangez pas les clés principales):
function multisortByKeyValue( $k, $arr ) {
$ids = array();
$index = 1;
foreach ( $arr as $key => $row ) {
$ids[ $key ] = intval( $row[ $k ] ) . '-' . $index . '-' . $key;
$index ++;
}
natsort( $ids );
$arr = array_merge( $ids, $arr );
return $arr;
}
Cas de test:
$arr = array(
'id1' => array(
'label' => 'ID 1',
'priority' => 30,
),
'id2' => array(
'label' => 'ID 2',
'priority' => 70,
),
'id3' => array(
'label' => 'ID 3',
'priority' => 20,
),
'id4' => array(
'label' => 'ID 4',
'priority' => 30,
),
);
$sorted = multisortByKeyValue( 'priority', $arr );
// $sorted equals to:
/*
array (
'id3' => array (
'label' => 'ID 3',
'priority' => 20,
),
'id1' => array (
'label' => 'ID 1',
'priority' => 30,
),
'id4' => array (
'label' => 'ID 4',
'priority' => 30,
),
'id2' => array (
'label' => 'ID 2',
'priority' => 70,
),
)
*/
Si vous souhaitez commander en fonction de la valeur de la clé, vous pouvez le faire en une ligne, élégante et claire. Cela commandera par le prix croissant. Utilise array_multisort et array_column.
Array([0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => coffee [price] => 9.99 ) [2] => Array ( [name] => rice [price] => 4.04 ) )
array_multisort (array_column($array, 'price'), SORT_ASC, $array);
produire
Array ( [0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => rice [price] => 4.04 ) [2] => Array ( [name] => coffee [price] => 9.99 ) )
Il est très pratique de trier les tableaux avec sorted function from Nspl :
Tri de base
// Sort array
$sorted = sorted([3, 1, 2]);
// Sort array in descending order
$sortedDesc = sorted([3, 1, 2], true);
Tri par résultat de fonction
// Sort array by the result of a given function (order words by length)
$sortedByLength = sorted(['bc', 'a', 'abc'], 'strlen');
$sortedByLengthDesc = sorted(['bc', 'a', 'abc'], true, 'strlen');
// Sort array by the result of user-defined function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], function($v) { return $v[0]; });
// Which is the same as
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], itemGetter(0));
$sortedByTheFirstCharacterDesc = sorted(['bc', 'a', 'abc'], true, itemGetter(0));
// itemGetter(0) returns a function which takes an argument with access by index/key
// and returns the value at index 0
Tri d'un tableau multidimensionnel
// Sort multidimensional array (sort list of users by their names)
$users = [
array('name' => 'Robert', 'age' => 20),
array('name' => 'Alex', 'age' => 30),
array('name' => 'Jack', 'age' => 25),
];
$sortedByName = sorted($users, itemGetter('name'));
$sortedByNameDesc = sorted($users, true, itemGetter('name'));
// itemGetter('name') returns a function which takes an argument with access by index/key
// and returns the value of the 'name' key
Tri du tableau d'objets
// Lets assume we have class User(name, age) with properties name and age
// and public methods getName() and getAge()
$users = [
new User('Robert', 20),
new User('Alex', 30),
new User('Jack', 25),
];
// Sort list of objects by property value (sort list of users by their name)
$sortedByName = sorted($users, propertyGetter('name'));
$sortedByNameDesc = sorted($users, true, propertyGetter('name'));
// propertyGetter('name') returns a function which takes an object
// and returns the value of its 'name' property
// Sort list of objects by method result (sort list of users by their age)
$sortedByAge = sorted($users, methodCaller('getAge'));
$sortedByAgeDesc = sorted($users, true, methodCaller('getAge'));
// methodCaller('getAge') returns a function which takes an object
// and returns the result of its getAge() method
Tri avec une fonction de comparaison
// Sort with a comparison function (order words lexicographically with strcmp)
$sortedLexicographically = sorted(['bc', 'a', 'abc'], false, null, 'strcmp');
// Sort with user-defined comparison function (order words by the 1st character)
$sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], false, null, function($v1, $v2) {
return chr($v1[0]) - chr($v2[0]);
});
Vous pouvez voir tous ces exemples ici .
Il existe plusieurs façons de trier un tableau. Je mentionnerai quelques méthodes pour effectuer cette tâche. Pour commencer, je vais donner un tableau entier appelé "$ nombres".
$number = array(8,9,3,4,0,1,2);
C'est la manière normale de créer un tableau. Supposons que je veuille trier ce tableau par ordre croissant. Pour cela, la méthode 'sort ()' peut être utilisée.
<?php
$number = array(8,9,3,4,0,1,2);
sort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
Maintenant, considérons la sortie de cela,
Vous pouvez voir que le tableau de nombres imprimé est trié. Si vous voulez que ce tableau de nombres soit trié par ordre décroissant, la méthode 'rsort ()' peut être utilisée pour cette tâche.
<?php
$number = array(8,9,3,4,0,1,2);
rsort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
considérer la sortie ..
Maintenant, tableau est trié par ordre décroissant.Ok, considérons un tableau associatif.Je vais donner un tableau associatif (Tableau associatif signifie que, Un tableau dont chaque index a une valeur de clé unique.) Comme ceci,
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
Donc, maintenant je veux trier ce tableau par ordre croissant en fonction de leur valeur. La méthode 'asort ()' peut être utilisée pour cela.
<?php
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
asort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
Si vous triez l'ordre décroissant en fonction de leur valeur, vous pouvez utiliser la méthode 'arsort ()' . Supposons que vous souhaitiez trier ce tableau en fonction de la valeur de leur clé. En cela, la méthode 'ksort ()' peut être utilisée.
<?php
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
ksort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
Considérons maintenant la sortie . 
Le tableau est maintenant trié en fonction de la valeur de la clé.Si vous souhaitez trier le tableau en ordre décroissant en fonction de la valeur de la clé, la méthode 'krsort ()' peut être utilisée.
<?php
$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
krsort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
Maintenant, le tableau associatif est trié par ordre décroissant en fonction de la valeur de la clé.Regardez en sortie . 
Voici quelques méthodes pour trier un tableau en ordre croissant ou décroissant dans php. J'espère que vous pourrez vous faire une idée. Merci!