Tri des chaînes PHP. Trier un tableau en php

Dernière mise à jour: 1.11.2015

fonction is_array

La fonction is_array() vérifie si une variable est un tableau, et si c'est le cas, elle renvoie vrai, sinon elle renvoie faux. Par exemple:

$isar = is_array($technics); echo ($isar==true)?" ceci est un tableau " ceci n'est pas un tableau " ;

nombre/taille des fonctions

Les fonctions count() et sizeof() obtiennent le nombre d'éléments dans un tableau :

$nombre = nombre($techniques); // identique à // $number = sizeof($technics); echo "Dans le tableau technique, il y a $nombre d'éléments";

fonctions de lecture aléatoire

La fonction shuffle mélange les éléments du tableau de manière aléatoire :

$os = array("Windows 95", "Windows XP", "Windows Vista", "Windows 7", "Windows 8", "Windows 10"); mélanger($os); print_r($os); // un des options possibles// Tableau ( => Windows 95 => Windows 7 => Windows Vista => Windows XP => Windows 10 => Windows 8)

Fonctions compactes

La fonction compacte vous permet de créer un tableau associatif à partir d'un ensemble de variables, où les noms de variables eux-mêmes sont les clés :

Apple II => Apple => 1978) ?>

La fonction compacte reçoit un ensemble de variables entre parenthèses. Chaque variable est spécifiée entre guillemets sans le signe $. Le résultat de la fonction est un nouveau tableau.

Tri des tableaux

Il existe deux types de tri en PHP : le tri des chaînes par ordre alphabétique et le tri des nombres par ordre croissant/décroissant. Si les valeurs triées représentent des chaînes, elles sont alors triées par ordre alphabétique, s'il s'agit de nombres, elles sont alors triées par ordre croissant de nombres. PHP choisit son propre type de tri par défaut.

Pour trier par ordre croissant, utilisez la fonction asort :

"Lenovo IdeaTab A3500", "samsung" => "Samsung Galaxy Tab 4", "apple" => "Apple iPad Air"); assorti($comprimés); écho "

    " ; foreach ($comprimés comme $key => $value) (​echo »
  • $clé : $valeur
    • "; ) écho "
"; ?>

Dans ce cas, les valeurs du tableau représentent des chaînes, donc PHP choisira de trier par ordre alphabétique. Cependant, en utilisant un paramètre supplémentaire, nous pouvons indiquer explicitement à l'interpréteur PHP quel type de classement utiliser. Ce paramètre peut prendre trois valeurs :

    SORT_REGULAR : sélection automatique tri

    SORT_NUMERIC : tri numérique

    SORT_STRING : trier par ordre alphabétique

Indiquons explicitement le type de tri :

Tri ($comprimés, SORT_STRING);

Pour trier un tableau dans l'ordre inverse, utilisez la fonction arsort :

Arsort($comprimés);

Tri par clés

La fonction asort trie par valeurs d'éléments, mais il existe également un tri par clés. Il est représenté par la fonction ksort :

Ksort($comprimés, SORT_STRING);

Le tri par clés dans l'ordre inverse est effectué par la fonction krsort() :

Krsort ($ comprimés);

Tri naturel

Bien que les fonctions de tri décrites ci-dessus fassent bien leur travail, leurs capacités ne sont toujours pas suffisantes. Par exemple, trions le tableau suivant par ordre croissant :

Windows 10 => Windows 7 => Windows 8) ?>

Puisque les valeurs représentent des chaînes, PHP trie par ordre alphabétique. Cependant, ce tri ne prend pas en compte les numéros et les cas. Par conséquent, la valeur « Windows 10 » viendra au tout début, et non à la fin, comme il se doit. Et pour résoudre ce problème, PHP dispose de la fonction natsort(), qui effectue un tri naturel :

Windows 7 => Windows 8 => Windows 10) ?>

Si nous avons également besoin que le tri soit insensible à la casse, nous pouvons utiliser la fonction natcasesort().

Il est évident qu'il peut être nécessaire de trier un tableau par valeurs clés. Par exemple, si nous avons tableau données sur les livres, comme dans l'exemple ci-dessus, alors il est probable que nous voudrons trier livres par nom d'auteur. Pour ce faire en PHP, vous n'avez pas non plus besoin d'écrire beaucoup de lignes de code - vous pouvez simplement utiliser la fonction ksort() Pour tri ascendant (ordre direct) tri) ou tri ()- Pour tri décroissant (ordre inverse tri). La syntaxe de ces fonctions est encore une fois similaire à la syntaxe de la fonction trier().

$books = array("Pouchkine"=>"Ruslan et Lyudmila",

"Tolstoï" => "Guerre et Paix",

"Lermontov" => "Héros de notre temps");

// trie le tableau,

// sauvegarde des valeurs clés

print_r($livres);

Exemple 7.9. Trier un tableau par clés (HTML , SMS )

Tableau ([Lermontov] => Héros de notre temps

[Pouchkine] => Ruslan et Lyudmila

[Tolstoï] => Guerre et Paix)

Tri à l'aide d'une fonction définie par l'utilisateur

