Un tableau est une collection d’objets de même taille et de même type. Chaque objet du tableau est appelé élément du tableau. Créer un nouveau tableau en PHP est simple. Lors de la déclaration d'un tableau indexé, une paire de crochets () est placée après le nom de la variable :

$langues ​​= "Espagnol" ;

// $langues ​​= "Espagnol"

Vous pouvez ensuite ajouter de nouveaux éléments au tableau, comme indiqué ci-dessous. Veuillez noter que de nouveaux éléments sont ajoutés sans spécifier explicitement d'index. Dans ce cas, le nouvel élément est ajouté à une position égale à la longueur du tableau plus 1 :

$langues ​​= "Anglais" ; // $1langues[l] = "Anglais";

$languest ] = "Gaélique"; // $langues ​​= "Gaélique";

De plus, de nouveaux éléments peuvent être ajoutés à une position spécifique du tableau. Pour cela, précisez l'index du premier élément :

$langues ​​= "Italien" ;

$langues = « Français » ;

Les tableaux associatifs sont créés de la même manière :

$langues["Espagne"] = "Espagnol";

$langues["France"] = "Français";

Lors de la création de tableaux, trois constructions de langage standard sont utilisées :

• tableau();
• liste();
• gamme().

Bien que les trois cas aboutissent au même résultat, à savoir la création d’un réseau, dans certains cas, une conception peut être préférable aux autres. Vous trouverez ci-dessous des descriptions et des exemples d’utilisation de chaque conception.

La fonction array() obtient zéro ou plus éléments et renvoie un tableau composé des éléments spécifiés. Sa syntaxe est :

tableau tableau ([élément1, élément2...])

Array() est probablement juste un raccourci plus visuel pour créer un tableau, utilisé pour la commodité du programmeur. Vous trouverez ci-dessous un exemple d'utilisation de array() pour créer un tableau indexable :

$langues ​​= array("Anglais". "Gaélique". "Espagnol");

// $langues ​​= "Anglais". $langues = "Gaélique",

// $langues ​​= "Espagnol"

Voici comment array() est utilisé pour créer des tableaux associatifs :

$langues ​​= array("Espagne" => "Espagnol",

"Irlande" => "Gaélique".

"États-Unis" => "Anglais");

// $langues["Espagne"] = "Espagnol"

// $langues["Irlande"] = "Gaélique"

// $langues["États-Unis"] = "Anglais"

Les tableaux associatifs sont particulièrement utiles dans les situations où les index numériques n'ont pas de correspondance logique. Par exemple, dans l’exemple précédent, les noms de pays sont tout naturellement associés aux langues. Essayez d'implémenter cette connexion logique en utilisant des chiffres !

La construction list() est similaire à array(), mais son objectif principal est d'attribuer simultanément des valeurs extraites d'un tableau à plusieurs variables à la fois. Syntaxe de la commande List() :

liste vide (variable1 [. variable2, ...])

La construction list() est particulièrement utile lors de la lecture d’informations à partir d’une base de données ou d’un fichier. Supposons que vous souhaitiez formater et afficher des données lues à partir d'un fichier texte. Chaque ligne du fichier contient des informations sur l'utilisateur (nom,

profession et couleur préférée); Les composants d'un enregistrement sont séparés par une barre verticale (|). Une ligne typique ressemble à ceci :

Nino Sanzi|Golfeur professionnel|vert

En utilisant list(), vous pouvez écrire une boucle simple qui lira chaque ligne, attribuera ses composants à des variables, formatera et affichera les données. La liste ci-dessous démontre la possibilité d'attribuer simultanément plusieurs variables à l'aide de list() :

while ($line = fgets ($user_file. 4096)) :

// Divisez la chaîne en utilisant split().

// Les composants sont affectés aux variables Sname. $occupation et Scolor.

list ($nom, $occupation, $color) = split("|", $line);

// Formatage et sortie des données

imprimer "Nom : Sname
";

imprimer "Occupation : Soccupation
";

imprimer "Couleur préférée: Scolor
";

Chaque ligne du fichier est lue, formatée et affichée comme suit :

Nom : Nino Sanzi

Profession : Golfeur professionnel

Couleur préférée : vert

Dans l'exemple ci-dessus, l'utilisation de list() dépend du fractionnement de la chaîne en éléments à l'aide de la fonction split(). Les éléments résultant de la division sont respectivement affectés aux variables $name, $occupation et $color. Ensuite, tout se résume au formatage des données pour les afficher dans un navigateur spécifique. Des outils pratiques pour l'analyse lexicale des fichiers texte sont l'un des points forts de PHP. Ce sujet est abordé en détail dans les chapitres 7 et 8.

La construction range() vous permet de créer rapidement et facilement un tableau d'entiers à partir d'une plage définie par une limite supérieure et inférieure. Range() renvoie un tableau composé de tous les entiers de la plage spécifiée. Syntaxe range() :

plage du tableau (int lower_bound, int upper_bound)

L’exemple suivant montre clairement à quel point cette conception est pratique :

$loterie = plage(0,9);

// $loterie = tableau(0,1,2,3,4,5,6,7,8,9)

Comme le montre le fragment ci-dessus, les paramètres range() spécifiaient un intervalle de 0 à 9 et le tableau $lottery était rempli d'entiers de cet intervalle.

Tableaux multidimensionnels

Au fil du temps, vos programmes deviendront plus complexes et de simples tableaux unidimensionnels ne suffiront pas à stocker les informations nécessaires. Tableau multidimensionnel(tableau de tableaux) fournit au programmeur plus des moyens efficaces pour stocker des informations nécessitant une structuration supplémentaire. Créer un tableau multidimensionnel est simple : il suffit d'ajouter une paire de crochets supplémentaire pour forcer le tableau à prendre une nouvelle dimension :

$échiquier = "Roi" ; // Tableau bidimensionnel

$capitals["USA"] ["Ohio"] = "Columbus": // Tableau bidimensionnel

$streets["USA"]["Ohio"]["Columbus"] = "Harrison"; // Tableau tridimensionnel

À titre d'exemple, considérons un tableau qui stocke des informations sur les desserts et les caractéristiques de leur préparation. Il serait assez difficile de s'en sortir avec un tableau unidimensionnel, mais un tableau bidimensionnel convient parfaitement :