Sauf deux des moyens simples trier les valeurs du tableau(décroissant ou ascendant) PHP offre à l'utilisateur la possibilité de définir les critères de tri données. Le critère est spécifié à l'aide d'une fonction dont le nom est spécifié comme argument pour les fonctions spéciales triusort() ou uksort(). D'après les noms de ces fonctions, vous pouvez deviner que usort()sortesvaleurséléments tableau, UN uksort()–valeursclés du tableau en utilisant une fonction définie par l'utilisateur. Les deux fonctions renvoient vrai si tri réussi et faux – dans sinon. Leur syntaxe est la suivante :

usort (tableau, fonction de tri)

uksort (tableau, fonction de tri)

Bien sûr, tu ne peux pas trier un tableau en utilisant n’importe quelle fonction personnalisée. Cette fonction doit satisfaire certains critères pour permettre la comparaison des éléments tableau. Comment structurer la fonction de tri ? Premièrement, il doit avoir deux arguments. En eux, l'interprète transmettra des paires valeurséléments pour la fonction usort() ou clés du tableau pour la fonction uksort(). Deuxièmement, la fonction de tri doit renvoyer :

    un entier inférieur à zéro si le premier argument est inférieur au second ;

    un nombre égal à zéro si les deux arguments sont égaux ;

    un nombre supérieur à zéro si le premier argument est supérieur au second.

Comme pour les autres fonctions tri, pour la fonction usort() il y a un analogue qui ne change pas valeursclés, - fonction uasort().

Exemple 7.10. Disons que nous avons tableau, contenant des informations sur les œuvres littéraires telles que le titre, l'auteur et l'année de création. Nous souhaitons organiser les livres par date de création.

// le tableau ressemble à ceci :

$books = array("Héros de notre temps" =>

tableau ("Lermontov", 1840),

"Ruslan et Lyudmila" => array("Pouchkine",1820),

"Guerre et Paix" => tableau ("Tolstoï", 1863),

"Idiot" => array("Dostoïevski",1868));

/* vous pouvez bien sûr réécrire ce tableau

différemment, en faisant par exemple l'année de publication,

index, mais il est beaucoup plus pratique d'écrire le vôtre

fonction de tri */

uasort($livres,"cmp");

// trie le tableau à l'aide de la fonction cmp