$desserts = tableau(

"Coupe de fruits" => tableau (

"calories" => "faible",

"servi" -> "froid",

"préparation" => "10 minutes"

"Brownies" => tableau (

"calories" -> "élevé",

"servi" => "très chaud",

"préparation" => "45 minutes"

Après avoir créé un tableau, ses éléments sont accessibles à l'aide des touches correspondantes :

$desserts["Fruit Cup"]["préparation"] // renvoie "10 minutes"

$desserts["Brownies"]["calories"] // renvoie "élevé"

L'attribution de valeurs aux éléments des tableaux multidimensionnels s'effectue de la même manière que dans les tableaux unidimensionnels :

$desserts["Gâteau"]["calories"] = "trop";

// Définit la propriété "calories" de l'objet "Cake" sur "trop"

Bien que les tableaux multidimensionnels introduisent de nouveaux niveaux d’organisation logique des données, les tableaux multidimensionnels sont créés de la même manière que les tableaux unidimensionnels. Cependant, les références à des tableaux multidimensionnels dans des chaînes nécessitent une attention particulière ; La section suivante est consacrée à ce sujet.

Références aux tableaux multidimensionnels

imprimer "Les brownies sont bons, mais la teneur en calories l'est".

$desserts["Brownies"]["calories"];

imprimer "Les brownies sont bons, mais la teneur en calories est

($desserts)";

A noter l'absence de guillemets autour des touches. N'oubliez pas non plus qu'il ne doit y avoir aucun espace supplémentaire entre les accolades et le lien. Si au moins une de ces conditions n’est pas remplie, une erreur se produira. Toutefois, les deux méthodes conviennent. Je vous recommande de choisir un format et de vous y tenir pour rendre vos programmes plus cohérents. Si ne pas utiliser Avec chacune de ces méthodes de formatage, les références aux tableaux multidimensionnels seront interprétées littéralement, ce qui conduira probablement à des résultats inattendus.

Recherche d'éléments de tableau

La recherche d'éléments est l'une des opérations les plus importantes avec les tableaux. PHP dispose de plusieurs fonctions standards qui permettent de trouver facilement les clés et valeurs souhaitées dans un tableau.

La fonction i n_array() vérifie si un élément donné est présent dans le tableau. Si la recherche réussit, la fonction renvoie VRAI, sinon elle renvoie FAUX. La syntaxe de la fonction in_array() est :

bool in_array (élément mixte, tableau tableau)

Cette fonction est particulièrement pratique car vous n'avez pas besoin de parcourir l'intégralité du tableau à la recherche de l'élément souhaité. Dans l'exemple suivant, la fonction in_array() recherche l'élément "Russe" dans le tableau $langues :

$langues ​​= array("Anglais", "Gaélique", "Espagnol") :

$exists = in_array("Russe", $langues); // $exists est défini sur FALSE

$exists = in_array("English", $langues) : // $exists est défini sur TRUE

La fonction in_array() se trouve souvent dans les constructions de contrôle où sa valeur de retour (TRUE/FALSE) est utilisée pour sélectionner l'une des deux options de continuation. L'exemple suivant utilise la fonction in_array() pour sélectionner l'une des deux options dans une instruction if conditionnelle :

// Entrée utilisateur

$langue = "Français"; $email = " [email protégé]";

// Si la langue est présente dans le tableau

if (in_array($langue. $langues)) :

// Abonnez l'utilisateur à la newsletter.

// Attention : PHP n'a pas de fonction standard nommée

// abonnez_user(). DANS dans cet exemple cette fonction simule simplement

// processus d'abonnement.

Subscribe_user ($ email, $ langue);

print "Vous êtes maintenant abonné à l'édition $langue de la newsletter.";

// La langue n'est pas dans le tableau

print "Nous sommes désolés, mais nous ne proposons pas encore d'édition en langue $ de la newsletter".

Que se passe-t-il dans cet exemple ? Disons que les variables $langue et $email contiennent des entrées utilisateur. Vous voulez vous assurer que la langue spécifiée est prise en charge par votre système et utiliser la fonction in_array() à cet effet. Si le nom de la langue est présent dans le tableau, l'utilisateur s'abonne à la newsletter et reçoit un message correspondant. DANS sinon le programme signale que la newsletter n'est pas distribuée dans la langue spécifiée. Bien entendu, dans un programme réel, l'utilisateur ne devrait pas avoir à deviner quelles langues votre programme prend en charge. Le problème est résolu à l'aide d'une liste déroulante - ce sujet est abordé en détail au chapitre 10. Ici, cet exemple démontre simplement les capacités de travail avec des tableaux.

La fonction array_keys() renvoie un tableau contenant toutes les clés du tableau d'origine passées en paramètre. Si l'appel passe le paramètre search_item supplémentaire, seules les clés correspondant à la valeur donnée sont renvoyées ; sinon, toutes les clés du tableau sont renvoyées. La syntaxe de la fonction array_keys() est :

tableau array_keys (tableau tableau [, élément de recherche mixte])

Regardons un exemple d'utilisation de la fonction array_keys() pour obtenir la clé d'un élément donné :

$great_wines = array ("Australie" => "Clarendon Hills 96",

"France" => "Comte George de Vogue 97",

"Autriche" => "Feiler Artinger 97");

$great_labels = array_keys($great_wines);

// $great_labels = array("Australie", "France", "Autriche");

$great_labels = array_keys($great_wines, "Clarendon Hills 96");

// $great_labels = array("Australie");

La fonction array_keys() permet d'obtenir très facilement toutes les clés d'un tableau associatif - par exemple, dans le cas précédent il s'agissait des noms des pays dans lesquels sont produits différents types de vins.

La fonction array_values() renvoie un tableau composé de toutes les valeurs du tableau d'origine passées en paramètre. La syntaxe de la fonction array_values() est :

tableau array_values ​​(tableau tableau)

Revenons à l'exemple précédent, où la fonction array_keys() a été utilisée pour obtenir toutes les valeurs des clés. Cette fois, la fonction array_values() renvoie toutes les valeurs correspondant aux clés :

// $great_wines = array ("Australie" => "Clarendon Hills 96",

// "France" => "Comte George de Vogue 97",

// "Autriche" => "Feiler Artinger 97");

$great_labels = array_values($great_wines);

// $great_labels = array("Clarendon Hills 96",

// "Comte Georges de Vogue 97",

// "Feiler Artinger 97");

Les fonctions array_keys() et array_values() se complètent, permettant d'obtenir si nécessaire tous les composants d'un côté ou de l'autre d'un tableau associatif.

Ajout et suppression d'éléments

Heureusement, en PHP, vous n'avez pas besoin de spécifier un nombre maximum d'éléments lors de la création d'un tableau. Cela vous donne plus de flexibilité lorsque vous travaillez sur des tableaux, car vous n'avez pas à vous soucier d'un dépassement accidentel du tableau si le nombre d'éléments dépasse un seuil attendu. Il existe plusieurs fonctions en PHP pour augmenter la taille d'un tableau. Certains d'entre eux ont été créés pour la commodité des programmeurs habitués à travailler avec différents types de files d'attente et de piles (FIFO, FILO, etc.), ce qui se reflète dans les noms des fonctions (push, pop, shift et unshift). Mais même si vous ne savez pas ce qu'est une « file d'attente » ou une « pile », ne vous inquiétez pas : ces fonctions n'ont rien de compliqué.

Une file d'attente est une structure de données à partir de laquelle les éléments sont récupérés dans l'ordre dans lequel ils sont reçus. Une pile est une structure de données à partir de laquelle les éléments sont récupérés dans l'ordre inverse de leur arrivée.

La fonction array_push() ajoute (c'est-à-dire ajoute à la fin du tableau) un ou plusieurs nouveaux éléments. La syntaxe de la fonction array_push() est :

int array_push (tableau, élément mixte [, ...])

La longueur d'un tableau augmente proportionnellement au nombre de ses éléments. Ceci est démontré dans l’exemple suivant :

$langues ​​= array("Espagnol", "Anglais", "Français");

array_push($langues, "Russe", "Allemand", "Gaélique");

// $langues = array("Espagnol", "Anglais", "Français",

// "Russe", "Allemand", "Gaélique")

La fonction array_push(), comme de nombreuses fonctions PHP standard, possède un « double » : la fonction array_push(), conçue pour récupérer des éléments d'un tableau. La principale différence entre ces fonctions est que array_push() peut ajouter plusieurs éléments à la fois, tandis que array_push() ne supprime que les éléments un par un.

tableau_pop()

Le résultat de la fonction array_push() est exactement le contraire de array_push() - cette fonction récupère (c'est-à-dire supprime) le dernier élément du tableau. L'élément extrait est renvoyé par la fonction. Syntaxe de la fonction app_op() :

array_pop (tableau tableau)

Chaque fois que appray_pop() est exécuté, la taille du tableau est réduite de 1. Regardons un exemple :

$langues ​​= array("Espagnol", "Anglais", "Français",

"Russe", "Allemand", "Gaélique");

$a_langue = array_pop($langues) : // $a_langue = "Gaélique"

$a_langue = array_pop($langues) : // $a_langue = "Allemand"

// $langues = tableau ("Espagnol", "Anglais", "Français", "Russe");

Les fonctions array_push() et array_pop() sont utiles car elles vous permettent d'effectuer des opérations sur des éléments et de contrôler la taille d'un tableau sans vous soucier des éléments non initialisés ou vides. Cette solution fonctionne beaucoup plus efficacement que toute tentative de contrôle de ces facteurs par le programmeur.

La fonction array_shift() est similaire à array_shift() avec une différence : l'élément est supprimé du début (bord gauche) du tableau. Tous les autres éléments du tableau sont décalés d'une position vers le début du tableau. La fonction array_shift() a la même syntaxe que array_shift() :

array_shift (tableau tableau)

Lorsque vous travaillez avec la fonction array_shift(), vous devez vous rappeler que les éléments sont supprimés depuis le début du tableau, comme le montre l'exemple suivant :

$langues ​​= array("Espagnol", "Anglais", "Français", "Russe");

$a_langue = array_shift($langues); // $a_langue = "Espagnol" ;

// $langues = array("Anglais", "Français", "Russe");

La fonction array_unshift() complète array_shift() en insérant un nouvel élément au début du tableau et en décalant les éléments restants d'une position vers la droite. La syntaxe de la commande array_unshift() est :

1nt array_unshift (tableau de tableau, variable mixte1 [....variable2])

Avec un seul appel de fonction, vous pouvez ajouter un ou plusieurs éléments, et la taille du tableau augmente proportionnellement au nombre d'éléments ajoutés. Exemple d'ajout de plusieurs éléments :

$ langues = array("Français", "Italien", "Espagnol");

array_unshift($langues, "Russe", "Swahili", "Chinois");

// $langues ​​= array("Russe", "Swahili", "Chinois",

// "Français", "Italien", "Espagnol");

La fonction array_pad() vous permet d'agrandir rapidement un tableau jusqu'à la taille souhaitée en le remplissant avec des éléments standard. La syntaxe de la fonction array_pad() est :

array arrap_pad (tableau tableau, taille int, valeur mixte) :

Paramètre taille définit la nouvelle longueur du tableau. Paramètre signification spécifie la valeur par défaut attribuée aux éléments à toutes les nouvelles positions dans le tableau. Il y a certaines choses à considérer lors de l'utilisation de array_pad() :

Si taille est positif, le tableau est complété à droite, et s'il est négatif, le tableau est complété à gauche.

Si la valeur absolue du paramètre taille est inférieure ou égale à la longueur du tableau, aucune action n'est effectuée.

La valeur absolue (module) d'un entier est sa valeur non signée. Par exemple, la valeur absolue des nombres 5 et -5 est 5.

Exemple d'ajout d'un tableau à partir de la fin :

$weights = array_pad($weights. 10, 100);

// Résultat : $weights = array(1, 3, 5, 10, 15, 25, 50, 100, 100, 100);

Exemple d'ajout d'un tableau depuis le début :

$poids = tableau(1, 3, 5, 10, 15, 25, 50);

$weights = array_pad($weights, -10, 100);

// Résultat : $weights = array(100, 100, 100, 1, 3, 5, 10, 15, 25, 50);

Tentative incorrecte d'ajout d'un tableau :

$poids = tableau(1, 3, 5, 10, 15, 25, 50);

$weights = array_pad($weigtits, 3, 100);

// Le tableau $weights ne change pas :

// $poids = tableau(1, 3, 5, 10, 15, 25, 50);

Itérer sur les éléments

PHP dispose de plusieurs fonctions standard conçues pour parcourir les éléments du tableau. Ensemble, ces fonctions constituent un moyen flexible et pratique pour traiter et afficher rapidement le contenu des tableaux. Vous utiliserez probablement beaucoup ces fonctions, car elles constituent la base de presque tous les algorithmes de tableaux.

La fonction reset() déplace le pointeur interne vers la position actuelle dans le tableau jusqu'au premier élément. De plus, il renvoie la valeur du premier élément. Syntaxe de la fonction Reset() :

réinitialisation mixte (array array)

Considérez le tableau suivant :

$fruits = array("pomme", "orange", "banane");

Disons que le pointeur de position actuelle dans ce tableau est défini sur l'élément "orange". Équipe:

$a_fruit = réinitialiser ($fruits);

renverra un pointeur vers le début du tableau, c'est-à-dire l'élément "apple", et renverra cette valeur si le résultat de l'appel reset() est utilisé dans le programme. Une version simplifiée de l'appel est également possible :

Dans ce cas, le pointeur se déplace sur le premier élément du tableau et la valeur de retour n'est pas utilisée.

La fonction each() fait deux choses à chaque fois qu'elle est appelée : elle renvoie la paire clé/valeur référencée par le pointeur de position actuelle et elle déplace le pointeur vers l'élément suivant. Syntaxe de la fonction Each() :

tableau chacun (tableau tableau)

Pour plus de commodité, each() renvoie la clé et la valeur sous la forme d'un tableau de quatre éléments ; les clés de ce tableau sont 0, 1, valeur et clé. La clé renvoyée est associée aux clés 0 et key, et la valeur renvoyée est associée aux clés 1 et value.

Dans l'exemple suivant, la fonction each() renvoie l'élément à la position actuelle :

// Déclare un tableau de cinq éléments

$épices = array("persil", "sauge", "romarin", "thym", "poivre");

// Place le pointeur sur le premier élément du tableau

// Crée un tableau $a_sp1ce. quatre pièces

$a_spice = chacun ($épices);

Suite à l'exécution du fragment ci-dessus, le tableau $a_spice contiendra les paires clé/valeur suivantes :

• 0 => 0;
• 1 => "persil" ;
• clé => 0 ;
• valeur => "persil".

Après cela, la chaîne « persil » peut être générée par l'une des commandes suivantes :

print $a_spice : print $a_spice["value"];

La fonction each() est généralement utilisée en combinaison avec list() dans les constructions en boucle pour parcourir tout ou partie des éléments d'un tableau. À chaque itération, each() renvoie soit la paire clé/valeur suivante, soit un booléen false lorsque le dernier élément du tableau est atteint. Revenons au tableau $spices ; Pour afficher tous les éléments à l'écran, vous pouvez utiliser le script suivant :

// Réinitialise le pointeur de position actuelle

// Énumérer les paires clé/valeur, en limitant la sortie à la valeur

while (list ($key, $val) = each ($spices)) :

imprimer "$val
"

Vous trouverez ci-dessous un exemple plus intéressant d'utilisation de each() en combinaison avec les autres fonctions décrites dans ce chapitre. Le listing 5.1 montre comment utiliser ces fonctions pour afficher un tableau formaté des pays et des langues.

Inscription 5.1. Construire un tableau HTML à partir du contenu d'un tableau

// Déclare un tableau associatif de pays et de langues $langues = tableau ("Pays" => "Langue",

"Espagne" => "Espagnol",

"États-Unis" => "Anglais",

"France" => "Français",

"Russie" => "Russe");

// Commence une nouvelle table

imprimer "

";

// Déplace le pointeur vers la position du premier élément

$hdl = clé ($ langues);

Shd2 = $langues[$hd1];

// Afficher la première clé et l'élément sous forme d'en-têtes de tableau

imprimer "

";

suivant($langues);

// Imprimer les lignes du tableau avec les clés et les éléments du tableau

while (list ($ctry,$lang) = each ($langues)) :

imprimer "

";

// Fin de l'impression du tableau "

$hd1	$hd2
Paysage	$lang

";

L'exécution de ce code produira le tableau HTML suivant.

Pays	Langue
Espagne	Espagnol
Etats-Unis	Anglais
France	Français
Russie	russe

Cet exemple donne une idée de la plus grande force de PHP : sa capacité à combiner du code dynamique avec du HTML pour produire une représentation visuelle et formatée des données qu'il lit.

La fonction end() déplace le pointeur vers la position du dernier élément du tableau. Syntaxe de la fonction end() :

fin (tableau tableau)

La fonction next() déplace le pointeur d'une position vers l'avant, puis renvoie l'élément à la nouvelle position. Si à la suite d'un déplacement

le pointeur ira au-delà du tableau, next() renvoie false. Syntaxe de la fonction Next() :

mélangé ensuite (tableau)

L'inconvénient de la fonction next() est qu'elle renvoie false pour les éléments de tableau existants mais vides. Si vous souhaitez effectuer une recherche régulière, utilisez la fonction each().

La fonction prev() est similaire à next() à une exception près : elle déplace le pointeur d'une position vers le début du tableau, puis renvoie l'élément à la nouvelle position. Si le décalage place le pointeur avant le premier élément du tableau, prev() renverra false. La syntaxe de la fonction prev() est :

mélange précédent (tableau)

L'inconvénient de la fonction prev() est qu'elle renvoie false pour les éléments de tableau existants mais vides. Si vous souhaitez effectuer une recherche régulière, utilisez la fonction each().

La fonction array_walk() vous permet d'appliquer une fonction à plusieurs (ou éventuellement à tous) les éléments d'un tableau. La syntaxe de la fonction array_walk() est :

int array_walk (tableau de tableau, chaîne nom_fonction [, données mixtes])

La fonction spécifiée par function_name peut être utilisée à diverses fins, telles que rechercher des éléments présentant certaines caractéristiques ou modifier le contenu d'un tableau. Dans les tableaux associatifs, la fonction function_name doit recevoir au moins deux paramètres : un élément de tableau et une clé. Si les données du troisième paramètre facultatif sont spécifiées, elles deviennent le troisième paramètre. L'exemple suivant utilise la fonction array_walk() pour supprimer les doublons d'un tableau :

fonction delete_dupes ($ élément) (

statique $dernier="" ; si ($element == $dernier)

unset($élément); autre. ""

$e-mails = tableau(" [email protégé]", "[email protégé]", "[email protégé]");

array_walk($emails,"delete_dupes");

// $emails = tableau(" [email protégé]", "[email protégé]");

La fonction array_reverse() permet d'inverser facilement l'ordre des éléments qui composent un tableau. La syntaxe de la fonction array_reverse() est :

tableau tableau_inverse(tableau tableau)

Regardons un exemple d'utilisation de la fonction array_reverse() :

$us_wireproducers = array("Californie", "Oregon", "New York". "Washington");

$us_wine_producters - array_reverse(Sus_wine_producers);

// $us_wine_producers = array ("Washington". "New York", "Oregon". "Californie");

Lorsque vous appelez array_reverse() sur un tableau associatif, les paires clé/valeur sont conservées, seul l'ordre des éléments du tableau est modifié.

La fonction array_flip() retourne les clés et les valeurs des éléments du tableau. La syntaxe de la fonction array_flip() est :

tableau tableau_flip(tableau tableau)

Dans l'exemple suivant, la fonction array_flip() permute toutes les clés et valeurs des éléments :

$linguals ​​= array("Espagne" => "Espagnol", "France" => "Français", "Italie" => "Italien");

$langues ​​= array_flip($langues);

// $linguals ​​= array("Espagnol" => "Espagne", // "Français" => "France", // "Italien" => "Italie");

N'oubliez pas : la fonction array_flip() ne change pas ordre des éléments du tableau. La fonction array_reverse() est utilisée à cet effet.

Taille du tableau

Avoir des informations sur la taille actuelle du tableau peut souvent rendre un script plus efficace. La taille du tableau est probablement le plus souvent utilisée lors d’une itération sur des éléments :

$us_wine_producers = array("Washington". "New York", "Oregon", "Californie");

pour (Si = 0; Si< sizeof ($us_wine_producers); $i++) :

imprimer "$us_wine_producers[$i]";

Puisque le tableau $us_wine_producers est indexé par des entiers, nous pouvons utiliser une boucle for pour parcourir la variable compteur ($i) et imprimer chaque élément du tableau.

La fonction sizeof() renvoie le nombre d'éléments dans un tableau. La syntaxe de la fonction sizeof() est :

int taille de (tableau tableau)

Vous verrez probablement souvent la fonction sizeof() dans vos applications Web. Vous trouverez ci-dessous un bref exemple de son utilisation (d'ailleurs, l'exemple précédent est également une utilisation standard de sizeof()) :

$pasta = array("bowties", "angelhair", "rigatoni");

$pasta_size = taille de ($pasta);

// $pasta_size = 3

La fonction sizeof() a également une autre forme étendue, count() (voir ci-dessous).

La fonction count() effectue la même opération que sizeof() ; elle renvoie le nombre de valeurs contenues dans un tableau. La syntaxe de la fonction count() est :

nombre int (variable mixte)

La seule différence entre sizeof() et count() est que dans certaines situations, count() renvoie des informations supplémentaires :

• si la variable existe et est un tableau, count() renvoie le nombre d'éléments dans le tableau ;
• si la variable existe mais n'est pas un tableau, la fonction renvoie 1 ;
• si la variable n'existe pas, la valeur 0 est renvoyée.

array_count_values()

La fonction array_count_values() est une variante de sizeof() et count(). Au lieu du nombre total d’éléments, il compte le nombre d’instances de chaque valeur du tableau. La syntaxe de la fonction array_count_values() est :

tableau array_count_values(tableau tableau) :

Dans le tableau renvoyé, les clés seront les valeurs du tableau d'origine, et les valeurs seront leurs fréquences :

$states = array("ON", "OK", "SA", "RA", "ON", "ON", "RA", "AK");

$state_freq = array_count_values($states);

Le tableau $state_freq est rempli avec les paires clé/valeur associatives suivantes :

$state_freq = аrrау("ON" => 3, "OK" => 1, "SA" => 1, "RA" => 2, "AK" => 1);

Tri des tableaux

Le tri occupe une place importante en programmation et se retrouve souvent en pratique dans des applications Internet telles que les sites commerciaux (tri des catégories de produits par ordre alphabétique, tri des prix) ou les moteurs de recherche (tri des programmes par nombre de téléchargements). Il existe neuf fonctions de tri standard en PHP (Tableau 5.1), et chaque fonction trie un tableau d'une manière spécifique.

Tableau 5.1. Fonctions de tri

	Tri	Ordre inverse	Stockage des paires clé/valeur
	Signification
	Signification
	Signification
	Signification
	Signification
	Signification

Fait référence à l'utilisation de fonctions de tri personnalisées où l'ordre de tri d'un tableau dépend des résultats renvoyés par la fonction personnalisée.

Le tri des éléments du tableau ne se limite pas aux critères standards, puisque trois fonctions (usort(), uasort() et uksort()) vous permettent de définir des critères personnalisés et de trier les informations de n'importe quelle manière.

La fonction la plus simple sort() trie les éléments d'un tableau par ordre croissant (du plus petit au plus grand). La syntaxe de la fonction sort() est :

tri vide (tableau)

Les éléments non numériques sont triés par ordre alphabétique selon les codes ASCII. L'exemple suivant montre l'utilisation de la fonction sort() dans le tri :

// Crée un tableau de villes.

// Trier les villes par ordre croissant

// Parcourez le contenu du tableau et affichez toutes les paires clé/valeur.

pour (reset($cities); $key = clé ($cities); next ($cities)) :

print("villes[$clé] = $villes[$clé]
";

Cet extrait produit le résultat suivant :

villes = Aprilia

villes = Nettuno

villes = Venise

Comme vous pouvez le voir, le tableau $cities est trié par ordre alphabétique. Une variante de cette méthode de tri est implémentée dans la fonction asort() décrite ci-dessous.

La fonction rsort() fonctionne exactement de la même manière que la fonction sort(), à une exception près : les éléments du tableau sont triés dans l'ordre inverse. Syntaxe de la fonction rsort() :

void rsort (tableau)

Revenons au tableau $cities de l'exemple précédent :

$cities array("Aprilia", "Nettuno", "Roma", "Venezia", ​​​​​​"Anzio");

villes = Venise

villes = Nettuno

villes = Aprilia

Le tableau $cities est également trié, mais cette fois par ordre alphabétique inverse. Une variante de cette méthode de tri est implémentée dans la fonction arsort() décrite ci-dessous.

La fonction asort() fonctionne à peu près de la même manière que la fonction sort() mentionnée ci-dessus, mais elle conserve l'association originale des index avec les éléments quel que soit le nouvel ordre des éléments. Syntaxe de la fonction asort() :

void asort (tableau tableau)

Revenons au tableau $cities :

$cities = array("Aprilia", "Nettuno", "Roma", "Venezia", ​​​​​​"Anzio");

Suite au tri du tableau $cities à l'aide de la fonction rsort(), les éléments seront disposés dans l'ordre suivant :

villes = Aprilia

villes = Nettuno

villes = Venise

Faites attention aux indices et comparez-les avec ceux donnés dans la description de la fonction sort(). C'est précisément la différence entre les deux fonctions.

La fonction arsort() est une variante de asort() qui conserve l'association d'index d'origine mais trie les éléments dans l'ordre inverse. Syntaxe de la fonction arsort() :

tableau vide (tableau tableau)

Utilisons la fonction arsort() pour trier le tableau $cities :

$cities = array("Aprilia", "Nettuno", "Roma", "Venezia", ​​​​​​"Anzio");

tri($villes);

villes = Venise

villes[l] = Nettuno

villes = Aprilia

Faites attention aux indices et comparez-les avec ceux donnés dans la description de la fonction rsort(). C'est précisément la différence entre les deux fonctions.

La fonction ksort() trie un tableau par clé, en préservant les associations clé-valeur d'origine. Syntaxe de la fonction ksort() :

void ksort (tableau)

Par exemple, considérons un tableau légèrement différent du tableau d'origine

$wine_producters = array ("Amérique" ​​=> "Napa Valley",

"Italie" => "Toscane",

"Australie" => "Ruthgerlen",

"France" => "Loire",

"Chili" => "Vallée de Rapel");

Suite au tri d'un tableau à l'aide de la fonction ksort(), les éléments seront disposés dans l'ordre suivant :

"Amérique" => "Napa Valley"

"Australie" => "Ruthgerlen"

"Chili" => "Vallée de Rapel"

"France" => "Loire"

"Italie" => "Toscane"

Comparez les résultats du tri de $wine_producers avec la fonction sort() :

"Amérique" => "Napa Valley"

"Australie" => "Toscane"

"Chili" => "Ruthgerlen"

"France" => "Loire"

"Italie" => "Vallée de Rapel"

Un résultat plus que douteux !

La fonction krsort() est presque la même que ksort(), mais les clés sont triées dans l'ordre inverse. Syntaxe de la fonction krsort() :

void krsort(tableau $tableau)

Regardons comment trier le tableau des reproducteurs $wi à l'aide de la fonction krsort() :

$wine_producters = array ("Amérique" ​​=> "Napa Valley",

"Italie" => "Toscane",

"Australie" => "Ruthgerlen",

"France" => "Loire".

"Chili" => "Vallée de Rapel");

krsort($wine_producters);

Suite au tri, les éléments seront disposés dans l’ordre suivant :

"Italie" => "Toscane"

"France" => "Loire"

"Chili" => "Vallée de Rapel"

"Australie" => "Ruthgerlen"

"Amérique" => "Napa Valley"

Les fonctions de tri décrites ci-dessus seront probablement suffisantes dans la plupart des cas. Cependant, dans certaines situations, vous devrez peut-être définir vos propres critères de tri. En PHP, cette fonctionnalité est implémentée dans trois fonctions standards : usort(), uasort() et uksort().

La fonction usort() permet de trier un tableau en fonction d'un critère défini par le programmeur. Pour ce faire, usort() reçoit en paramètre le nom de la fonction qui détermine l'ordre de tri. La syntaxe de la fonction usort() est :

void usort (tableau, chaîne nom_fonction)

Le paramètre array contient le nom du tableau trié et le paramètre function_name contient le nom de la fonction sur la base de laquelle le tri sera effectué. Disons que vous avez une longue liste de noms grecs que vous devez mémoriser pour votre prochain examen d'histoire. Vous souhaitez trier les mots par longueur afin de commencer par les plus longs, puis d'apprendre les plus courts lorsque vous êtes fatigué. Pour trier un tableau par longueur, vous pouvez utiliser la fonction usort().

Inscription 5.2. Définir des critères de tri pour la fonction usort()

$vocab = аrrау("Socrate", "Aristophane", "Platon", "Eschyle", "Thesmophoriazusae");

fonction compare_length($str1, $str2) (

// Récupère la longueur des deux mots suivants

$longueur1 = strlen($str1);

$longueur2 = strlen($str2);

// Détermine quelle chaîne a la longueur la plus courte

si ($longueur1 == $longueur2) :

sinon (longueur 1 $)< $length2) :

// Appelez usort() en spécifiant la fonction compare_length()

// comme critère de tri

usort($vocab, "compare_length") :

// Sortie de la liste triée

while (list ($key, $val) = each ($vocab)) (

echo "$val
";

Dans le listing 5.2, la fonction compare_length() définit comment trier le tableau. Dans ce cas, cela se fait en comparant la longueur des éléments transmis. La fonction critère doit recevoir deux paramètres représentant

éléments du tableau à comparer. Notez également comment ces éléments sont implicitement transmis à la fonction critère lors de l'appel de usort(), et comment tous les éléments sont automatiquement comparés par cette fonction.

Les fonctions uasort() et uksort() sont des variantes de usort() avec la même syntaxe. La fonction uasort() trie un tableau selon des critères définis par l'utilisateur tout en préservant les associations clé/valeur. La fonction uksort() trie également le tableau selon des critères définis par l'utilisateur, mais elle trie les clés, pas les valeurs.

Autres fonctionnalités utiles

Cette section décrit certaines fonctions qui n'appartiennent à aucune section spécifique, mais qui sont sans aucun doute utiles.

La fonction arrayjnerge() fusionne de 1 à N tableaux, en les combinant selon l'ordre dans lequel ils sont répertoriés dans les paramètres. La syntaxe de la fonction array_merge() est :

tableau tableau_merge (tableau tableau1, tableau tableau2, ..., tableau tableauN]

Regardons un exemple union simple des tableaux avec la fonction arrayjnerge() ;

$arr_1 = array("fraise", "raisin", "citron");

$arr_2 = array("banane", "cacao", "lime");

$arr_3 = array("pêche", "orange");

$arr_4 = array_merge ($arr2, $arr_1, $arr_3) :

// $arr_4 = array("banane", "cacao", "citron vert", "fraise", "raisin", "citron", "pêche", "orange");

La fonction array_slice() renvoie une tranche d'un tableau dont les positions de début et de fin sont spécifiées par le décalage par rapport au début et un paramètre de longueur facultatif. La syntaxe de la fonction array_slice() est :

array array_slice (tableau tableau, décalage int [, longueur int])

• Si le décalage est positif, la position de départ du fragment renvoyé est comptée à partir du début du tableau.
• Si le décalage est négatif, la position de départ du fragment renvoyé est comptée à partir de la fin du tableau.
• Si la longueur n'est pas spécifiée, le tableau renvoyé inclut tous les éléments de la position de début à la fin du tableau.
• Si une longueur positive est spécifiée, le fragment renvoyé se compose du nombre d'éléments spécifié.
• Si une longueur négative est spécifiée, le fragment renvoyé se termine dans le nombre d'éléments spécifié à partir de la fin du tableau.

La fonction array_spl ice() est vaguement similaire à array_slice() : elle remplace une partie du tableau, définie par une position de départ et une longueur facultative, par des éléments d'un paramètre de tableau facultatif. La syntaxe de la fonction array_splice() est :

array_splice(array input_array, int offset, , );

Les valeurs des paramètres sont définies selon certaines règles :

• Si le décalage est positif, la position de départ du premier élément à supprimer est comptée à partir du début du tableau.
• Si le décalage est négatif, la position de départ du premier élément à supprimer est comptée à partir de la fin du tableau.
• Si la longueur n'est pas spécifiée, tous les éléments de la position de départ à la fin du tableau sont supprimés.
• Si une longueur positive est spécifiée, le fragment à supprimer comprend le nombre d'éléments spécifié.
• Si une longueur négative est spécifiée, les éléments du tableau sont supprimés de la position de départ à la position correspondant à la distance spécifiée de la fin du tableau.
• Si remplacement_array n'est pas spécifié, alors les éléments spécifiés par le décalage et la longueur facultative sont supprimés du tableau.
• Si un remplacement_array est spécifié, il doit être enfermé dans une construction array() (s'il contient plus d'un élément).

Regardons quelques exemples qui démontrent clairement les capacités de cette fonction. Ces exemples utiliseront le tableau $pasta (voir ci-dessus) sur lequel diverses opérations seront effectuées.

Suppression de tous les éléments de la cinquième position à la fin du tableau :

$pasta = array_splice($pasta, 5);

Suppression des cinquième et sixième éléments :

$pasta = array_splice($pasta. 5, 2);

Remplacement des cinquième et sixième éléments par de nouvelles valeurs :

$pasta = array_splice($pasta, 5, 2, array("element1", "element2"));

Suppression de tous les éléments à partir du cinquième jusqu'au troisième élément à partir de la fin du tableau :

$pasta = array_splice($pasta, 5, -3);

Comme vous pouvez le voir dans ces exemples, la fonction array_splice() offre la flexibilité nécessaire pour supprimer des éléments d'un tableau avec un minimum de code.

La fonction shuffle() trie les éléments d'un tableau dans un ordre aléatoire. La syntaxe de la fonction shuffle() est :

void shuffle (tableau tableau);

Résultats

Ce chapitre a examiné les tableaux et les fonctions PHP standard pour travailler avec des tableaux. En particulier, les thèmes suivants ont été abordés :

• créer des tableaux indexés et associatifs ;
• tableaux multidimensionnels ;
• afficher le contenu de tableaux multidimensionnels ;
• recherche d'éléments ;
• ajouter et supprimer des éléments ;
• taille du tableau ;
• tri;
• autre fonctionnalités utiles pour travailler avec des tableaux.

Les tableaux sont des outils très pratiques et universels pour travailler avec des données dans des applications Web. Dans les exemples des chapitres suivants, les tableaux seront utilisés à plusieurs reprises pour améliorer l'efficacité et la clarté du code.

Au chapitre 6, nous continuerons à présenter les bases de PHP. Cette fois, nous parlerons des capacités orientées objet du langage.

Fonctions pour travailler avec des tableaux en PHP beaucoup, et ce n'est pas surprenant étant donné que vous devez travailler assez souvent avec des tableaux lors de la programmation. Et dans cet article, nous analyserons les principales fonctions que nous avons créées pour travailler avec des tableaux en PHP développeurs.

Tout d’abord, regardons la fonction la plus simple qui vérifie si un élément se trouve dans un tableau. La fonction s'appelle dans_array():

$arr = array("Num", "Str", "Int");
if (in_array("Str", $arr)) echo "Élément trouvé" ;
?>

Comme le montre l'exemple, cette fonction vérifie la présence du premier paramètre parmi les valeurs du tableau spécifié par le deuxième paramètre. Et revient vrai, si l'élément est trouvé, ou FAUX, s'il n'est pas trouvé. Les plus avancés demanderont : « Mais qu’en est-il de choses telles que 0 Et FAUX, car ce différentes significations, mais PHP les considère comme identiques ?". Pour cela, dans fonctions in_array() Il existe également un troisième paramètre, facultatif, qui s'il a une valeur vrai, alors la fonction vérifie non seulement les valeurs, mais aussi les types :

$arr = tableau(0, "Str", "Int");
if (in_array(false, $arr, true)) echo "Élément trouvé" ;
else echo "Élément introuvable" ;
?>

Une autre fonctionnalité très utile est tableau_unique() qui prend un tableau et renvoie un tableau sans valeurs en double :

$arr = tableau(3, 5, "Val", 3, "Val", 7);
$arr_uniq = tableau_unique($arr);
print_r($arr_uniq);
?>

Comme vous pouvez le voir en exécutant le script, il n'y a aucune valeur en double dans le tableau résultant.

Très fonctions importantes- ce sont des fonctions permettant d'extraire une partie d'un tableau de l'original (analogue à la fonction sousstr(), uniquement pour les chaînes) :

$arr_2 = array_slice($arr, 3);
print_r($arr_2);
?>

Cette fonction prend deux paramètres : le tableau d'origine et le numéro de l'élément à partir duquel doit commencer le nouveau tableau (rappelez-vous que la numérotation commence à zéro). Comme vous pouvez le voir, le nouveau tableau ira de l'élément dont le numéro est spécifié dans le deuxième paramètre jusqu'à la fin du tableau d'origine. De plus, si vous ajoutez un troisième paramètre, vous pouvez définir la longueur du nouveau tableau :

$arr = array(12, 10, 15, "Nom", "Certains", -0.5);
$arr_2 = array_slice($arr, 3, 2);
print_r($arr_2);
?>

En conséquence, vous verrez : " Tableau ( => Nom => Certains)".

Passons maintenant au dernier groupe de fonctions - fonctions de tri de tableaux. Mais d’abord, permettez-moi de vous rappeler la différence entre les listes et les tableaux associatifs. Liste est un tableau dont les indices sont des nombres classés par ordre croissant, en commençant par 0 . UN tableau associatif est un tableau dont les index sont, de manière générale, des chaînes appelées clés. Pourquoi est-ce si important lors du tri ? Si vous triez une liste, alors il n'est pas du tout important pour vous que le lien soit enregistré : " valeur clé", puisque les index ne servent pas à identifier une valeur, mais seulement à y accéder. Et dans un tableau associatif, c'est le connecteur qui est primordial : " valeur clé", il faut donc qu'il soit conservé lors du tri.

Commençons par quelque chose de simple : trier les listes. Pour cela il y a Fonctions sort() et rsort(). La première fonction trie le tableau par ordre croissant et la seconde par ordre décroissant :

$arr = tableau(15, 12, "Chaîne", 40, -2, 0, 12);
trier($arr);
print_r($arr);
écho "
";
rsort($arr);
print_r($arr);
?>

Je pense que tout est clair ici.

Passons maintenant à fonctions de tri des tableaux associatifs: un tri() Et tri (). Ils font tout pareil, mais la connexion" valeur clé" est enregistré :

$arr = array("Nom" => "Tommy", "Âge" => "34", "Niveau" => "15");
un tri($arr);
print_r($arr);
écho "
";
tri($arr);
print_r($arr);
?>

Maintenant, jetons un coup d'oeil fonctions de tri par clés de tableaux associatifs: ksort() Et tri ():

$arr = array("Nom" => "Tommy", "Âge" => "34", "Niveau" => "15");
ksort($arr);
print_r($arr);
écho "
";
krsort($arr);
print_r($arr);
?>

Je suis sûr que tout est transparent ici. Et si quelque chose n'est pas clair, exécutez le script et analysez le résultat.

Et enfin, considérons fonctions de tri personnalisées: uasort() Et uksort(). Les deux fonctions prennent deux paramètres : un tableau et fonction de tri personnalisée. La fonction trie le tableau par valeurs, et Fonction uksort() trie le tableau par clés. À titre d'exemple, considérons le script suivant :

fonction cmp($x, $y) (
si ($x == $y) renvoie 0 ;
si ($x == 1) renvoie 1 ;
si ($y == 1) renvoie -1 ;
si ($x > $y) renvoie 1 ;
sinon, renvoie -1 ;
}
$arr = array("A" => 1, "C" => 3, "B" => 2);
uasort($arr, "cmp");
print_r($arr);
écho "
";
uksort($arr, "cmp");
print_r($arr);
?>

Comme vous pouvez le constater, nous avons rédigé nos propres règles de tri, selon lesquelles le nombre " 1 " est toujours supérieur à toute autre valeur. Si aucun des nombres n'est " 1 ", puis on compare selon les règles habituelles. Ainsi, PHP trie notre tableau selon les règles décrites dans la fonction de comparaison dont nous avons passé le nom dans les fonctions uasort() Et uksort().

C'est tous les principaux fonctions pour diverses manipulations avec des tableaux. Bien sûr, ce n'est pas tout ce que les développeurs ont fait pour nous, mais ces fonctions sont vraiment importantes et sont régulièrement utilisées dans la pratique.

Aujourd'hui, nous allons examiner les tableaux. Nous allons vous parler de leur syntaxe, divers types, fonctions intégrées pour travailler avec des tableaux. Nous donnerons également des exemples pratiques d'utilisation de tableaux en PHP.

Mais je vais d’abord vous raconter une histoire intéressante.

Il y a un magasin de DVD près de mon bureau avec super sélection Films anglais. Le propriétaire du magasin n'est pas une personne très instruite, mais il peut toujours trouver facilement le film souhaité parmi 20 000 disques. Comment fait-il ?

J'ai analysé sa stratégie. Le propriétaire du magasin a classé tous les DVD en différents genres et a également fourni des identifiants/codes spéciaux pour différentes étagères. Il conserve des films similaires sur les mêmes étagères. Chaque étagère porte un nom de catégorie, tel que Films romantiques, Films d'horreur, etc. Chaque DVD possède un identifiant unique qui peut être utilisé pour le suivi.

Donc, si jamais vous ouvrez votre propre magasin de DVD, procédez comme suit :

• Rangez les DVD similaires sur la même étagère.
• Étiquetez chaque catégorie par son nom.
• Étiquetez les rangées de DVD.
• Attribuez des identifiants à tous les DVD.

Passons maintenant à la morale de l’histoire, qui nous ramènera dans le monde des ordinateurs.
Parfois, en programmation, vous devez gérer des valeurs liées qui sont liées les unes aux autres de différentes manières. Par exemple, les noms des cinq meilleurs étudiants, les modèles de voitures Porsche, les variables représentées sous une certaine forme, etc. Dans de tels cas, il est nécessaire d'organiser le code et la logique pour les gérer efficacement et rapidement. Vous pouvez utiliser la logique du vendeur de DVD pour faire ceci :

1. Organisez vos données en différentes catégories.
2. Définissez des lignes (lignes).
3. Attribuez des identifiants uniques à chaque valeur de données.

Une définition simple des tableaux : un bloc qui permet de combiner des données similaires du même type pour meilleure organisation et le traitement.

Définition correcte du tableau

"Une collection de différentes variables avec une seule étiquette, permettant d'organiser les valeurs pour un traitement plus facile."

C'est ma propre définition des tableaux. Bien que certains les définissent comme « une variable qui contient d’autres variables ».

Syntaxe du tableau :

$arrayName = tableau (« valeur1 ? », valeur2 ?, « valeur3 ?) ;

Nous utilisons le symbole $ pour donner le nom du tableau. Ceci est suivi d'un signe égal, puis mot-clé"tableau" . Cela indique à l'analyseur que nous travaillons avec un tableau.

Viennent ensuite les valeurs entre parenthèses, et chacune est enfermée entre double citation et séparés par une virgule.

Un exemple de définition et d'affichage de tableaux en PHP :

Le résultat du programme ci-dessus sera le suivant :

Tableau ( => fastcreators.com => howtoforge.com => scriptsbible.com)

Nous utilisons print_r car vous ne pouvez pas imprimer un tableau en utilisant echo ou print. Bien que vous puissiez les utiliser pour afficher éléments individuels du tableau. Par exemple:

écho $Top3Sites ; //fastcreators.com

N'oubliez pas que le numéro d'index commence par 0 et non par 1.

Chaque valeur du tableau reçoit un identifiant unique, appelé NUMÉRO D'INDEX.
Une autre façon serait de définir trois variables, de leur attribuer des valeurs et d'utiliser différents opérateurs pour les afficher. Cela peut être acceptable dans le cas de trois valeurs acceptées par l'argument. Mais cela n’est pas adapté lorsqu’il s’agit de cinquante ou centaines de valeurs.

Dans l'exemple ci-dessus, nous avons défini un tableau et lui avons attribué des valeurs en une seule étape. Bien que vous puissiez le faire comme ceci :

Types de tableaux

Il existe trois types de tableaux en PHP :

• Numérique : un tableau avec une clé d'identification numérique.
• Associatif : Un tableau dans lequel chaque clé d'identification est associée à une valeur.
• Multidimensionnel : un tableau composé d'un ou plusieurs tableaux.

Les tableaux numériques utilisent un entier comme numéro d'index pour identifier chaque élément. Les exemples que nous avons examinés ci-dessus sont des tableaux numériques. Ils utilisent des valeurs entières comme index.

blanc => noir => bleu) */ ?>

Dans le code ci-dessus, les indices du blanc, du noir et du bleu correspondent à 0, 1, 2. C'est pourquoi nous appelons ces tableaux numériques.

Tableaux associatifs

Parfois, il est préférable d’utiliser des noms d’index plutôt que des nombres. Par exemple, si vous souhaitez stocker les noms et numéros de trois étudiants.

Lors de la soumission des données du formulaire en utilisant Méthode POST ou GET, vous obtenez un tableau associatif. Essayez de créer un formulaire HTML avec des champs, de le publier et d'afficher un tableau global sur la page de traitement, par exemple :

print_r($_POST); print_r($_GET);

et vous obtiendrez un tableau associatif.

Les tableaux associatifs facilitent la gestion des informations liées aux représentations de données de formulaires complexes, aux valeurs de bases de données dynamiques, etc.

Tableaux multidimensionnels

Un tableau multidimensionnel peut contenir des tableaux en lui-même et les sous-tableaux peuvent contenir d'autres tableaux.

Prenons un exemple de vrai vie. David a deux fils, Richie et Mason. Richie a deux filles – Sue et Natasha, tandis que Mason a trois filles – Nicole, Salma et Amber. Leur arbre généalogique ressemble à ceci :

Si nous voulons afficher l'arbre généalogique de David à l'aide d'un tableau PHP multidimensionnel, nous pouvons définir le tableau comme ceci :

$david = array ("richie"=>array ("Sue", "Natasha"), "Mason"=>array ("Nichole", "Salma", "Amber"));

Vous pouvez utiliser des tableaux multidimensionnels pour organiser les données. Essayez de soumettre un tableau de champs de formulaire, puis de générer un tableau global pour tester la sortie et vous vous retrouverez avec un tableau multidimensionnel global qui inclura d'autres tableaux.

Boucle FORACH

La boucle FOREACH est utilisée pour prendre chaque valeur de tableau suivante et y effectuer les actions requises.

La syntaxe de base de la boucle FOREACH est la suivante :

foreach($arraynameas $temporaryVarName) ( // le corps de la boucle foreach //$temporaryVarName contient les valeurs du tableau et //à chaque itération suivante, il prend la prochaine valeur disponible du tableau)

Écrivons un programme en utilisant la boucle FOREACH :

$std_name agit comme une variable qui prend la valeur d'un tableau. Chaque fois que la boucle s'exécute, la valeur suivante du tableau écrase la valeur $std_name existante et $std_name pointe vers la valeur actuellement sélectionnée. C'est ainsi que nous parcourons les valeurs du tableau une par une.

Le résultat du code ci-dessus est :

David Kevin Julie Nayyar

La boucle FOREACH se termine lorsqu'elle atteint la dernière valeur du tableau. Dans notre cas, il s'agit de la valeur NAYYAR.

Vous pouvez rompre la boucle à tout moment en utilisant l'instruction break. Par exemple, lors du traitement du nom Julie, vous pouvez inclure une instruction IF dans le code ci-dessus, comme indiqué ci-dessous :

Il existe d'autres fonctions pratiques pour travailler avec des tableaux.

Fonctions importantes du tableau

1) Sauvegarde de la sortie de la fonction print_r :

Auparavant, nous utilisions print_r pour afficher les valeurs d'un tableau. Mais vous pouvez ajouter un argument supplémentaire à print_r et stocker le résultat dans une variable. Par exemple:

Print_r affichera le tableau lui-même sauf si vous utilisez TRUE comme deuxième argument. Mais si TRUE est spécifié, la fonction stocke la sortie dans une variable.

2) Comment déterminer la taille d’un tableau ?

Si vous souhaitez déterminer le nombre de valeurs dans un tableau, vous pouvez utiliser la fonction COUNT comme ceci :

Le code ci-dessus génère 3 car il y a trois éléments dans le tableau.

3) fonction var_dump :

Il s'agit d'une fonction similaire à print_r() . En gros, ça fait la même chose, mais :

• affiche les tailles des variables ;
• n'affiche pas de données non publiques dans les objets ;
• ne prend pas en charge un deuxième paramètre pour renvoyer la sortie.

La modification du premier script à l'aide de var_dump() donne le résultat suivant :

array(3) ( => string(6) « Pommes » => string(7) « Oranges » => string(5) « Poires » )

La fonction var_dump() montrait que le tableau avait trois valeurs et imprimait également la longueur de chaque ligne.

4) fonction var_export :

Il existe une fonction var_export() qui est similaire à var_dump() et print_r() . Il diffère en ce qu'il affiche en conséquence des informations sur une variable, qui peuvent être utilisées comme code PHP. Par exemple, si nous utilisions var_export() au lieu de print_r(), nous obtiendrions ce qui suit :

array (0 => 'Pommes', 1 => 'Oranges', 2 => 'Poires',)

Notez qu'une virgule supplémentaire est ajoutée après le dernier élément. Mais elle est ignorée par PHP, et vous pouvez copier et coller ces informations directement dans vos scripts :

"Pommes", 1 => "Oranges", 2 => "Poires"); ?>

5) fonction array_shift :

Il supprime le premier élément du tableau et le stocke dans une variable.

Par exemple, vous pouvez supprimer les pommes du tableau utilisé dans les exemples précédents et stocker cette valeur dans une autre variable :

C'est une fonction pratique si vous disposez d'un tableau multidimensionnel transmis à partir d'un formulaire et que vous souhaitez obtenir une sous-matrice à partir du tableau principal. Mais lorsque vous sélectionnez une sous-matrice du tableau principal à l'aide de array_shift , les variables réceptrices ($fruit dans l'exemple précédent) seront le tableau.

Je vous suggère également d'explorer d'autres fonctions utiles liées à array_shift :

array_unshift

tableau_pop

tableau_push

Je tiens également à souligner que la boucle FOREACH n'est pas le seul moyen de traiter des tableaux. Cela peut être fait en utilisant une boucle FOR ou les fonctions list() et each().

Pour traiter un tableau, vous devez déterminer la taille du tableau comme indiqué ci-dessous :

Cela fonctionne très bien pour les tableaux numériques comportant des index entiers, mais ne fonctionne pas pour les tableaux associatifs.

Un tableau est une collection de variables, indexées et liées entre elles en une seule super variable, offrant un accès et une référence faciles, qui fournit moyen pratiqueéchanger plusieurs valeurs entre des lignes de code, des fonctions et même des pages. Cet article donne un aperçu structure interne tableaux et décrit toutes les fonctions PHP intégrées conçues pour manipuler les tableaux. Mais avant d'approfondir ce sujet, il convient d'examiner les manières les plus courantes d'utiliser les tableaux dans le code PHP réel.

De nombreuses variables d'environnement intégrées de PHP sont représentées sous forme de tableaux (un exemple est le tableau $_SESSION, qui contient tous les noms et valeurs de variables propagés de page en page à l'aide du mécanisme de session de PHP). Pour accéder à ces variables, vous devez au minimum savoir comment accéder aux tableaux.

Tableaux associatifs et indexés numériquement

Les tableaux indexés numériquement utilisent des nombres comme valeurs d'index, tandis que les tableaux associatifs utilisent des chaînes. Dans les tableaux associatifs, chaque nouvel élément doit se voir attribuer un index de chaîne unique. Les tableaux avec des index numériques vous permettent d'ajouter simplement un élément, et PHP attribuera automatiquement son index au premier nombre libre, en commençant par 0. Les deux types de tableaux vous permettent d'ajouter de nouveaux éléments un par un. Les tableaux associatifs sont parfaits pour stocker des informations de configuration car leurs clés peuvent stocker des informations sémantiques.

Attention : la plupart des gens commencent à compter non pas à partir de 0, mais à partir de 1. En étant distrait, vous pouvez facilement faire référence à un élément de tableau inexistant - c'est ce qu'on appelle erreur de surestimation de un(erreur par une). Pour obtenir la valeur d'index du dernier élément d'un tableau, vous devez soustraire un de la longueur du tableau. Un symptôme typique indiquant que vous avez commencé par erreur à parcourir un tableau à partir de l'index 1 plutôt que de 0 est la découverte que lorsque vous essayez d'accéder au dernier élément du tableau, un tel élément n'est tout simplement pas trouvé.

En PHP, les tableaux avec des index numériques sont stockés exactement de la même manière que les tableaux associatifs. Les tableaux avec des index numériques offrent un moyen plus simple de parcourir des ensembles de données car vous pouvez accéder à la valeur suivante en incrémentant de un l'index de la précédente.

Création d'un tableau

Pour créer des tableaux dans Scripts PHP Il existe trois manières principales : attribuer une valeur à l'un des éléments du futur tableau (et ainsi créer implicitement un tableau), utiliser la construction array() et appeler une fonction dont la particularité est de renvoyer un tableau comme valeur.

Affectation directe

La manière la plus simple de créer un tableau est d'agir sur une variable comme s'il s'agissait déjà d'un tableau et de lui attribuer une valeur :

Code PHP // Création et remplissage d'un tableau numérique $array = 1; $tableau = 2; $array = "Bonjour tout le monde !"; // Création et remplissage d'un tableau associatif $arr["fruit"] = "apple"; $arr["couleur"] = "vert"; $arr["compte"] = 40; // Les tableaux associatifs et numériques peuvent être mélangés, cela ne provoquera // pas d'erreurs (mais il vaut mieux ne pas utiliser cette approche) $arr = "pear"; $array["dix"] = 10;

Pour créer un tableau, vous devez déterminer les valeurs de ses éléments et indices. Les éléments du tableau peuvent avoir n'importe quelle valeur, y compris des chaînes, des nombres et même d'autres tableaux. Le champ clé doit être un scalaire. Les valeurs scalaires sont des valeurs d'un type primitif tel que des nombres ou des chaînes, y compris les valeurs VRAI et FAUX, mais pas les données pouvant avoir plusieurs valeurs composites, telles que des objets. De plus, le champ clé du tableau pour chaque élément doit avoir une valeur unique, sinon vous pouvez écrire un nouvel élément par-dessus un élément existant avec la même clé. Si vous essayez d'attribuer une clé à un nouvel élément déjà défini pour un autre élément, la nouvelle valeur remplacera simplement l'ancienne.

La construction array()

Une autre façon de créer un tableau consiste à utiliser la construction array(), qui crée un nouveau tableau basé sur la spécification des éléments et de leurs clés associées. Dans son version la plus simple La construction array() est appelée sans paramètres, ce qui entraîne la création d'un nouveau tableau vide. Plus complexe que la version la plus simple est la construction array(), qui prend une liste d'éléments séparés par des virgules à stocker, sans aucune spécification de clés. Le résultat est que les éléments sont stockés dans le tableau dans un ordre donné et se voient attribuer des clés entières commençant par zéro. Par exemple, en exécutant l'instruction :

Code PHP // Crée un tableau numérique en utilisant la construction array() $fruit = array("Orange", "Apple", "Banana", "Pear");

fait que le nom de la variable $fruit devient le nom d'un tableau avec quatre éléments de chaîne ("Orange", "Apple", "Banana", "Pear"), ayant respectivement les index 0,1, 2 et 3. De plus, le tableau se souvient de l'ordre dans lequel les éléments y ont été écrits. Ainsi, l'opération d'affectation ci-dessus à $fruit produit exactement le même résultat que les opérations suivantes :

Code PHP

à condition que $fruit n'était pas lié au moment de la première affectation. Un effet similaire peut également être obtenu en omettant les index dans l'opération d'affectation, comme dans l'exemple suivant :

Code PHP $fruit = "Orange" ; $fruit = "Pomme" ; $fruit = "Banane" ; $fruit = "Poire" ;

Dans ce cas, l'interpréteur PHP part du principe que des éléments séquentiels sont ajoutés, qui doivent avoir des index entiers, comptés à partir de zéro.

Il convient de souligner encore une fois que par défaut la numérotation des indices de tableau commence à zéro, et non à un. Cette convention de numérotation des indices de tableau est acceptée dans la plupart des langages de programmation.

DANS exemple simple La construction array() de l'exemple précédent attribuait automatiquement des indices aux éléments, mais ces indices sont exclusivement entiers et comptés à partir de zéro, cette approche n'offre donc pas beaucoup de choix. Mais il s'avère que la construction array() offre la possibilité d'utiliser une structure syntaxique spéciale pour créer des tableaux associatifs. Au lieu de lister les valeurs des éléments séparées par des virgules, cette construction vous permet de spécifier des paires clé-valeur séparées par des virgules dans lesquelles la clé et la valeur sont séparées par le caractère spécial =>. Considérez la déclaration suivante :

Code PHP $fruit = array(0 => "Orange", 1 => "Pomme", 2 => "Banane", 3 => "Poire");

L'exécution de cet opérateur produira le même résultat que l'exécution des opérateurs d'affectation ci-dessus - chaque chaîne sera stockée dans le tableau de manière séquentielle et ces valeurs de chaîne se verront attribuer les indices 0, 1, 2, 3 dans l'ordre. Cependant, vous pouvez utiliser exactement il s'agit plutôt de la même structure syntaxique pour stocker les mêmes éléments, mais avec des index de chaîne :

Code PHP $fruit = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire");

Cela ajoutera les quatre mêmes éléments au tableau dans le même ordre, mais les indexera en utilisant des touches de couleur plutôt que des nombres. Par exemple, pour extraire le nom d'un fruit d'un tableau couleur jaune, il suffit de calculer l'expression suivante :

Code PHP // Cet élément doit avoir la valeur "Banane" $fruit["jaune"];

Fonctions qui renvoient des tableaux

La dernière façon de créer un tableau dans un script consiste à appeler une fonction qui renvoie un tableau. Il peut s'agir d'une fonction définie par l'utilisateur ou d'une fonction intégrée qui crée un tableau à l'aide de certaines méthodes PHP internes.

Par exemple, de nombreuses fonctions qui interagissent avec la base de données renvoient leurs résultats sous forme de tableaux créés dynamiquement. Il existe également d'autres fonctions conçues uniquement pour créer des tableaux qui peuvent être facilement utilisés comme modèles dans les fonctions ultérieures de manipulation de tableaux. Une de ces fonctions est gamme(), qui prend deux entiers comme paramètres et renvoie un tableau rempli de tous les entiers (inclus) situés sur l'axe des nombres entre ces paramètres. En d'autres termes, l'opérateur $my_array = range(1,5); est équivalent à l'opérateur $my_array = array(1, 2, 3, 4, 5);.

Exemples de valeurs

Cette section vous permet de trouver la réponse à la question de savoir comment les valeurs sont récupérées d'un tableau après leur stockage dans ce tableau.

Sélection par index ou clé

Le moyen le plus direct de récupérer la valeur d’un élément d’un tableau consiste à utiliser l’index de l’élément. Par exemple, si une valeur a été écrite dans le tableau $my_array à l'index 5, l'évaluation de l'expression $my_array devrait aboutir à la récupération de la valeur stockée.

construction list()

Il existe de nombreuses autres façons de récupérer les valeurs des tableaux qui n'utilisent pas de clés. La plupart de ces méthodes sont basées sur le fait que les tableaux, par défaut, enregistrent les éléments dans l'ordre dans lequel ils ont été transférés vers le stockage. La construction list() est utilisée pour attribuer plusieurs valeurs d'éléments de tableau consécutifs à des variables. Supposons que deux instructions aient été exécutées :

Code PHP $fruit = array("Orange", "Pomme", "Banane", "Poire"); liste($fruit1, $fruit2) = $fruit;

Ces instructions attribuent la chaîne "Orange" à $fruit1 et la chaîne "Apple" à $fruit2 (la chaîne "Banana" n'est affectée à aucune variable car trop peu de variables ont été spécifiées). Les variables de la construction list() se voient attribuer les valeurs des éléments du tableau dans l'ordre dans lequel les éléments ont été initialement stockés dans le tableau. Remarquez à quel point la structure syntaxique de l'opérateur d'affectation est inhabituelle : la construction list() se trouve à gauche du signe de l'opérateur d'affectation (=), alors qu'à cette position, vous ne voyez généralement que les noms de variables.

À certains égards, la construction list() est l'opposé, ou l'inverse, de array(), car array() regroupe ses paramètres dans un tableau, tandis que list() décompresse le tableau, attribuant des valeurs aux variables individuelles.

Tableaux multidimensionnels

Dans tous les exemples considérés jusqu'à présent, les tableaux étaient unidimensionnels, puisque les clés spécifiées dans accolades, défini un seul niveau d'accès au tableau. Mais Langage PHP facilite la prise en charge de tableaux multidimensionnels avec un nombre arbitraire de clés. Les tableaux multidimensionnels sont simplement des tableaux qui stockent d'autres tableaux. Vous trouverez ci-dessous un exemple de création de tableaux multidimensionnels numériques et associatifs, ainsi qu'un organigramme expliquant leur utilisation :

Code PHP // Deux tableaux simples unidimensionnels $counts = array(1, 2, 10, 14, -5); $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); // Deux tableaux bidimensionnels $counts2 = 1; $compte2 = 2 ; $compte2 = 3 ; $compte2 = 4 ; $compte2 = 5 ; $compte2 = 6 ; $compte2 = 7 ; $compte2 = 8 ; $compte2 = 9 ; $nature = array("fruit" => array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"), " flower" => array("red" => "Aster", "white" => "Rose", "pink" => "Pivoine", "blue" => "Bell")); // Affiche la valeur de la fleur blanche echo $nature["flower"]["white"]; Structure des tableaux unidimensionnels et bidimensionnels de l'exemple

Il convient de noter que tenter d’accéder à un tableau multidimensionnel en utilisant le mauvais index pour récupérer une valeur n’entraîne pas de sanctions sévères ; si aucune clé correspondante n'est trouvée, alors l'expression entière est traitée comme une variable indépendante.

Obtenir des informations sur les tableaux

Ce qui précède décrit comment créer des tableaux, stocker des valeurs dans les tableaux, puis récupérer à nouveau les valeurs si nécessaire. Le tableau ci-dessous fournit un résumé de certains autres types de fonctions pouvant être utilisées pour obtenir des informations sur les tableaux.

Fonctions PHP simples pour obtenir des informations sur les tableaux

Fonction	Description
est_array()	Accepte un seul paramètre de n'importe quel type et renvoie true si le paramètre est un tableau ; sinon renvoie faux
compter()	Prend un tableau comme paramètre réel et renvoie le nombre d'éléments non vides dans le tableau
taille de()	Identique à count()
dans_array()	Prend deux paramètres réels : un élément (qui peut être écrit dans un tableau en tant que valeur) et un tableau (qui peut contenir l'élément). Renvoie vrai si l'élément est contenu dans le tableau en tant que valeur ; sinon, renvoie faux. (Notez que cette fonction ne vérifie pas si le tableau contient des clés spécifiques.)
estSet($tableau[$clé])	Prend la forme d'un tableau et renvoie vrai si la partie désignée par clé est une clé valide pour le tableau. (Il s'agit d'une manière spécialisée d'utiliser davantage fonction générale isSet(), qui vérifie si une variable est liée.)

Il convient de noter que toutes ces fonctions ne fonctionnent qu'à la profondeur d'un niveau d'un tableau donné, donc pour obtenir des données sur les valeurs stockées dans un tableau multidimensionnel à des niveaux plus profonds, il est nécessaire de préciser à quel niveau le des informations doivent être obtenues. Vous trouverez ci-dessous un exemple dans le cas du tableau bidimensionnel $nature ci-dessus :

Code PHP nombre d'écho ($ nature); // 2 nombre d'écho ($nature["fleur"]); // 4

Supprimer des éléments des tableaux

L'opération de suppression d'un élément d'un tableau est simple et tout à fait similaire à l'opération de suppression d'une valeur affectée à une variable. Il vous suffit d'appeler la fonction non défini() comme ci-dessous :

Code PHP $mon_array = "valeur" ; $my_array = "cette valeur doit être supprimée" ; $my_array = "une autre valeur" ; unset ($ mon_array);

Une fois le code terminé, cette variable $my_array contiendra deux valeurs ("valeur", "une autre valeur") associées à deux indices (0 et 2, respectivement).

Il est à noter que l’opération de suppression d’un élément n’est pas la même que l’opération d’attribution d’une valeur vide à un élément. Par exemple, si au lieu d'appeler la fonction unset() l'instruction suivante était utilisée :

Code PHP $mon_array = "";

alors le tableau finirait par contenir trois valeurs stockées ("valeur", "", "une autre valeur"), associées à trois indices (respectivement 0, 1 et 2).

Tableaux itérés

Les tableaux PHP stockent non seulement les valeurs associées aux clés correspondantes, mais produisent également par défaut une liste ordonnée de paires clé-valeur, stockées dans l'ordre dans lequel elles ont été écrites dans le tableau. Cette structure de tableau a été adoptée afin que le tableau puisse être utilisé pour parcourir tout le contenu du tableau. (Il convient de noter que cette tâche est difficile à accomplir simplement en formant une boucle qui incrémente la valeur de l'index, puisque les index des tableaux PHP ne doivent pas nécessairement être numériques.)

En fait, les tableaux intègrent une sorte de système de pointeurs caché. Chaque paire clé-valeur stockée pointe vers la suivante, et l'un des effets secondaires est que le pointeur actuel pointe vers le tout premier élément et reste pointé sur cet élément à moins qu'il ne soit décalé par l'une des fonctions itératives.

Dans chaque tableau, une paire clé-valeur stockée spécifique est mémorisée comme étant la paire actuelle, et une certaine part Les actions des fonctions itératives de tableau sont basées sur le principe du déplacement de ce marqueur de la paire actuelle à travers une liste interne de clés et de valeurs. Nous appellerons ce marqueur le pointeur courant, mais il faut tenir compte du fait que le langage PHP ne supporte pas les pointeurs à part entière dans le sens où ce concept est interprété par les programmeurs travaillant dans les langages C/C++/C#. De plus, le terme pointeur actuel, utilisé dans ce sens, n'apparaîtra que dans le contexte de la description de moyens d'itération sur les éléments d'un tableau.

Le système de pointeurs considéré basé sur une liste chaînée est manière alternative obtenir des informations sur les tableaux et les manipuler. Le système de pointeur existe à côté d'un système qui permet d'écrire et de récupérer un tableau en fonction de clés.

boucle foreach

Pour organiser le traitement cyclique d'un tableau, vous pouvez utiliser une boucle foreach. Il semble certainement que cette construction soit héritée de la construction foreach de Perl, mais qu'elle ait une structure syntaxique légèrement étrange (qui, cependant, ne correspond pas à l'étrange structure syntaxique de la construction similaire en Perl). La structure syntaxique de la construction foreach en PHP se décline en deux versions, et la décision quant à celle qui doit être utilisée dans un programme dépend de si vous souhaitez récupérer à la fois les clés et les valeurs du tableau ou simplement les valeurs :

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); // Utilisez une boucle foreach pour récupérer uniquement les valeurs foreach ($fruits as $value) ( ​​​​echo $value."
"; ) écho "
"; // Utiliser une boucle foreach pour récupérer les valeurs et les clés foreach ($fruits as $key => $f) ( echo " ".$clé."=> ".$f."
"; }
Utiliser une boucle foreach

Fonctions itératives

J'aime la construction foreach, mais elle n'est vraiment utile que dans les situations où vous souhaitez simplement parcourir les valeurs stockées dans un tableau. Pour obtenir un contrôle supplémentaire sur le code de traitement, vous devez utiliser des fonctions itératives, décrites dans le tableau ci-dessous :

Fonctions de traitement de tableaux en boucle

Fonction	Possibilités	Effet secondaire	Valeur de retour
actuel()		Absent	La valeur de la paire clé-valeur actuellement pointée par le pointeur interne « actuel » (ou false si une telle valeur n'existe pas)
suivant()	Un paramètre réel avec notation matricielle	Avance le pointeur d’un élément. Si le pointeur pointe déjà vers le dernier élément, cette fonction avance le pointeur "hors du tableau", donc un appel ultérieur à current() retournera false	La valeur vers laquelle pointe le pointeur après avoir été avancé (ou false s'il n'y a pas de valeur actuelle, c'est-à-dire que le pointeur a dépassé le tableau)
précédent()	Un paramètre réel avec notation matricielle	Avance le pointeur vers l’arrière d’un élément. Si le pointeur pointe déjà vers le premier élément, avance le pointeur en dehors du tableau, en le plaçant "avant le début du tableau".	La valeur vers laquelle pointe le pointeur après avoir été avancé dans la direction opposée (ou false s'il n'y a pas de valeur actuelle, c'est-à-dire que le pointeur a dépassé les limites du tableau)
réinitialiser()	Un paramètre réel avec notation matricielle	Avance le pointeur vers l'arrière pour qu'il pointe vers la première paire clé-valeur (ou vers la position "avant le début du tableau" si le tableau est vide)	La première valeur stockée dans le tableau, ou false si le tableau est vide
fin()	Un paramètre réel avec notation matricielle	Déplace le pointeur vers l'avant et le définit sur la dernière paire clé-valeur	La dernière valeur actuellement dans la liste des paires clé-valeur
pos()	Un paramètre réel avec notation matricielle	Aucun (Cette fonction est un alias de la fonction current().)	La valeur de la paire clé-valeur vers laquelle le pointeur pointe actuellement
chaque()	Un paramètre réel avec notation matricielle	Déplace le pointeur vers la paire clé-valeur suivante	Un tableau qui contient les données clé et valeur de la paire clé-valeur qui était actuelle avant le déplacement du pointeur (ou une fausse valeur s'il n'y a pas de paire actuelle, c'est-à-dire que le pointeur est en dehors des limites du tableau). Dans le tableau renvoyé, la clé et la valeur sont stockées sous les propres clés du tableau, respectivement 0 et 1, et sous les propres clés du tableau, "key" et "value", respectivement.
tableau_walk()	Le premier paramètre est un paramètre réel avec une désignation de tableau, le deuxième paramètre est le nom d'une fonction avec deux (ou trois) paramètres réels qui est appelée sur chaque paire clé-valeur et le troisième paramètre est un paramètre réel facultatif.	La fonction array_walk() appelle la fonction spécifiée comme deuxième paramètre réel sur chaque paire clé-valeur. Les effets secondaires dépendent des effets secondaires de la fonction passée	Renvoie la valeur 1

La fonction current() renvoie la valeur stockée vers laquelle pointe actuellement le pointeur. Dans un tableau nouvellement créé avec des éléments, le pointeur actuel pointe toujours vers le premier élément. La fonction next() fait d'abord avancer le pointeur, puis renvoie la valeur actuelle vers laquelle le pointeur est pointé. Si next() est appelé dans des conditions où le pointeur actuel pointe déjà vers la dernière valeur stockée et doit donc aller au-delà de la fin du tableau, la fonction renvoie false.

À titre d'exemple, envisagez d'afficher le contenu d'un tableau à l'aide des fonctions itératives current() et next(), comme indiqué ci-dessous :

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); function print_all_next($array) ( $current = current($array); if ($current) echo $current."
"; else echo "Pointeur introuvable"; while ($current = next($array)) echo $current."
"; écho "
"; ) print_all_next($fruits); print_all_next($fruits); // Lancer un appel répété // pour voir ce qui se passe

Après avoir exécuté ce code de sortie de tableau, les données suivantes seront à nouveau obtenues :

Utilisation des fonctions current() et next()

Les résultats donnés ici soulèvent la question : comment se fait-il que le deuxième appel à print_all_next() ait produit les mêmes résultats ? Comment avez-vous réussi à ramener le pointeur actuel au début afin de répéter toutes les opérations une seconde fois ? La réponse vient du fait que les appels de fonctions PHP sont des appels par valeur. Ainsi, des copies de paramètres sont transmises à la fonction et la fonction opère sur ces copies, et non sur les paramètres eux-mêmes. Par conséquent, dans ces deux appels à la fonction, une copie non modifiée du tableau utilisé comme paramètre est transmise et le tableau lui-même n'est pas affecté par l'appel à next().

L'exemple précédent montre comment écrire votre propre fonction, qui est un analogue partiel d'une boucle foreach. Mais la boucle foreach vous permet également d'afficher les clés. Modifions notre exemple en ajoutant des clés à la sortie de l'écran à l'aide de la fonction clé():

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); function print_all_next($array) ( $current = current($array); $current_key = key($array); if ($current) echo " $clé_actuelle=> ".$courant."
"; else echo "Pointeur introuvable"; while ($current = next($array)) ( $current_key = key($array); echo " $clé_actuelle=> ".$courant."
"; ) écho "
"; ) print_all_next($fruits);
Utiliser la fonction key() pour obtenir les clés d'un tableau

Outils de conversion de tableaux

Le langage PHP fournit un certain nombre de fonctions qui permettent de manipuler des données une fois que ces données ont été stockées sous forme de tableaux pour en faciliter l'utilisation. La caractéristique commune des fonctions abordées dans cette section est qu'elles prennent toutes un tableau comme paramètre, effectuent certaines actions dessus et renvoient les résultats sous la forme d'un autre tableau (une description des fonctions de tri de tableaux sera donnée dans un des sections suivantes).

Les fonctions de manipulation de tableau sont données dans le tableau ci-dessous :

Fonctions de conversion de tableau

Description	Fonction
tableau_clés()	Prend un seul paramètre sous forme de tableau et renvoie un nouveau tableau dont les valeurs sont les clés du tableau d'entrée, et les clés sont des entiers croissants séquentiellement à partir de zéro
tableau_valeurs()	Prend un seul paramètre sous forme de tableau et renvoie un nouveau tableau dont les valeurs sont les valeurs du tableau d'entrée et les clés sont des entiers croissants séquentiellement, en commençant par zéro.
array_count_values()	Prend un seul paramètre sous forme de tableau et renvoie un nouveau tableau dont les clés sont les valeurs du tableau d'entrée et dont les valeurs sont le nombre de fois que la valeur d'origine apparaît dans le tableau d'entrée
tableau_flip()	Prend un seul paramètre sous forme de tableau et le modifie pour que les clés deviennent les valeurs, et vice versa
tableau_inverse()	Prend un seul paramètre sous forme de tableau et inverse l’ordre interne des paires clé-valeur. S'il y a des clés numériques entières dans le tableau, elles sont également renumérotées
mélanger()	Prend un seul paramètre sous forme de tableau et modifie de manière aléatoire l'ordre interne des paires clé-valeur. Les clés entières sont également renumérotées selon le nouvel ordre. La fonction shuffle() utilise un générateur lors de l'exécution nombres aléatoires rand(), donc avant d'appeler cette fonction, vous devez d'abord appeler la fonction srand() pour initialiser la valeur initiale du générateur (ceci est discuté dans l'article suivant)
tableau_merge()	Prend deux paramètres sous forme de deux tableaux, les fusionne et renvoie un nouveau tableau composé des éléments du premier tableau (dans l'ordre d'origine), suivis des éléments du deuxième tableau. Cette fonction est plus applicable au traitement de tableaux qui sont de simples listes chaînées, plutôt que de tableaux associatifs, car si deux tableaux associatifs ont des clés identiques, une seule des valeurs de chaque clé en double se retrouve dans le tableau résultant, et la seconde est détruit. Si le tableau résultant contient des clés numériques entières, elles sont renumérotées conformément au nouvel ordre, en partant de zéro.
tableau_pad()	Prend trois paramètres : le tableau d'entrée, le nombre d'éléments dans le tableau complété et la valeur que les éléments complétés doivent contenir. Renvoie un nouveau tableau rempli d'éléments selon les règles suivantes. Si le nombre d'éléments dans le tableau complété dépasse le nombre d'éléments dans le tableau d'entrée, alors le tableau est complété à droite jusqu'au nombre d'éléments spécifié selon le même principe que si les opérations d'affectation suivantes étaient effectuées à la suite : $mon_array = $pad_value. Si la valeur spécifiée pour le nombre d'éléments dans le tableau complété est négative, alors le remplissage se produit de la même manière que s'il était positif, sauf que le tableau est complété à gauche (début) plutôt qu'à droite (fin). Si le nombre d'éléments dans le tableau d'entrée dépasse le nombre d'éléments dans le tableau complété, l'exécution de cette fonction n'a aucun effet.
tableau_slice()	Prend trois paramètres : un tableau d'entrée, un décalage entier et une valeur de longueur entière (facultatif). Renvoie un nouveau tableau qui est un fragment de l'ancien - une sous-séquence de sa liste de paires clé-valeur. Les éléments de début et de fin d'un fragment sont déterminés par le décalage et la longueur. Une valeur de décalage positive indique que élément initial est l'élément compté depuis le début du tableau, et une valeur de décalage négative indique l'élément compté depuis la fin. Le paramètre facultatif de longueur peut également être positif ou négatif. Une valeur positive spécifie la longueur de la tranche que array_slice() doit produire, et une valeur négative spécifie à quel élément, en partant de la fin du tableau, la tranche doit se terminer. S'il n'y a pas de paramètre de longueur, le fragment sélectionné continue jusqu'à la fin du tableau
tableau_splice()	Supprime un fragment (considéré comme la partie coupée) d'un tableau et le remplace par le contenu d'un autre tableau. Prend quatre paramètres : un tableau d'entrée, un décalage, une valeur de longueur entière facultative et un tableau de remplacement facultatif. Renvoie un nouveau tableau contenant la partie coupée qui a été supprimée du tableau d'entrée. Les règles d'utilisation des paramètres offset et length qui spécifient la tranche à supprimer sont les mêmes que dans la fonction array_slice() décrite ci-dessus. Si aucun tableau de remplacement n'est spécifié, alors cette fonction supprime simplement (de manière destructive) la partie coupée du tableau d'entrée et la renvoie. S'il existe un tableau de remplacement, les éléments de ce tableau sont insérés à la place de la partie supprimée

Examinons ces fonctions plus en détail à l'aide d'exemples.

Récupération des clés et des valeurs

La fonction array_keys() renvoie les clés du tableau donné en entrée sous la forme d'un nouveau tableau dont les clés sont les valeurs stockées. Les clés du nouveau tableau sont des index ordinaires sous la forme d'entiers à croissance automatique qui partent de zéro. La fonction array_values() fait exactement la même chose, sauf que les valeurs stockées sont les valeurs du tableau d'origine :

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); echo "Tableau de clés :
"; foreach (array_keys($fruits) as $key => $value) ( ​​​​echo " ".$clé."=> ".$valeur."
"; ) écho "
Tableau de valeurs :
"; foreach (array_values($fruits) as $key => $value) ( ​​​​echo " ".$clé."=> ".$valeur."
"; }
Obtenir un tableau de clés et de valeurs à partir d'un tableau source à l'aide des fonctions array_keys() et array_values()

Apparemment, les résultats de la deuxième fonction en question (array_values()) sont moins intéressants, puisque cette fonction prend en fait le tableau d'origine et crée un nouveau tableau dont les clés sont remplacées par des nombres croissants séquentiellement.

Une opération légèrement plus utile (qui peut être d'une grande aide pour résoudre le problème de commande) peut être effectuée en utilisant la fonction array_count_values(). Cette fonction prend un tableau comme paramètre et renvoie un nouveau tableau dans lequel les anciennes valeurs sont converties en nouvelles clés et les nouvelles valeurs indiquent combien de fois chaque ancienne valeur apparaît dans le tableau d'origine.

Mise en miroir, inversion et brassage aléatoire

Une fonction moins couramment utilisée que celles décrites ci-dessus est la fonction array_flip(), qui convertit les clés du tableau en valeurs et vice versa. Il convient de noter que les clés du tableau sont garanties uniques, mais que les valeurs du tableau ne sont pas garanties d'être uniques. Pour cette raison, toutes les valeurs en double dans le tableau d'origine sont converties en la même clé dans le nouveau tableau. Par conséquent, une seule des clés originales est conservée, qui devient la nouvelle valeur correspondante.

L'inversion de tableau est une opération moins complexe : array_reverse() renvoie un nouveau tableau avec les paires clé-valeur dans l'ordre inverse.

Si des éléments aléatoires supplémentaires doivent être introduits dans le programme, alors la fonction shuffle() peut être utilisée pour ce faire. La fonction shuffle() prend un tableau comme paramètre et modifie aléatoirement l'ordre des éléments du tableau.

L'exemple suivant montre l'utilisation de ces fonctions :

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); // array_flip() echo "Tableau initial :
"; foreach ($fruits comme $key => $value) ( ​​​​​echo " ".$clé."=> ".$valeur."
"; ) écho "
tableau_flip():
"; $fruits = array_flip($fruits); foreach ($fruits as $key => $value) ( ​​​​​​echo " ".$clé."=> ".$valeur."
"; ) // array_reverse() écho "
Tableau source :
"; $array = range(1,5); foreach ($array as $value) ( ​​​​echo $value." "; ) echo "
Tableau après avoir utilisé la fonction tableau_inverse():
"; $array = array_reverse($array); foreach ($array as $value) ( ​​​​echo $value." "; ) // shuffle() echo "

Tableau source :
"; $array = range(1,10); foreach ($array as $value) ( ​​​​echo $value." "; ) echo "
Tableau après avoir utilisé la fonction mélanger():
"; srand((double)microtime()*1000000); // Utilisé pour générer un mélange de nombres aléatoires ($array); foreach ($array as $value) ( ​​​​echo $value." "; )
Utilisation des fonctions array_flip(), array_reverse(), shuffle()

Contrairement à la plupart des autres fonctions de tableau présentées dans cet article, la fonction shuffle() est destructeur. Cela signifie qu'il s'applique directement au tableau donné en paramètre et le modifie, plutôt que de renvoyer un tableau nouvellement créé. (Fonctions renvoyant nouvel objet et ne pas modifier leurs paramètres sont généralement appelés constructifs ou non destructifs.) Entre autres choses, cela signifie que la bonne façon d'appeler la fonction de mélange aléatoire des éléments en question n'est pas :

Code PHP $array = aléatoire($array); // Conception incorrecte !

Fusionner, ajouter, couper et coller des éléments de tableau

Si vous devez combiner deux tableaux, par exemple pour obtenir plus liste complète, vous pouvez alors utiliser la fonction array_merge(). Cette fonction prend deux tableaux ou plus comme paramètres et renvoie un nouveau tableau avec des clés renumérotées, le deuxième tableau étant ajouté à la fin du premier. Par exemple:

Code PHP $new_array = array_merge(range(0,2), array(5,6,7), array(10,11)); //

La fonction array_pad() est utilisée pour créer un nombre spécifié de paires clé-valeur de début ou de fin afin d'augmenter la taille du tableau. Cette fonction prend un tableau d'entrée comme premier paramètre. Ce paramètre doit être suivi du nombre d'éléments dont le tableau est augmenté, puis de la valeur attribuée aux éléments supplémentaires. Si un entier positif est spécifié comme deuxième paramètre, alors le tableau est complété à la fin, et si un entier négatif est spécifié, le tableau est complété au début. Si le deuxième paramètre est inférieur à la taille du tableau, aucun remplissage n'est effectué :

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); foreach (array_pad($fruits, 10, "vide") as $key => $value) ( ​​​​echo " ".$clé."=> ".$valeur."
"; }
Augmenter la taille d'un tableau à l'aide de la fonction array_pad()

Notez que les touches attribuées automatiquement commencent à zéro, même si elles sont comptées à partir de la cinquième position.

Les fonctions array_slice() et array_splice() sont un peu plus complexes. Le premier renvoie un sous-ensemble des éléments du tableau d’entrée, en prenant respectivement le décalage et la longueur comme deuxième et troisième paramètres. array_splice() est similaire à array_slice() mais prend un quatrième paramètre, qui peut être un tableau de n'importe quelle longueur à insérer dans le tableau d'entrée.

Piles et files d'attente

Les piles et les files d'attente sont des structures de données abstraites souvent utilisées en programmation qui imposent des règles d'accès spécifiques aux objets qu'elles contiennent, règles largement indépendantes du type d'objets eux-mêmes. Les tableaux PHP sont bien adaptés pour résoudre les problèmes d'émulation de structures de données d'autres types, et en raison de l'absence de typage strict des éléments du tableau PHP, il est possible d'émuler facilement des structures de données telles que des piles et des files d'attente à l'aide de tableaux. PHP possède des fonctions de tableau spécialement conçues à cet effet. Si le programme utilise exclusivement de telles fonctions, le programmeur peut même ne pas tenir compte du fait que les structures de données en question sont basées sur des tableaux.

Une pile est un conteneur qui stocke des valeurs et prend en charge les opérations d'accès dernier entré, premier sorti (LIFO) à ces valeurs. Cela signifie que la pile conserve l'ordre des valeurs qui y sont stockées et fournit le seul moyen de récupérer la valeur qui y est stockée - en récupérant (et en supprimant) la valeur stockée la plus récemment :

Pile - "dernier entré, premier sorti"

Une analogie courante utilisée pour décrire une pile est une pile de plateaux dans une cafétéria devant l'une des lignes de service, à partir de laquelle les clients prennent les plateaux en les écrémant par le haut, et les employés réapprovisionnent constamment le stock de plateaux en les empilant également. haut. De nouveaux plateaux peuvent être placés sur ceux existants et ceux existants peuvent être pris par le haut, mais les plateaux précédemment placés ne peuvent pas être atteints sans d'abord retirer les plateaux placés ultérieurement.

Une file d'attente s'apparente à une pile, mais fonctionne sur le principe d'une file d'attente séquentielle (premier entré, premier sorti - FIFO). Habituellement, pour décrire une telle file d'attente, une analogie est utilisée avec une chaîne de personnes en attente de service, appelée file d'attente en Angleterre et file d'attente aux États-Unis. Règle générale Le service pour les personnes faisant la queue est que la personne qui a fait la queue le plus longtemps doit être servie ensuite :

File d'attente - "premier entré, premier sorti"

Pour travailler avec des piles, les fonctions array_push() et array_pop() sont utilisées. Fonction tableau_push() prend en paramètre un tableau initial, qui peut être suivi de n'importe quel nombre d'éléments poussés sur la pile. Les éléments sont insérés à la fin du tableau, dans l'ordre de gauche à droite. Fonction tableau_pop() prend un tel tableau comme paramètre et supprime l'élément à la fin du tableau, renvoyant cet élément.

Tri des tableaux

Enfin, PHP possède de nombreuses fonctions pour trier les tableaux. Comme indiqué ci-dessus, il peut parfois être difficile de faire la distinction entre la situation dans laquelle les associations clé-valeur sont appliquées dans un tableau et la situation dans laquelle les clés numériques sont traitées comme des informations de classement qui doivent être modifiées lorsque l'ordre des éléments est modifié. Heureusement, PHP propose des fonctions de tri de variantes qui prennent en compte les spécificités de chacun de ces types de situations. De plus, PHP vous permet de trier les éléments par ordre croissant ou décroissant, ainsi que d'utiliser les fonctions de tri fournies par l'utilisateur. Les noms des fonctions de tri sont abrégés mais contiennent des désignations de lettres(sauf la partie du nom avec le mot sort), qui permettent de déterminer le but de la fonction. Ci-dessous se trouve brève description les désignations des lettres indiquées :

Le « a » en tête signifie que la fonction trie par valeurs mais conserve les associations entre les paires clé-valeur telles qu'elles existent.

Le « k » initial indique que le tri s'effectue par clé, mais que les associations clé-valeur sont conservées.

L'absence de « a » ou de « k » en tête signifie que le tri est effectué par valeurs, mais que les associations clé-valeur ne sont pas conservées. En particulier, les touches numériques sont renumérotées pour refléter le nouvel ordre.

La lettre « r » devant le mot sort signifie que l'ordre de tri est inversé.

Le «u» initial indique que la fonction prend un deuxième paramètre, le nom d'une fonction définie par l'utilisateur qui spécifie l'ordre de deux éléments à trier.

Ces règles simples vous aideront à éviter de vous perdre dans les fonctions de tri suivantes :

Fonctions de tri de tableaux

Fonction	Description
un tri()	Accepte un seul paramètre sous forme de tableau. Trie les paires clé-valeur par valeur, mais conserve le mappage clé-valeur inchangé. C'est très pratique lorsque l'on travaille avec des tableaux associatifs
tri ()	Identique à asort(), mais trie par ordre décroissant
ksort()	Accepte un seul paramètre sous forme de tableau. Trie les paires clé-valeur par clé, mais conserve les associations clé-valeur inchangées
tri ()	Identique à ksort(), mais trie par ordre décroissant
trier()	Accepte un seul paramètre sous forme de tableau. Trie les paires clé-valeur d'un tableau en fonction de leurs valeurs. Les clés peuvent être renumérotées pour correspondre au nouvel ordre des valeurs
tri()	Identique à sort(), mais trie par ordre décroissant
uasort()	Trie les paires clé-valeur par valeur à l'aide d'une fonction de comparaison. Similaire à asort(), sauf que l'ordre réel des valeurs est déterminé par le deuxième paramètre, qui est le nom d'une fonction d'ordre définie par l'utilisateur. Cette fonction doit renvoyer un nombre négatif si son premier paramètre vient avant le second (tel que déterminé par la fonction de comparaison), un nombre positif si son premier paramètre vient après le second et zéro si les éléments comparés sont les mêmes.
uksort()	Trie les paires clé-valeur par clé à l'aide d'une fonction de comparaison. Similaire à uasort(), sauf que le classement se fait par clés plutôt que par valeurs
usort()	Trie le tableau par valeurs à l'aide de la fonction de comparaison fournie. Similaire à uasort(), sauf que les associations clé-valeur ne sont pas conservées (comme avec sort())

Vous trouverez ci-dessous un exemple simple de tri alphabétique :

Code PHP $fruits = array("orange" => "Orange", "rouge" => "Pomme", "jaune" => "Banane", "vert" => "Poire"); trier($fruits); foreach ($fruits comme $key => $value) ( ​​​​​echo " ".$clé."=> ".$valeur."
"; }
Utilisation de la fonction sort()

Comme vous pouvez le voir, la fonction sort() a non seulement trié les valeurs, mais a également remplacé les clés de texte par des index numériques. Si ce comportement n'est pas souhaité, alors la fonction asort() doit être utilisée.

Expressions régulières Calcul des nombres et opérations mathématiques 1 2 3 4 5 6 7 8 9 10

1. Qu'est-ce qu'un tableau PHP ?
2. Exemple de tableau PHP ?
3. Tableau unidimensionnel(vecteur)
- indice
- associatif
4. Tableau bidimensionnel (tableau dans un tableau, matrice)
5. Fonctions pour travailler avec des tableaux (tableau dans un tableau, matrice)

Je voudrais commencer ce sujet avec des exemples renoncés. Disons que nous envisageons certains personne. Il a prénom, nom, adresse, numéro de téléphone, sexe, taille, couleur des yeux et ainsi de suite. Les informations sur tous ces points peuvent être attribuées à un ensemble de données sur une personne.

Le tableau peut être d'un type différent, sans aucune précision sur les éléments. Il n'y aura qu'un sujet. Disons ceci programmation web. Et les éléments seront des langues - HTML, CSS, Javascript, PHP, MySQL. Il y a 5 éléments au total.

Sur la base du dernier exemple, supposons un tableau :

programmation web
1. HTML
2.CSS
3. Javascript
4.PHP
5. MySQL

Regardez maintenant cet exemple et analysez les concepts de base.

Tableau en PHP est un ensemble de données séquentiellement localisées du même type, liées par un thème commun, dont le nombre d'éléments est fixe.

Le tableau dans cet exemple sera appelé programmation web.

Chaque élément a sa propre place ordinale, identifiant.
Indice(clé de tableau) - soit un numéro de séquence, soit une valeur textuelle par laquelle l'élément peut être identifié.

Les index dans l'exemple ci-dessus seraient valeur numérique de 1 à 5. Lors de l'accès à l'index 2, nous verrons le CSS.

Exemple de tableau en PHP

Regardons maintenant l'exemple ci-dessus dans la syntaxe PHP, pas en russe. Disons que le tableau sera appelé plus court - la toile. Les crochets inséreront un index.

Regardons un exemple simple de tableau, où les valeurs d'index contiendront des valeurs numériques, et nous créerons le tableau comme si nous attribuions des valeurs à des variables.

$web='HTML';
$web='CSS';
$web='JavaScript';
$web='PHP';
$web='MySQL';

$web ; // cette variable contient un tableau de 5 éléments

// pour afficher l'un des éléments du tableau, il suffit de spécifier l'index dans le tableau
écho $web; // imprime PHP

Tableau unidimensionnel

TABLEAU D'INDEX

Ci-dessus, avec la programmation Web, nous n'avons examiné qu'un exemple de tableau unidimensionnel.
Il est rarement créé de cette façon. Il montre plutôt visuellement la structure du tableau. Le plus souvent, ils recourent à une autre méthode.

$web=array('HTML','CSS','JavaScript','PHP','MySQL');
écho $web; // affichera 'HTML'
écho $web; // affichera 'JavaScript'
écho $web; // affichera 'PHP'

Si vous souhaitez définir des valeurs d'index, vous devez les spécifier comme suit. Signe => est un pointeur pour attribuer un index à une valeur, ou vice versa à une valeur d'index.

$web=array(1=>’HTML’,2=>’CSS’,3=>’JavaScript’,4=>’PHP’,5=>’MySQL’);
écho $web; // HTML
écho $web; // CSS
écho $web; //PHP
Dans l'exemple, le comptage part de 1. La variable d'indice 0 est donc vide.

Dans l'exemple suivant, nous ne spécifierons pas d'index.

$jour='Lundi'; // indice 0
$day='Mardi'; // 1
$day='Mercredi'; // 2
$day='Jeudi'; // 3
$jour='Vendredi'; // 4
Vous pouvez voir que le remplissage séquentiel se fait à partir de zéro.

RÉSEAU ASSOCIATIF

Il est souvent nécessaire de créer un index de lettres pour un élément du tableau. Comme je l'ai mentionné ci-dessus, un tel index doit être composé de lettres latines et le nom doit être mis entre guillemets. Regardons l'exemple d'une personne.

$user['nick']='Logique';
$user['name']='Pavel';
$user['âge']='25';
$user['sex']='Homme';

$utilisateur ; // la variable $user contient un tableau de 4 éléments avec des indices de lettres

// affiche l'élément du tableau, en indiquant son indice de lettre
echo $web['nom']; // affichera 'Pavel'
Comme vous pouvez le constater, tout est assez simple. Nous citons uniquement la valeur de l'indice.

Tableau bidimensionnel

Si vous avez raté la première partie avec le One-Dimensional Array, je vous conseille fortement de la lire.
Pour faire simple, il s’agit d’un tableau dans un tableau. Autrement dit, les éléments d’un large tableau sont différents. De tels tableaux ralentissent vraiment le script, en chargeant RAM, par conséquent, pour traiter rapidement de tels groupes de données, des bases de données ont été créées (Qu'est-ce qu'une base de données ?), mais nous y reviendrons plus tard. Regardons un exemple de tableau à deux dimensions.

// tableau avec les noms des parties du monde
$m = array('Europe','Asie','Afrique','Amérique','Australie et Océanie');

// tableau avec les noms des pays
$s = array('Russie','Ukraine','Biélorussie','Kazakhstan');

// tableau avec les noms des majuscules
$с = array('Moscou','Kiev','Minsk','Astana');

// crée un tableau bidimensionnel Géographie
$géographie = tableau($m, $s, $c);
?>
Les tableaux inclus, comme vous l'avez remarqué, peuvent avoir un nombre différent d'éléments. De la partie sur les tableaux unidimensionnels, il s'ensuit que chaque élément du tableau peut avoir un index. Attribuons donc une valeur différente à chaque tableau inclus.

Pour ce faire, développez la dernière ligne et écrivez-la comme suit.

$geography = array('Parties du monde'=>$m, 'Pays'=>$s, 'Capitales'=>$s);

Fonctions pour travailler avec des tableaux php

Pour chaque est une fonction cyclique pour travailler avec des tableaux, dans laquelle le nombre de cycles est égal au nombre d'éléments du tableau.

Cela ressemble à ceci :

Code PHP

foreach (tableau sous la forme $key=>$value)
équipes;
Eh bien, tout de suite, un exemple de travail

// crée un tableau avec le célèbre informatique
$names["Ritchie"] = "Dennis";
$names["Thompson"] = "Ken";
$names["Portes"] = "Facture";
$names["Jobs"] = "Steve";

foreach ($noms comme $key => $value) (
echo "$valeur $clé";
}
?>
Le script s'affichera à l'écran

Dennis Ritchie
Ken Thompson
Bill Gates
Steve Emplois
Compter- une fonction qui renvoie le nombre d'éléments dans le tableau.

nombre d'écho ($ noms); // dans notre exemple avec IT renverra la valeur 4
Trier- une fonction qui trie les éléments du tableau. Pratique pour les valeurs d'index numériques.
Arsort est une fonction qui trie les éléments d'un tableau dans l'ordre inverse.

trier($noms); // trie dans l'ordre. C'est pratique s'il y a des chiffres dans l'index
arsort($noms); // trier dans l'ordre inverse. Autrement dit, par indices, les éléments seront dans l'ordre 3, 2, 1, 0
Désarmé est une fonction qui supprime un élément du tableau.

non défini($tableau); // suppression d'un élément de tableau avec l'index 2
non défini($tableau); // suppression de tout le tableau
Tableau_recherche— fonction de recherche dans un tableau.

Leçon 7. Tableaux en PHP

A deux arguments. En termes simples, il a array_search('what',where)

$animaux='chien';
$animaux='chat';
$animaux='oiseau';
echo array_search('chat',$animaux); // affichera l'index de l'élément - numéro 2
Mélanger est une fonction qui mélange les clés des valeurs du tableau.

mélanger ($animaux); // arrange les éléments dans un ordre aléatoire
Merci pour votre attention!

Article précédent
Leçon 6. Boucles en PHP Article suivant
Leçon 8. Inclure un fichier en PHP. Inclure et exiger

Commentaires sur l'article (vk.com)

Crée un tableau vide.

Vous pourrez ensuite vider les valeurs dans un tableau, comme ceci :

Actuellement, $myArray contient "arbre", "maison" et "chien". Chacune des commandes ci-dessus s'ajoute au tableau, en préservant les éléments qui s'y trouvaient déjà.

Venant d'autres langages, cette façon d'ajouter un tableau m'a paru étrange. Je m'attendais à faire quelque chose comme $myArray+="dog" ou quelque chose comme ça...

ou peut-être une méthode "add()" telle que les collections Visual Basic. Mais cette syntaxe d’ajout direct est courte et pratique.

Vous devriez en fait utiliser la fonction unset() pour supprimer des éléments :

... supprimera "house" du tableau (les tableaux sont basés sur null).

Bases du travail avec des tableaux en PHP

... détruira tout le tableau.

Pour être clair, la syntaxe des crochets vides pour l'ajout à un tableau est simplement un moyen de dire à PHP d'attribuer automatiquement des indices à chaque valeur, plutôt que d'attribuer des indices. Coverings, PHP fait réellement ceci :

Vous pouvez attribuer vous-même des index si vous le souhaitez et utiliser les numéros de votre choix. Vous pouvez également attribuer des numéros d'index à certains éléments et pas à d'autres. Si vous faites cela, PHP remplira les numéros d'index manquants, en augmentant à partir du plus grand numéro d'index attribué au fur et à mesure de son arrivée.

Donc si tu fais ça :

... l'élément "chien" se verra attribuer le numéro d'index 21. PHP ne fait pas de correspondance de modèles intelligente pour attribuer les indices un par un, donc il ne saura pas que vous souhaiterez peut-être attribuer le numéro d'index 30 à "chien". Vous pouvez utiliser d'autres fonctions pour spécifier le modèle d'incrémentation d'un tableau. Je n'entrerai pas dans les détails, mais tout est dans la documentation PHP.

Dans certains autres langages (par exemple AS3), il a été noté que l'initialisation d'un nouveau tableau est plus rapide si elle est effectuée en tant que plutôt qu'à des fins de création et d'instanciation d'objets. Je me demande s'il existe des équivalences en PHP ?

Tableaux en PHP. Travailler avec des tableaux en PHP.

Cet article couvre l'utilisation de tableaux en PHP (bases). Les tableaux en PHP sont un type de données qui vous permet de stocker plusieurs variables en une seule.

Voici un exemple simple :

Dans l’exemple ci-dessus, $products est un tableau dans lequel nous avons stocké plusieurs produits différents. Ensuite, nous avons dérivé tous ces produits, en accédant à chacun via des « index » (clés) : 0, 1 et 2.

Bien entendu, les valeurs individuelles peuvent également être stockées dans des variables distinctes, par exemple comme ceci :

C'est bien sûr bien, mais imaginons que nous ayons soudain besoin de passer par tous ces éléments. Comment pouvons-nous être ici ? Écrire du code pour chaque variable ? C'est long et peu pratique. La solution consiste à utiliser des tableaux.
A l'aide de boucles, on peut accéder à l'élément suivant à chaque itération (étape), grâce à des indices (clés).

Création d'un tableau en PHP.

Il n'est pas nécessaire de déclarer un tableau en PHP. Nous pouvons créer un tableau en utilisant la fonction array() :

Dans ce cas, nous avons créé un tableau vide. Si l'on précise plusieurs valeurs entre parenthèses séparées par des virgules, alors nous remplirons ce tableau avec plusieurs éléments :

Types de tableaux.

1. Tableaux « indexés » ou « tableaux automatiques ». Nous avons déjà donné ci-dessus des exemples d’un tel tableau. Une particularité de ces tableaux est qu'ils possèdent des indices numériques créés automatiquement (« à la volée »). La numérotation des éléments commence à 0.

Comment déterminer la longueur (taille) d'un tableau indexé.

Utiliser des tableaux

Utilisation de la fonction compter():

Énumération des éléments. Vous pouvez énumérer tous les éléments d'un tableau automatique en utilisant la construction pour ou pour chaque:

Pour ajouter un nouvel élément au tableau (écrire dans le tableau), il suffit d'exécuter la ligne suivante :

L'itération sur tous les éléments d'un tableau associatif s'effectue comme suit :

3. Les tableaux multidimensionnels contiennent d'autres tableaux comme éléments :

Nous pouvons également créer un tableau tridimensionnel :

produire un tableau en PHP. Vous pouvez afficher n'importe quel tableau en utilisant la fonction print_r(), Par exemple:

Cependant, lorsqu'un élément est supprimé, les indices des autres éléments restent inchangés.

Fonctions pour travailler avec des tableaux :

Tri des tableaux
array_search – recherche une valeur dans un tableau