foreach ($livres comme $key => $book) (

echo "$livre : \"$clé\"
";

fonction cmp($a,$b)(

// fonction qui détermine la méthode de tri

si ($a< $b) return -1;

elseif ($a==$b) renvoie 0 ;

Exemple 7.10. Tri à l'aide de fonctions personnalisées (HTML , SMS )

En conséquence nous obtenons :

Pouchkine : « Ruslan et Lyudmila »

Lermontov : "Héros de notre temps"

Tolstoï : « Guerre et Paix »

Dostoïevski : "Idiot"

Nous avons appliqué notre propre fonction trià tous les éléments tableau. Voyons ensuite comment appliquer toute autre fonction personnalisée aux éléments du tableau.

Appliquer une fonction à tous les éléments d'un tableau

Fonction array_walk (tableau, fonction [, données]) applique une fonction créée par l'utilisateur à tous les éléments tableau tableau et renvoie vrai si l'opération a réussi et faux dans le cas contraire.

Une fonction définie par l'utilisateur a généralement deux arguments, qui sont transmis alternativement signification Et clé chaque élément tableau. Mais si lors de l'appel de la fonction tableau_walk() un troisième argument est spécifié, il sera traité comme signification le troisième argument d'une fonction définie par l'utilisateur, dont la signification est déterminée par l'utilisateur. Si une fonction utilisateur nécessite plus d'arguments que ceux qui lui sont transmis, alors à chaque appel tableau_walk() un avertissement sera émis.

Si vous avez besoin de travailler avec de vrais valeurs tableau, et non avec leurs copies, vous devez transmettre l'argument à la fonction par référence. Cependant, gardez à l'esprit que vous ne pouvez pas ajouter ou supprimer des éléments tableau et prendre des mesures qui nous changent tableau, puisque dans ce cas le résultat du travail tableau_walk() est considérée comme incertaine.

$books1 = tableau(

"A.S. Pouchkine" => "Ruslan et Lyudmila",

"L.N. Tolstoï" => "Guerre et Paix",

"M.Yu. Lermontov" => "Héros de notre temps");

fonction try_walk($val,$key,$data)(

echo "$data \"$val\" a écrit $key
";

// Fonction $book1 try_walk

array_walk($books1,"try_walk","Roman");

Exemple 7.11. Appliquer une fonction à tous les éléments d'un tableau (HTML , SMS )

Le roman "Ruslan et Lyudmila" a été écrit par A.S. Pouchkine

Le roman "Guerre et Paix" a été écrit par L.N. Tolstoï

Roman "Héros de notre temps"

écrit par M.Yu. Lermontov

Notez que nous n'avons pas changé valeurs aux éléments tableau. Pour les changer, il fallait transmettre valeurs dans la variable $var de la fonction try_walk par référence.

$books1 = tableau(

"A.S. Pouchkine" => "Ruslan et Lyudmila",

"L.N. Tolstoï" => "Guerre et Paix",

"M.Yu. Lermontov" => "Héros de notre temps");

// crée la fonction souhaitée

// s'applique aux éléments du tableau

fonction try_walk(&$val,$key)(

$clé = "

$val = "Nom : \"" . $val ."\"

";

// s'applique à tous les éléments du tableau

// Fonction $book1 try_walk

array_walk($books1,"try_walk");

print_r($livres1);

Exemple 7.12. Appliquer une fonction à tous les éléments d'un tableau. Option 2 (HTML , SMS )

À la suite du script, nous obtenons :

Titre : "Ruslan et Lyudmila"

Titre : "Guerre et Paix"

Titre : « Héros de notre temps »

Tableau ([A.S. Pouchkine] =>

Titre : "Ruslan et Lyudmila"

[L.N. Tolstoï] =>

Titre : "Guerre et Paix"

[M.Yu. Lermontov] =>

Titre : "Héros de notre temps")

Sélection de sous-tableau

fonction array_slice

Parce que le tableau- Ce ensemble d'éléments, il est probable que vous deviez en sélectionner un sous-ensemble. PHP a une fonction à cet effet tableau_slice. Sa syntaxe est :

array_slice(tableau,

numéro_élément [, longueur])

Cette fonction alloue un sous-tableau longueurlongueur tableau un tableau commençant à partir de l'élément dont le numéro est spécifié par le paramètre element_number. Le numéro_élément positif indique le numéro ordinal de l'élément par rapport au début tableau, négatif – au numéro d'élément à partir de la fin tableau.

$arr = tableau(1,2,3,4,5);

$sub_arr = array_slice($arr,2);

print_r($sub_arr);

affichera Array ( => 3 =>4 => 5),

ceux. sous-tableau composé d'éléments

$sub_arr = array_slice($arr,-2);

print_r($sub_arr);

// affichera Array ( => 4 => 5),

// c'est à dire. sous-tableau d'éléments 4, 5

Exemple 7.13. Utilisation de la fonction array_slice() (HTML , SMS )

Si vous définissez le paramètre de longueur lors de l'utilisation tableau_slice, alors ce sera sous-tableau alloué, ayant exactement autant d'éléments que spécifié par ce paramètre. La longueur peut également être négative. Dans ce cas, l'interprète supprimera dès la fin tableau le nombre d'éléments égal au module du paramètre de longueur.

$arr = tableau(1,2,3,4,5);

$sub_arr = array_slice($arr, 2, 2);

// contient un tableau d'éléments 3, 4

$sub = array_slice($arr,-3, 2);

// contient également un tableau d'éléments 3, 4

$sub1 = array_slice($arr,0, -1);

// contient un tableau de

// éléments 1, 2, 3, 4

$sub2 = array_slice($arr,-4, -2);

// contient un tableau d'éléments 2, 3

Exemple 7.14. Utilisation de la fonction array_slice(). Option 2 (HTML , SMS )

fonction array_chunk

Il existe une autre fonction similaire à tableau_slice()- Ce tableau_chunk(). Elle brise tableau en plusieurs sous-réseaux d'une longueur donnée. Sa syntaxe est :

array_chunk(tableau, taille

[, save_keys])

À la suite du travail tableau_chunk() renvoie multidimensionnel tableau, dont les éléments représentent les sous-tableaux résultants. Si vous définissez l'option de sauvegarde clés si c'est vrai, alors ils seront enregistrés lors du fractionnement clés original tableau. Sinon clés les éléments sont remplacés par des indices numériques qui partent de zéro.

Exemple 7.15. Nous avons une liste d'invités, formatée comme tableau leurs noms de famille. Nous avons des tables pour trois personnes. Par conséquent, vous devez répartir tous les invités en groupes de trois.

$personnes = array("Ivanov", "Petrov",

"Sidorova", "Zaitseva", "Volkova");

$triples = array_chunk($persons,3);

// divise le tableau en sous-tableaux

// trois éléments chacun

foreach ($triple comme $k => $table)(

// affiche les triplets résultants

echo "À la table numéro $k, asseyez-vous :

    ";

    foreach ($table en $pers)

    écho "

  • $pers";

    écho "

";

Exemple 7.15. Usageles fonctionsarray_chunk() (HTML , SMS )

En conséquence nous obtenons :

à la table numéro 0, asseyez-vous :

Sidorova

à la table numéro 1, asseyez-vous :

Zaïtseva

Volkova

Somme des éléments du tableau

Dans cette section, nous présenterons la fonction qui calcule somme de tous les éléments du tableau. La tâche de calcul elle-même somme des valeurs du tableau extrêmement simple. Mais pourquoi écrire encore et encore le même code si vous pouvez utiliser une fonction spécialement créée et toujours disponible. Cette fonction s'appelle, comme vous pouvez le deviner, tableau_somme(). Et seul le nom lui est passé en paramètre tableau,somme des valeurs des éléments qu'il faut calculer.

A titre d'exemple d'utilisation de cette fonction, nous donnerons une solution à un problème plus complexe que le simple calcul somme d'éléments. Cet exemple illustre également l'utilisation de la fonction tableau_slice(), dont nous avons parlé un peu plus tôt.

Exemple 7.16. Qu'il soit donné tableau nombres naturels. Vous devez y trouver un numéro tel que somme d'élémentsà sa droite est égal somme d'élémentsà sa gauche.

//le tableau est spécifié par la fonction tableau

$arr = tableau(2,1,3,4,5,6,4);

// parcourt chaque élément du tableau $arr.

// À l'intérieur de la boucle, la clé actuelle du tableau

// contenu dans la variable $k,

// la valeur actuelle est dans la variable $v

foreach ($arr comme $k => $val)(

// tableau de syntaxe array_slice (

tableau tableau, décalage int [, longueur int])

// array_slice alloue un sous-tableau

// longueur longueur dans le tableau,

// en commençant par l'élément offset.

$out_next = array_slice($arr,$p);

// vient après l'actuel

$out_prev = array_slice($arr,0,$k);

// obtenir tableau d'éléments,

// venant avant l'actuel

// fonction mixte array_sum (tableau tableau)

// calcule la somme des éléments du tableau

$next_sum = array_sum($out_next);

$prev_sum = array_sum($out_prev);

// si la somme des éléments avant celui en cours est égale

// somme des éléments après, puis sortie

// valeur de l'élément courant

si ($next_sum==$prev_sum)

echo "valeur :$val" ;

// tu peux voir ce que c'est

// considère les tableaux à chaque étape

// print_r($out_next); écho "
";

// print_r($out_prev);

// echo "$somme_suivante, $somme_prev
";

écho "

";

Exemple 7.16. Un programme pour trouver un nombre tel que la somme des éléments à sa droite soit égale à la somme des éléments à sa gauche ( HTML , SMS )

Conclusion

Alors, résumons. Dans cette conférence, nous avons exploré un certain nombre de fonctions qui permettent de travailler avec tableaux données. Nous avons passé en revue les fonctions de rechercher une valeur parmi les éléments du tableau; fonctions pour trier les éléments du tableau selon eux valeurs, et par clés; fonctions qui permettent s'applique à tous les éléments fonction de tableau créé par l'utilisateur. De plus, nous avons étudié la fonction sélection de sous-tableauxà partir d'éléments tableau, et une fonction qui calcule somme de tous les éléments du tableau. L'utilisation de toutes ces fonctions a été démontrée à travers des exemples. Toutes les fonctions pour travailler avec tableaux sont disponibles sans aucun paramètre de configuration PHP et vous pouvez les utiliser en toute liberté. Alors, avant de réinventer la roue, jetez un œil au manuel Langage PHP: – il est fort possible que quelqu’un ait fait ça avant vous.

En raison de leur puissance et de leur flexibilité, les tableaux sont devenus un attribut indispensable de PHP. De plus, dans un certain nombre de situations complexes, il est possible d'utiliser des Tableaux PHP. Cet article concerne le tri des tableaux multidimensionnels en PHP.

Composants:

  • Tableau multidimensionnel ;
  • Fonctions PHP intégrées usort(), uasort() ou uksort();
  • Fonctions intégrées PHP strcasecmp() ou strcmp() .

Mise en œuvre:
Disons que nous avons un tableau :

$étudiants = tableau (1 => tableau ("nom" => "Jack", "note" => 98,5), 2 => tableau ("nom" => "Bill", "note" => 90,1), 3 => tableau ("nom" => "Chloé", "grade" => 94,0), 4 => tableau ("nom" => "Taylor", "grade" => 95,1), 5 => tableau ("nom" " => "Larry", "note" => 94,6));

Ici, vous pouvez trier un tableau PHP bidimensionnel par le paramètre de note ( grade) (tri numérique) ou le nom ( Nom) (trier ordre alphabétique ).

Le tableau externe $students se compose de cinq éléments, chacun étant également représenté sous forme de tableau distinct. Le tableau interne utilise l'identifiant de l'étudiant comme clé et stocke deux valeurs : le nom de l'étudiant et sa note.

Pour trier un tableau multidimensionnel, nous définissons notre propre fonction. Nous disons à PHP qu'il doit être utilisé pour appeler les fonctions intégrées usort(), uasort() ou uksort().

La fonction que vous définissez doit prendre deux paramètres et renvoyer une valeur indiquant quel paramètre vient en premier dans la liste. Une valeur négative ou fausse indique que le premier paramètre est spécifié avant le second. Positif ou vrai - que le deuxième paramètre vient en premier. Valeur nulle(0) indique que les deux paramètres sont égaux.

A – Tri par note (paramètre note) (tri numérique)

Définissons une fonction de tri du tableau par note (paramètre grade):

// Fonction de tri par note : tri par ordre DESCENDANT. fonction grade_sort($x, $y) ( if ($x[" grade "]< $y[" оценка "]) { return true; } else if ($x["оценка"] >$y["score"]) ( return false; ) else ( return 0; ) )

Ensuite, nous prendrons une fonction personnalisée et parcourrons un tableau PHP bidimensionnel basé sur la première clé. Cela ressemble à ceci :

// $students est notre tableau multidimensionnel et grade_sort est la fonction usort créée ($students, " grade_sort ");

Exemple:

// Affiche un tableau sous la forme (tableau initial) : echo "

Tableau sous la forme

" . print_r($étudiants, 1) . "
"; // Trier par note : uasort($students, "grade_sort"); echo "

Tableau trié par note

" . print_r($étudiants, 1) . "
";

PHP enverra des tableaux internes à cette fonction pour un tri ultérieur. Si vous souhaitez savoir comment tout cela se produit en détail, affichez les résultats de la comparaison des valeurs à l'intérieur de la fonction. Et après que PHP ait créé un tableau à deux dimensions, modifiez la fonction elle-même comme suit :

fonction grade_sort($x, $y) ( static $count = 1; echo "

Itération $count : ($x['score']) vs. ($y['score'])

n"; $compte++; si ($x[‘ score ‘]< $y[‘ оценка ‘]) { return true; } else if ($x[‘ключ1′] >$y['key1′]) ( return false; ) else ( return 0; ) )

En affichant les valeurs de $x['score'] et $y['score'] , vous pouvez voir comment la fonction de tri définie par l'utilisateur est appelée.

Vous pouvez raccourcir la fonction grade_sort comme ceci :

// Fonction de tri numérique par note : tri en fonction DESCENDANTE grade_sort($x, $y) ( return ($x["grade"]< $y["grade"]); }

résultats trier un tableau à deux dimensions PHP selon l'évaluation, sont présentés dans l'image ci-dessous :

Remarque : La fonction usort() trie par valeurs mais ne stocke pas les clés ( pour tableau externe). Si des clés sont nécessaires, il est préférable d'utiliser la fonction uasort().

B – Trier par nom (alphabétique)

Pour trier le tableau $students par la première clé, vous devez comparer deux chaînes. Par conséquent, dans l’exemple avec tri par ordre alphabétique, nous utiliserons la fonction strcasecmp() ( Pas sensible à la casse) et strcmp() ( sensible aux majuscules et minuscules). La résultante tableau bidimensionnel PHP ressemblera à ceci :

// Fonction pour trier par nom : function name_sort($x, $y) ( return strcasecmp($x["name"], $y["name"]); )

Exemple:

// Affiche un tableau comme (tableau initial) : echo "

Tableau sous la forme

" . print_r($étudiants, 1) . "
"; // Trier par nom : uasort($students, "name_sort"); echo "

Tableau trié par nom

" . print_r($étudiants, 1) . "
";

La capture d'écran ci-dessous montre le résultat du tri par nom :


Traduction de l'article " Tri d'un tableau multidimensionnel en PHP"a été préparé par l'équipe sympathique du projet.

tableau_inverse

Disposer les éléments du tableau dans l'ordre inverse.
Syntaxe:

Tableau array_reverse(array arr [, bool préservation_keys])

La fonction array_reverse() renvoie un tableau dont les éléments sont dans l'ordre inverse du tableau passé en paramètre. Dans ce cas, les connexions entre clés et valeurs ne sont pas perdues si paramètre supplémentaire préserver_keys = VRAI.

Un exemple d'utilisation de la fonction array_reverse() :

$result = array_reverse($input);
$result_keyed = array_reverse($input, true);
?>

Cet exemple créera à la fois des tableaux $result et $result_keyed avec les mêmes valeurs, mais avec des clés différentes. L'impression des tableaux $result et $result_keyed sera la suivante :

Tableau(
=> Tableau
=> vert
=>rouge
)

=> 4
=> php
Tableau(
=> Tableau
=> vert
=>rouge
)

=> 4
=> php
)

Remarque : Un deuxième paramètre Preserve_keys a été ajouté dans PHP 4.0.3.

Natcasesort

Effectue un tri naturel d'un tableau, insensible à la casse.
Syntaxe:

Vider natcasesort (tableau arr)

La fonction natcasesort() trie le tableau arr dans un ordre naturel pour les humains, en préservant les associations d'index.
Cette fonction est similaire à natsort(), mais n'est pas sensible à la casse.
Exemple d'utilisation de la fonction natcasesort() :

"img2.png", "img1.png", "IMG3.png");

trier($tableau1);

print_r($tableau1);

natcasesort($array2);
echo "nTri naturel (insensible à la casse)n";
print_r ($ tableau2);
?>

L'exemple donné affichera ce qui suit :

Tableau de tri standard (
=> IMG0.png
=> IMG3.png
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)

Tri naturel (insensible à la casse)
Tableau(
=> IMG0.png
=> img1.png
=> img2.png
=> IMG3.png
=> img10.png
=> img12.png
)

Fonction supportée par PHP 4, PHP 5

Tri personnalisé d'un tableau associatif tout en préservant les associations d'index.
Syntaxe:

Bool uasort(array arr, fonction cmp_function)

La fonction uasort() trie le tableau arr en préservant les associations d'index, en utilisant la fonction définie par l'utilisateur spécifiée par cmp_function pour comparer les indices des éléments.
Cette fonction est utilisée principalement lorsque la correspondance entre les index et les valeurs du tableau est significative.
La fonction uasort() renvoie true si le tri réussit et false sinon.
Remarque : consultez les fonctions usort() et uksort() pour écrire une fonction personnalisée.
Fonction supportée par PHP 3 >=3.0.4, PHP 4, PHP 5

Tri de tableaux personnalisés par clés.
Syntaxe:

Bool uksort(array arr, fonction cmp_function)

La fonction uksort() trie le tableau arr par indices, en préservant les associations d'index, en utilisant la fonction définie par l'utilisateur spécifiée dans l'argument cmp_function pour comparer les indices des éléments. Cette fonction reçoit deux index des éléments à comparer et doit renvoyer un nombre positif ou négatif ou 0.

La fonction uksort() renvoie true si le tri se termine avec succès, et FALSE sinon.
Très souvent, nous devons trier quelque chose selon des critères plus complexes que simplement par ordre alphabétique. Par exemple, laissez $Files stocker une liste de noms de fichiers et de sous-répertoires dans le répertoire actuel. Nous souhaiterions peut-être afficher cette liste non seulement dans l'ordre lexographique, mais également que tous les répertoires soient précédés de fichiers. Dans ce cas, nous devrions utiliser la fonction uksort(), après avoir écrit au préalable une fonction de comparaison avec deux paramètres, comme l'exige uksort().

1 exemple d'utilisation de la fonction uksort() :

// Cette fonction doit comparer les valeurs de $f1 et $f2 et renvoyer :
// -1 si $f1<$f2,
// 0 si $f1==$f2
// 1 si $f1>$f2
// Sous< и >nous comprenons la séquence de ces noms dans la fonction de liste de sortie FCmp($f1,$f2)
( // Le répertoire vient toujours avant le fichier
if(is_dir($f1) && !is_dir($f2)) renvoie -1;
// Le fichier vient toujours après le répertoire
if(!is_dir($f1) && is_dir($f2)) renvoie 1 ;
// Sinon, comparez lexigraphiquement
si($f1<$f2) return -1; elseif($f1>$f2) renvoie 1 ; sinon, renvoie 0 ;
}
// Laisse $Files contenir un tableau avec des clés - noms de fichiers
// dans le répertoire courant. Trions-le.uksort($Files,"FCmp"); // passe la fonction de tri "

array_multisort()

Trier plusieurs tableaux ou tableaux multidimensionnels (PHP 4, PHP 5)

Description:

Bool array_multisort (tableau ar1 [, arg mixte [, mixte ... [, tableau ...]]])

La fonction array_multisort() peut être utilisée pour trier plusieurs tableaux ou un seul tableau multidimensionnel selon une ou plusieurs dimensions. Cette fonction maintient la correspondance entre les clés et leurs valeurs correspondantes.

Les tableaux d'entrée sont traités comme des colonnes d'une table qui doivent être triées par lignes, une approche similaire au comportement de l'expression SQL ORDER BY. Le premier tableau est prioritaire dans le processus de tri.

La structure des arguments de cette fonction est un peu inhabituelle, mais pratique. Le premier argument doit être un tableau. Les arguments suivants peuvent être des tableaux ou des valeurs qui spécifient l'ordre de tri, comme indiqué dans la liste ci-dessous.

Valeurs qui déterminent l'ordre de tri :

SORT_ASC - trier par ordre croissant
SORT_DESC - trier par ordre décroissant

Trier les indicateurs de type :

SORT_REGULAR - compare les éléments comme d'habitude
SORT_NUMERIC - compare les éléments comme s'il s'agissait de nombres
SORT_STRING - compare les éléments comme s'il s'agissait de chaînes

Il est illégal de spécifier deux indicateurs de tri du même type après chaque tableau. Les indicateurs de tri passés après l'argument ar1 s'appliquent uniquement à cet argument - avant que la fonction ne commence à traiter le tableau suivant, ces indicateurs reviennent à leurs valeurs par défaut de SORT_ASC et SORT_REGULAR.

Tri de plusieurs tableaux

$ar1 = tableau("10", 100, 100, "a");
$ar2 = tableau(1, 3, "2", 1);
array_multisort($ar1, $ar2);

Dans l'exemple ci-dessus, une fois le tri effectué, le premier tableau contiendra 10, "a", 100, 100. Le second contiendra 1, 1, "2", 3. Les éléments du deuxième tableau correspondant à des éléments identiques de le premier (100 et 100 ), sera également trié.

Tri d'un tableau multidimensionnel

$ar = array(array("10", 100, 100, "a"), array(1, 3, "2", 1));
array_multisort ($ar, SORT_ASC, SORT_STRING,
$ar, SORT_NUMERIC, SORT_DESC);

Dans l'exemple ci-dessus, après tri, le premier tableau contiendra 10, 100, 100, "a" (ses éléments ont été triés par ordre croissant comme s'il s'agissait de chaînes) et le deuxième tableau contiendra 1, 3, "2" , 1 (les éléments sont triés sous forme de nombres, par ordre décroissant).

Trier un tableau par valeurs à l'aide d'une fonction personnalisée pour comparer les éléments (PHP 3 >= 3.0.3, PHP 4, PHP 5)

Description:

Bool usort (tableau & tableau, rappel cmp_function)

Cette fonction trie les éléments d'un tableau à l'aide d'une fonction personnalisée pour comparer les valeurs. Si vous devez trier un tableau selon des critères inhabituels, vous devez utiliser cette fonction.

La fonction utilisée pour la comparaison doit renvoyer un entier inférieur, égal ou supérieur à zéro si le premier argument est respectivement inférieur, égal ou supérieur au second.

Remarque : Si deux éléments du tableau d'origine sont égaux, leur ordre dans le tableau trié n'est pas défini. Jusqu'à PHP 4.0.6 fonctions personnalisées conservé l'ordre de ces éléments dans le tableau d'origine, mais nouvel algorithme Le système de tri introduit dans la version 4.1.0 n'utilise plus cette solution et n'en possède pas d'autre efficace.

Renvoie VRAI en cas de succès ou FAUX en cas d'erreur.

Exemple Usort()

fonction cmp($a, $b)
{
si ($a == $b) (
renvoie 0 ;
}
retour ($a)

$a = tableau(3, 2, 5, 6, 1);

usort($a, "cmp");

while (list($key, $value) = each($a)) (
echo "$clé : $valeur
";
}
?>

0: 1
1: 2
2: 3
3: 5
4: 6

Commentaire: Évidemment, la fonction sort() est plus adaptée à ce cas trivial.

Un exemple de la fonction usort() utilisant des tableaux multidimensionnels

fonction cmp($a, $b)
{
return strcmp($a["fruit"], $b["fruit"]);
}

$fruits["fruit"] = "citrons";
$fruits["fruit"] = "pommes";
$fruits["fruit"] = "raisins";

usort($fruits, "cmp");

while (list($key, $value) = each($fruits)) (
echo "\$fruits[$key]: " . $value["fruit"] . "
";
}
?>

Lors du tri d'un tableau multidimensionnel, les variables $a et $b contiennent des références aux deux premiers index du tableau.

Le résultat de l'exécution de cet exemple :

$fruits : pommes
$fruits : raisins
$fruits : citrons

Exemple d'utilisation de usort() avec une méthode de classe

classe TestObj(
var $nom;

fonction TestObj($nom)
{
$this->nom = $nom;
}

/* Ceci est la fonction de comparaison statique : */
fonction cmp_obj($a, $b)
{
$al = strtolower($a->name);
$bl = strtolower($b->nom);
si ($al == $bl) (
renvoie 0 ;
}
retour ($al > $bl) ? +1 : -1 ;
}
}

$a = new TestObj("c");
$a = new TestObj("b");
$a = new TestObj("d");

usort($a, array("TestObj", "cmp_obj"));

foreach ($a comme $item) (
echo $item->name . "
";
}
?>

Le résultat de l'exécution de cet exemple :

B
c
d

Mélange des éléments du tableau.
Syntaxe:

Mélange nul (tableau arr)

La fonction shuffle() mélange la liste qui lui est transmise par le premier paramètre arr, afin que ses valeurs soient distribuées aléatoirement. Dans ce cas, le tableau lui-même change et les tableaux associatifs sont perçus comme des listes.
Un exemple d'utilisation de la fonction shuffle() :

$nombres = plage(1, 20);
srand((float)microtime() * 1000000);
mélanger($nombres);
while (list(, $number) = each($numbers)) (
echo "$numéro" ;
}

Remarque : Depuis PHP 4.2.0, il n'est plus nécessaire d'initialiser le générateur de nombres aléatoires avec les fonctions srand()
ou mt_srand(), puisque cela se produit désormais automatiquement.
Fonction supportée par PHP 3 >= 3.0.8, PHP 4, PHP 5

Triez le tableau par ordre croissant.
Syntaxe:

Tri booléen (array arr [, int sort_flags])

La fonction sort() est conçue pour trier les tableaux par ordre croissant.
Remarque : Cette fonction modifie les clés des valeurs triées. Ceux. tout tableau associatif est traité comme une liste par cette fonction. Après commande, la séquence de clés devient 0,1,2,..., et les valeurs sont redistribuées selon les besoins. Comme vous pouvez le voir, les connexions entre les paramètres key=>value ne sont pas enregistrées, de plus, les clés disparaissent tout simplement, donc trier autre chose qu'une liste n'est guère conseillé.
Exemple d'utilisation de la fonction sort() :

trier($fruits);
réinitialiser($fruits);

echo "fruits[" . $clé . "] = " . $val. "n" ;
}
?>

Cet exemple affichera :

Fruits = pommes = bananes = citrons = orange


;
SORT_NUMERIC - compare les éléments sous forme de nombres ;
SORT_STRING - compare les éléments sous forme de chaînes.

Triez le tableau par ordre décroissant.
Syntaxe:

Bool rsort (tableau tableau [, int sort_flags])

La fonction rsort() trie le tableau par ordre décroissant (du plus élevé au plus bas).

La fonction renvoie VRAI en cas de succès, FAUX sinon.
Exemple d'utilisation de la fonction rsort() :

tri($fruits);
réinitialiser($fruits);
while (list($key, $val) = each($fruits)) (
echo "$clé = $valn";
}
?>

Cet exemple affichera :

0 = orange
1 = citron
2 = banane
3 = pomme

L'argument sort_flags spécifie les indicateurs de tri suivants :
SORT_REGULAR - compare les éléments "tels quels"
Fonction supportée par PHP 3, PHP 4, PHP 5

Tri d'un tableau associatif par ordre croissant.
Syntaxe:

Bool asort(array arr [, int sort_flags])

La fonction asort() trie le tableau spécifié dans son paramètre afin que ses valeurs soient par ordre alphabétique (pour les chaînes) ou croissant (pour les nombres). Dans ce cas, les connexions entre les clés et leurs valeurs correspondantes sont conservées, c'est-à-dire Certaines paires clé=>valeur « flottent » simplement vers le haut, et d'autres, au contraire, « tombent ».

La fonction renvoie vrai en cas de succès et faux si une erreur s'est produite.
Exemple d'utilisation de la fonction asort() :

"citron", "a" => "orange", "b" => "banane", "c" => "pomme");
assortiment($fruits);
réinitialiser($fruits);
while (list($key, $val) = each($fruits)) (
echo "$clé = $valn";
}
?>

L'exemple affichera ce qui suit :

C = pommeb = banane et = citronna = orange

Le tableau $fruits a été trié par ordre symbolique croissant, tandis que les indices du tableau ont été conservés.



Fonction supportée par PHP 3, PHP 4, PHP 5

Tri d'un tableau associatif par ordre décroissant.
Syntaxe:

Bool arsort(array arr [, int sort_flags])

La fonction arsort() trie le tableau arr par ordre décroissant, en préservant les associations d'index.
Cette fonction est utilisée principalement lorsque l'ordre des éléments dans le tableau est significatif.
La fonction renvoie vrai si le tri a réussi et faux si une erreur s'est produite.
Exemple d'utilisation de la fonction arsort() :

"citron", "a"=>"orange", "b"=>"banane", "c"=>"pomme");
tri($arr);
réinitialiser($arr);
while(list ($key, $val) = each ($arr)) (
echo "$key = $vall";
}

L'exemple affichera :

A = orange = citronb = bananec = pomme

Le tableau $arr a été trié par ordre décroissant des caractères, tandis que les indices du tableau ont été conservés.
La méthode de tri peut être modifiée à l'aide du paramètre facultatif sort_flags.
Cette option peut spécifier comment les valeurs sont comparées (sous forme de chaînes ou de nombres). Il peut prendre les valeurs prédéfinies suivantes :
SORT_REGULAR - comparaison normale des valeurs ;
SORT_NUMERIC - comparer sous forme de nombres ;
SORT_STRING - comparer sous forme de chaînes.
Cette option a été introduite dans la version 4 de PHP.
Fonction supportée par PHP 3, PHP 4, PHP 5

Triez le tableau par clés ascendantes.
Syntaxe:

Bool ksort(array arr [, int sort_flags])

La fonction ksort() trie un tableau par ordre croissant de clés tout en préservant les relations clé-valeur. Cette fonction est particulièrement utile lors du tri de tableaux associatifs.
La fonction retournera vrai si tout a réussi, faux sinon.
Exemple d'utilisation de la fonction ksort() :

"citron", "a"=>"orange", "b"=>"banane", "c"=>"pomme");
ksort($fruits);
réinitialiser($fruits);
while (list($key, $val) = each($fruits)) (
echo "$clé = $valn";
}
?>

Cet exemple affichera :

A = orangeb = bananec = pomme = citron

L'argument sort_flags spécifie les indicateurs de tri suivants :
SORT_REGULAR - compare les éléments "tels quels"
SORT_NUMERIC - compare les éléments sous forme de nombres SORT_STRING - compare les éléments sous forme de chaînes
Fonction supportée par PHP 3, PHP 4, PHP 5

Triez le tableau par index décroissant.
Syntaxe:

Bool krsort(array arr [, int sort_flags])

La fonction krsort() trie les clés du tableau arr dans l'ordre inverse. Dans ce cas, la chaîne clé-valeur est préservée. Cette fonction est utile lors du tri de tableaux associatifs.
La fonction renvoie vrai en cas de succès, faux sinon.
Exemple d'utilisation de la fonction krsort() :

"citron", "a"=>"orange", "b"=>"banane", "c"=>"pomme");
krsort($fruits);
réinitialiser($fruits);
while (list($key, $val) = each($fruits)) (
echo "$clé = $valn";
}
?>

Cet exemple affichera :

D = citronc = pommeb = bananea = orange

L'argument sort_flags spécifie les indicateurs de tri suivants :
SORT_REGULAR - compare les éléments "tels quels"
SORT_NUMERIC - compare les éléments sous forme de nombres SORT_STRING - compare les éléments sous forme de chaînes
Fonction supportée par PHP 3 >= 3.0.13, PHP 4, PHP 5

Effectue une sorte de tableau "naturel".
Syntaxe:

Natsort vide (tableau arr)

La fonction natsort() trie le tableau arr dans un ordre naturel pour les humains, en préservant les associations d'index.
Un exemple d'utilisation de la fonction natsort() :

trier($tableau1);
echo "Tri standard" ;
print_r($tableau1);

natsort($tableau2);
echo "Tri naturel" ;
print_r ($ tableau2);
?>

Cet exemple produira ce qui suit :

Tableau de tri standard (
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)

Tableau de tri naturel (
=> img1.png
=> img2.png
=> img10.png
=> img12.png
)

Fonction supportée par PHP 4, PHP 5

ARTICLES LIÉS