Créée le, 19/06/2015

 Mise à jour le, 12/05/2019

Visiteurs N°  




Accueil
Nouveau Blog Nouveautés Moteur de Recherche Votre Caddie Pour Vos Achats Votre Espace Membre Vos Signets et Vos Jeux Préférés Page de Bienvenue Statique Site en Français Site en Anglais
Sommaires
Électronique Fondamentale Technologie Fondamentale Testez vos Connaissances Électronique Théorique Digitale Électronique Pratique Digitale Lexique Électronique Numérique Data book TTL Data book CMOS Dépannage TVC Mathématique
Micro-ordinateurs
Théorique des Micro-ordinateurs Testez vos Connaissances Pratique des Micro-ordinateurs Glossaires sur les Ordinateurs
Physique
La lumière Champ d'action Rayonnement Électromagnétique
Technologies
Classification des Résistances Identification des Résistances Classification des Condensateurs Identification des Condensateurs
Formulaires Mathématiques
Géométrie Physique 1. - Électronique 1. 2. - Électronique 1. 3. - Électrotechnique 1. 4. - Électromagnétisme
Accès à tous nos Produits
E. T. F. - Tome I - 257 Pages E. T. F. - Tome II - 451 Pages E. T. F. - Tome III - 611 Pages E. T. D. - Tome I - 610 Pages N. B. M. - Tome I - 201 Pages E. T. M. - Tome I - 554 Pages Business à Domicile Ouvrages 34 pages gratuits Nos E-books Logiciel Géométrie Logiciel Composants Électroniques
Aperçu de tous nos Produits
E. T. F. - Tome I - 257 Pages E. T. F. - Tome II - 451 Pages E. T. F. - Tome III - 611 Pages E. T. D. - Tome I - 610 Pages E. T. M. - Tome I - 554 Pages Logiciel Géométrie Logiciel Composants Électroniques
Nos Leçons aux Formats PDF
Électronique Fondamentale Technologie Fondamentale Électronique Théorique Digitale Électronique Pratique Digitale Théorique des Micro-ordinateurs Mathématiques
Informatique
Dépannage Win98 et WinXP et autres Dépannage PC Glossaire HTML et Programmes PHP et Programmes JavaScript (en cours de travaux) Création de plusieurs Sites
Forums
Forum Électronique et Infos Forum Électronique et Poésie
Divers et autres
Formulaire des pages perso News XML Statistiques CountUs Éditeur JavaScript Nos Partenaires et nos Liens Utiles Gestionnaire de Partenariat Nos Partenaires MyCircle Sondages 1er Livre d'Or 2ème livre d'Or

Signets :
  Leçons suivantes        Leçons précédentes     Bas de page
  Cliquez ici pour la leçon suivante ou dans le sommaire prévu à cet effet


Utilisation de la Fonction shuffle(), Chargement de Tableaux à partir de Fichiers, Navigation au sein d'un Tableau, each, current(), reset(), end(), next(), pos() et prev(), count(), sizeof(), etc. (2ème partie) :

Retrier des tableaux :

Dans certaines applications, il apparaît nécessaire de "retrier" des tableaux selon d'autres critères. La fonction shuffle() permet alors de "mélanger" les éléments d'un tableau, c'est-à-dire de les trier de manière aléatoire. La fonction array_reverse() permet quant à elle d'obtenir une copie d'un tableau, dans laquelle tous les éléments ont été triés dans l'ordre inverse.

Utilisation de la fonction shuffle() :

Jean-Pierre aimerait présenter aux visiteurs du site de son entreprise, dans le haut de sa page d'accueil, un petit échantillonnage des articles proposés à la vente. Il aimerait extraire au hasard trois des articles de son catalogue, en proposant un échantillonnage différent à chaque nouvelle visite de ses clients, pour préserver l'intérêt de ces derniers. Un tel affichage mis à jour est facile à implémenter si tous les articles sont stockés dans un même tableau. L'exécution du listing ci-dessous, produit l'affichage de trois images d'articles choisies au hasard, en "mélangeant" le contenu du tableau, puis en affichant les images des trois premiers articles du tableau ainsi mélangé.

<HTML>

          <HEAD>

                    <TITLE> Page d'Accueil de chez Jean-Pierre </TITLE>

           </HEAD>

                    <BODY>

                <BR/> <BR/> <BR/>

                <font face="Arial" size="5" color="#005500"> <CENTER> <b> Actualisez votre Navigateur pour afficher au hasard les trois articles ou &agrave; son chargement de la page ! </b> </CENTER> </font>

                <H2> <CENTER> <BR/> Utilisation de PHP pour g&eacute;n&eacute;rer une page d'accueil dynamique sur le site Web de chez Jean-Pierre. </CENTER> </H2>

                <H1> <CENTER> <BR/> Les composants &eacute;lectroniques du site de chez Jean-Pierre ! </CENTER> </H1>

                <BR/> <BR/> <BR/>

                <TABLE WIDTH = 100%>

                <tr>

                <?php

                $pictures = array ("images/Trois_Leds.jpg", "images/Led.jpg", "images/Trois_Resistances.jpg" ,

                                                  "images/Transistor.jpg", "images/Thyristor.gif" ,

                                                  "images/Fusibles.jpg", "images/Condensateur.jpg" ,

                                                  "images/Resistance_Bobine.jpg", "images/Potentiometre.gif") ;

                shuffle ($pictures) ; // Permet de charger une image aléatoire à l'aide de la fonction "shuffle()".

                for ($i = 0 ; $i < 3 ; $i ++)

            {

                echo "<td align = 'center'> <img src = \"" ;

                echo $pictures [$i] ;

                echo " \" width = '115' height = '115' </td>" ;

            }

                ?>

                </tr>

                </TABLE>

                    </BODY>

</HTML>

Pour visualiser l'aperçu, en cliquant ici. [Exemple 10].

Etant donné que le code du listing ci-dessus, opère une sélection aléatoire d'images, il conduit à l'affichage d'une page différente à chaque chargement ou presque (voir figure 5).

La_Fonction_Shuffle.png

Utilisation de la fonction array_reverse() :

La fonction array_reverse() crée un nouveau tableau, dont le contenu est celui du tableau qui est fourni comme argument, mais trié dans l'ordre inverse. Considérons par exemple le cas d'un tableau contenant un décompte de dix à un. Il existe différentes manières de générer un tel tableau.

Nous pouvons utiliser la fonction range(), qui crée une série croissante, puis la fonction rsort pour trier cette série par ordre décroissant. Nous pouvons également créer les éléments du tableau un à un, au moyen d'une boucle for, comme suit :

    $Nombres = array() ;

    for ($i = 10 ; $i > 0 ; $i --)

    array_push ($Nombres, $i) ;

C'est ainsi qu'une boucle for peut procéder par ordre décroissant : il suffit de choisir une valeur initiale suffisamment élevée, et d'utiliser l'opérateur -- (post-décrémentation) pour diminuer le compteur d'une unité à chaque répétition de la boucle.

Le code précédent commence par créer un tableau vide, puis remplit peu à peu ce tableau par le biais de la fonction array_push() implémentée dans la boucle for, et qui ajoute chaque nouvel élément après le contenu existant déjà dans le tableau. Notez que la fonction array_pop() fait pendant à la fonction array_push() : elle supprime un élément à la fin du tableau qui lui est passé comme argument, en renvoyant l'élément supprimé.

Nous pouvons également utiliser la fonction array_reverse() pour trier dans l'ordre inverse, un tableau généré au moyen de la fonction range() :

    $Nombres = range (1, 10) ;

    $Nombres = array_reverse ($Nombres) ;

Notez que la fonction array_reverse() renvoie une copie modifiée du tableau qui lui est passé comme argument. Dans les lignes de code précédentes, toutefois, nous écrasons le tableau d'origine avec la nouvelle copie générée, parce que le tableau d'origine ne nous est plus d'aucune utilité.

Chargement de tableaux à partir de fichiers :

Nous avons vu dans la 2ème leçon, comment stocker les commandes clients dans un fichier, dont chaque ligne se présenterait de la manière suivante :

15 / 04 / 2016, 18 : 30 : 35 | 25 Resistance(s) | 56 Condensateur(s) | 98 Transistor(s) | Poupette DUPOND - 5, rue du Vésinet - 45 LOIRET

En vue du traitement de cette commande, nous pourrions la charger dans un tableau. Le script donné dans le listing ci-dessous permet d'afficher le contenu courant du fichier de commandes.

    <?php

          echo "<BR/> <BR/>" ;

          $Ordres_de_Commandes = file ("Orders/Commandes.txt") ;

          $Nombre_de_Commandes = count ($Ordres_de_Commandes) ;

          if ($Nombre_de_Commandes == 0)

      {

          echo "<p align='CENTER'> <font face='Arial' size='3' color='#FF0000'> <b> Il n'y a pas de commandes en attente. Veuillez revenir plus tard. </b> </font> </p>" ;

      }

          for ($i = 0; $i < $Nombre_de_Commandes ; $i ++)

      {

          echo "<p> <font face='Arial' size='3' color='005500'> <b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" . $Ordres_de_Commandes [$i] . "</b> </font> </p>" ;

      }

    ?>

Pour visualiser l'aperçu, en cliquant ici. [Exemple 11].

Le résultat obtenu à l'exécution de ce script est presque identique à celui produit par la 2ème leçon, en cliquant ici. Cette fois cependant, la fonction file() est utilisée pour charger l'intégralité du fichier dans un tableau. Chaque ligne du fichier devient alors un élément du tableau généré.

D'autre part, le listing ci-dessus utilise la fonction count() pour déterminer le nombre d'éléments du tableau créé.

Nous pouvons encore affiner cette opération de chargement de fichier, en chargeant chacune des sections des différentes lignes de commande dans des éléments séparés du tableaux, de sorte à pouvoir traiter les sections séparément les unes des autres, ou à les mettre en forme de manière plus attractive. Le listing ci-dessous donne le code correspondant.

<HTML>

          <HEAD>

                    <TITLE> Les Composants &Eacute;lectroniques </TITLE>

           </HEAD>

                    <BODY>

                <BR/> <BR/>

                <H1> <CENTER> Les Composants &Eacute;lectroniques de chez Jean-Pierre ! </CENTER> </H1>

                <H2> <CENTER> Bon de commande ! </CENTER> </H2>

                            <?php

                            // Lecture de l'intégralité du fichier. Chaque commande devient un élément du tableau.

                            $Commandes = file ("test_3.txt") ;

                            // Comptage du nombre de commandes stockées dans le tableau

                            $Nombre_de_Commandes = count ($Commandes) ;

                            if ($Nombre_de_Commandes == 0)

                        {

                            echo "<p><font face='Arial' size='3' color='#FF0000'> <CENTER> <b>N&deg; de Commandes en cours. Veuillez r&eacute;essayer plus tard. </b> </CENTER> </font> </p>" ;

                        }

                            echo "<CENTER> <TABLE BORDER = 1>\n" ;

                            echo "<tr><th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Date de Commande </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> R&eacute;sistances </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Condensateurs </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Transistors </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Montant Total </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Pr&eacute;nom </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Nom de Naissance </b> </font> </td>

                                                <th bgcolor = \"#FFC891\"> <font face='Arial' size='3' color='#005500'> <b> Adresse </b> </font> </td>

                                        </tr> </CENTER>" ;

                            for ($i = 0 ; $i < $Nombre_de_Commandes ; $i ++)

                        {

                            // Scission de chaque ligne

                            $line = explode( "\t", $Commandes [$i] ) ;

                            // Ne retient que le nombre des articles commandés

                            $line[1] = intval($line[1]) ;

                            $line[2] = intval($line[2]) ;

                            $line[3] = intval($line[3]) ;

                            // Sortie de chaque commande

                            echo "<tr><td> <font face='Arial' size='3' color='#000080'> $line[0] </td>

                                                <td align = CENTER> <font face='Arial' size='3' color='#000080'> $line[1] </td>

                                                <td align = CENTER> <font face='Arial' size='3' color='#000080'> $line[2] </td>

                                                <td align = CENTER> <font face='Arial' size='3' color='#000080'> $line[3] </td>

                                                <td align = CENTER> <font face='Arial' size='3' color='#000080'> $line[4] </td>

                                                <td align = CENTER> <font face='Arial' size='3' color='#000080'> $line[5] </td>

                                                <td align = CENTER> <font face='Arial' size='3' color='#000080'> $line[6] </td>

                                                <td align = LEFT> <font face='Arial' size='3' color='#000080'> $line[7] </td>

                                           </tr>" ;

                        }

                            echo "</TABLE>" ;

                            ?>

                    </BODY>

</HTML>

Si vous avez bien suivi nos premières leçons jusqu'à celles-ci, vous devriez comprendre qu'en remplissant le formulaire de chez Jean-Pierre, en cliquant ici, vos données seront sauvegardées et chargées dans un tableau. Pour se rendre compte des enregistrements concernant le tableau via les codes PHP, il suffit de cliquer ici, puis via le fichier texte (Bloc-Notes) qui se charge automatiquement dans le même tableau, en cliquant ici. Si ce dernier que vous voyez une page banche, il suffit d'actualiser votre navigateur afin que vous puissiez voir vos données enregistrées mais, le plus important, c'est celui du tableau que les données ou les informations seront sauvegardées automatiquement.

En résumant, vous avez quatre fichiers comme suit :

Un fichier intitulé "Bon_de_Commande.php", et pour visualiser l'aperçu, en cliquant ici. [Exemple 12].

Un second fichier intitulé "Ordre_de_Commande.php" permettant d'obtenir un récapitulatif de commandes.

Un troisième fichier intitulé "Affiche_les_Commandes.php", en cliquant ici.

Et le dernier fichier dans l'intitulé "test.txt", en cliquant ici, celui-ci permet d'enregistrer les commandes clients puis, de le charger dans un tableau pour la mise en forme des données.

A noter : Nous n'avons pas mis de tests conditionnels concernant les champs du formulaire de commande afin d'en simplifier la programmation mais, vous pouvez complémenter le programme en question. Ce dernier a pour but d'éducatif et de vous familiariser avec le langage PHP (pour rendre les champs obligatoires par exemple).

Le code du Listing ci-dessus de l'exemple [12], charge l'intégralité du fichier dans un tableau. Contrairement toutefois à l'exemple [11], c'est ici que la fonction explode() qui est employée pour scinder chaque ligne, pour mettre ensuite, en forme la sortie avant son impression sur le moniteur ou sur une imprimante.

Le résultat obtenu à l'exécution du Listing ci-dessus de l'exemple [12] est montré à la figure 6.

Lignes_Scindees_par_Explode.png

La fonction explode() s'utilise avec le prototype suivant :

    array explode (string séparateur, string chaîne)

Au cours de nos leçons précédentes, nous avons utilisé le caractère de tabulation, en guise de délimiteur lors du stockage de ces données. Par conséquent, l'appel de la fonction explode() doit ici être implémenté de la manière suivante :

    explode("\t", $Commandes[$i])

Cette instruction a pour effet de scinder, en plusieurs parties la chaîne passée comme argument. Chaque caractère de tabulation devient une séparation entre deux éléments. Par exemple, la chaîne suivante :

    18 / 04 / 2016, 00 : 27 : 13 \t 1 Resistance(s)\t 2 Condensateur(s)\t 3 Transistor(s)\t 27.60 euros\t Jacques\t DURAND\t 2, Rue de la violette - Escalier, 5 - 29000 AUDIERNE

est scindée en différentes parties, qui sont les suivantes :

    "18 / 04 / 2016, 00 : 27 : 13 ", "1 Resistance(s)", "2 Condensateur(s)", "3 Transistor(s)", "27.60 euros", "Jacques," "DURAND," et "2, Rue de la violette - Escalier, 5 - 29000 AUDIERNE".

Dans le même code du Listing ci-dessus de l'exemple [12], le traitement auquel sont soumises les données extraites du fichier de commande est minimal. Seules les quantités d'articles sont imprimées en sortie sur chaque ligne, puisqu'une ligne d'en-tête indique la signification des nombres affichés.

Différentes possibilités sont offertes pour extraire des nombres contenus dans des chaînes. Dans le Listing ci-dessus de l'exemple [12], nous avons utilisé la fonction intval(), qui convertit une chaîne (string), en un nombre entier (integer). Cette conversion est effectuée de manière raisonnablement intelligente, puisque les parties qui ne peuvent être converties, en nombre entier sont ignorées. Nous étudierons diverses autres méthodes de traitement des chaînes au cours des prochaines leçons.

Autres manipulations de tableaux :

Nous avons vu jusqu'ici qu'une moitié (environ) des fonctions de traitement de tableaux offertes par PHP. Parmi les autres fonctions de manipulation de tableaux, nombre ne sont utiles que de manière occasionnelle.

Navigation au sein d'un tableau ; each(), current(), reset(), end(), next(), pos(), et prev() :

Nous avons vu plus haut que chaque tableau comprend un pointeur interne dirigé sur l'élément courant du tableau. Nous avons déjà fait usage de manière indirecte de ce pointeur, lors de la mise en oeuvre de la fonction each(). Il est également possible d'utiliser et de manipuler directement ce pointeur

A la création d'un nouveau tableau, le pointeur est initialisé de sorte à pointer sur le premier élément du tableau. Pour connaître l'élément courant dans un tableau, il suffit d'invoquer la fonction current(), en passant à celle-ci le nom du tableau comme argument.

Les fonctions next() et each() permettent toutes deux de faire avancer le pointeur d'un élément. La fonction each() renvoie l'élément courant avant de déplacer le pointeur, tandis que la fonction next() fait avancer le pointeur, puis renvoie seulement ensuite le nouvel élément courant.

Comme nous l'avons déjà mentionné, la fonction reset() fait reculer le pointeur sur le premier élément du tableau. De la même manière, la fonction end() déplace le pointeur sur le dernier élément du tableau qui lui est fourni comme argument. Les fonctions reset() et end renvoient respectivement le premier et le dernier élément du tableau qui leur est passé comme paramètre.

Pour parcourir un tableau en sens inverse, vous pouvez employer les fonctions end() et prev(). La fonction prev() est l'opposé de la fonction next() : elle fait reculer le pointeur d'un élément, puis renvoie le nouvel élément courant.

Par exemple, le code qui suit produit l'affichage d'un tableau dans l'ordre inverse :

    $valeur = end ($tableau) ;

    while($valeur)

    {

    echo "$valeur<br>" ;

    $valeur = prev ($tableau) ;

    }

Si la variable $tableau avait été déclarée de la manière suivante :

    $tableau = array (1, 2, 3) ;

Alors le résultat de l'exécution du code précédent serait :

    3

    2

    1

En utilisant les fonctions each(), current(), reset(), end(), next(), pos() et prev(), vous pouvez implémenter votre propre mode de navigation au sein d'un tableau, dans l'ordre qui vous convient.

Application d'une fonction donnée à chaque élément d'un tableau ; array_walk() :

Il est parfois nécessaire de soumettre chaque élément d'un tableau à une même manipulation. La fonction array_walk() apparaît alors très pratique.

La fonction array_walk() s'utilise avec le prototype suivant :

    int array_walk (array tableau, string fonction, [données_utilisateur])

Tout comme la fonction usort(), array_walk() requiert comme deuxième argument une fonction définie par l'utilisateur.

La fonction array_walk() prend trois paramètres. Le premier, tableau, est le tableau dont le contenu doit être traité. Le second, fonction, est le nom de la fonction définie par l'utilisateur, et qui sera appliquée à chaque élément du tableau. Le troisième paramètre, données_utilisateur, est optionnel. S'il est spécifié, il est passé comme argument à la fonction définie par l'utilisateur. Nous allons voir un peu plus loin, un exemple de mise en oeuvre de la fonction array_walk().

Il pourrait, par exemple, se révéler très pratique d'attribuer à chaque élément d'un tableau une fonction qui applique une mise en forme particulière.

Le code qui suit affiche chaque élément sur une nouvelle ligne, invoquant la fonction définie par l'utilisateur MonImprime pour chaque élément du tableau $Valeur :

    $Valeur = array ("Jean-Pierre", "Alain", "Paulette", "Daniel", "Patricia") ;

    function MonImprime($Valeur)

    {

    echo "$Valeur <BR>" ;

    }

    array_walk($Valeur, "MonImprime") ;

Ce qui donne comme résultat ci-après :

    Jean-Pierre

    Alain

    Paulette

    Daniel

    Patricia

Pour chaque élément du tableau traité, array_walk() prend la clé et la valeur stockée dans le tableau, ainsi que la valeur spécifiée comme paramètre données_utilisateur, puis invoque la fonction que vous avez vous-même écrite de la manière suivante :

    VotreFonction (valeur, clé, données_utilisateur)

Dans la plupart des cas, l'argument données_utilisateur est inutile. Il est toutefois parfois nécessaire, lorsque la fonction que vous avez définie requiert un paramètre.

Occasionnellement, la clé de chaque élément est tout autant nécessaire à la manipulation effectuée que la valeur de l'élément. Ce n'est toutefois pas toujours le cas, comme avec MonImprime(), et la fonction définie par l'utilisateur peut alors ignorer la clé et le paramètre données_utilisateur qui lui sont passés par la fonction array_walk().

Considérons à présent un exemple un peu plus complexe : nous allons écrire une fonction qui modifie les valeurs d'un tableau, et requiert un paramètre. Notez que, dans ce cas, bien que nous ne soyons pas intéressé par la clé, nous devons la spécifier dans la fonction à définir pour pouvoir passer le troisième paramètre.

    $value = array (6) ;

    function MyMultiply (&$value, $key, factor)

    {

        $value *= $factor ;

    }

    array_walk ($value, "MyMultiply", 3) ;

    print_r ($value) ;

La fonction MyMultiply() ainsi défini multiplie chaque élément du tableau par le facteur passé comment argument. Dans le cardre d'une mise en oeuvre de cette fonction par la fonction array_walk(), le facteur de multiplication est spécifié via le troisième argument de array_walk(). Pour que notre fonction MyMultiply récupère ce facteur, il est impératif de la définir avec trois arguments : une valeur d'élément de tableau ($value), une clé d'élément de tableau ($key), et le facteur de multiplication ($factor). Dans ce cas, toutefois, la fonction MyMultiply() ignore la clé qui est passée comme deuxième argument.

Un point subtil mérite votre attention : la manière dont $value est passée à la fonction MyMultiply(). L'esperluette (&) insérée avant le nom de la variable dans la définition de MyMultiply() indique à l'interpréteur PHP que $value doit être passée par référence. Passer une variable par référence permet que la fonction puisse modifier le contenu du tableau.

Cette manière de passer les variables aux fonctions seront étudiées, en détail dans les prochaines leçons. Si cette notion vous est étrangère, il vous suffit pour l'heure de savoir qu'une esperluette doit être placée avant le nom d'une variable pour que la variable soit passée par référence.

Comptage des éléments d'un tableau ; count(), sizeof(), et array_count_values() :

Dans un des exemples précédents, nous avons employé la fonction count() pour déterminer le nombre des éléments d'un tableau stockant des commandes clients. La fonction sizeof() répond exactement au même objectif que la fonction count(). sizeof() et count() renvoient toutes deux le nombre des éléments du tableau qui leur est passé comme argument. Ces fonctions renvoient la valeur 1 lorsqu'elles sont appliquées à une variable scalaire normale, et 0 lorsqu'un tableau vide ou une variable non définie leur sont passés comme argument.

La fonction array_count_values() est plus complexe : elle détermine le nombre d'occurrences de chaque valeur "unique" dans le tableau qui lui est passé comme argument (et donc la "cardinalité" du tableau). Cette fonction renvoie un tableau associatif contenant une table de fréquences. Le tableau renvoyé par array_count_values() contient comme clés toutes les valeurs uniques du tableau passé à array_count_values comme argument ($tableau), et comme valeurs le nombre d'occurrences des clés correspondantes dans $tableau.

Ainsi, le code suivant crée un tableau appelé $Tableau.

    $array = array (4, 5, 1, 2, 3, 1, 2, 1) ;

    $Tableau = array_count_values ($array) ;

    print_r ($Tableau) ;

Sont contenu est le suivant :

Clé Valeur
4 1
5 1
1 3
2 2
3 1

L'exécution de ce code produit le résultat suivant :

    Array ( [4] => 1 [5] => 1 [1] => 3 [2] => 2 [3] => 1 )

Dans ce cas précis, le tableau renvoyé par array_count_values() nous informe que le tableau $array contient une seule fois les valeurs 4, 5 et deux fois les valeurs 3, quatre fois la valeur 1, et deux fois la valeur 2.

Conversion de tableaux en variables scalaires ; extract() :

Un tableau associatif contenant des paires clé/valeur peut être transformé, en un ensemble de variables scalaires au moyen de la fonction extract(). Le prototype de la fonction extract() est le suivant :

    extract (array var_array [, int type_extract] [, string préfixe]) ;

La fonction extract() génère des variables scalaires à partir du tableau qui lui est passé comme argument, en utilisant les clés comme noms de variables, et les valeurs des éléments comme valeurs de variables.

Voici un exemple simple d'utilisation de la fonction extract() :

    $array = array ("key1" => "Valeur_1", "key2" => "Valeur_2", "key3" => "Valeur_3") ;

    extract ($array) ;

    echo "$key1 $key2 $key3" ;

L'exécution de ce code produit le résultat suivant :

    Valeur_1 Valeur_2 Valeur_3

Le tableau $array contient trois éléments dont les clés sont key1, key2 et key3. La fonction extract() appliquée à la variable $array conduit à la création des trois variables scalaires $key1, $key2 et $key3. Vous pouvez constater, dans le résultat obtenu, que les valeurs de $key1, $key2 et $key3 sont respectivement "Valeur_1", "Valeur_2", et "Valeur_3". Ces valeurs proviennent du tableau d'origine $array.

La fonction extract() prend deux arguments optionnels : type_extract, et préfixe. Le paramètre type_extract indique à la fonction extract() la manière dont doivent être gérées les collisions, c'est-à-dire les situations où il existe déjà une variable portant le même nom. Le comportement par défaut de extract() consiste à écraser la variable existante. Le tableau de la figure 7 décrit les quatre valeurs aurorisées comme argument type_extract.

Fig. 7. - Valeurs permises pour l'argument "type_extract" de la fonction extract().
Type Signification
EXTR_OVERWRITE Écrase la variable existante en cas de collision.
EXTR_SKIP Saute l'élément en cas de collision.
EXTR_PREFIX_SAME Crée une variable dénommée $prefix_key en cas de collision. Le paramètre préfixe doit alors être spécifié.
EXTR_PREFIX_ALL Préfixe tous les noms de variable avec la valeur spécifiée dans le paramètre préfixe. Le paramètre préfixe doit alors être spécifié.

Les deux valeurs les plus couramment utilisées pour l'argument type_extract sont la valeur par défaut (EXTR_OVERWRITE) et EXTR_PREFIX_ALL. Les deux autres valeurs autorisées sont utiles de manière occasionnelle, lorsqu'une collision particulière est attendue, et que vous voulez "sauter" ou préfixer la clé posant problème. Le fragment de code qui suit illustre l'utilisation de la valeur EXTR_PREFIX_ALL. Observez la manière dont sont formés les noms des variables créées : préfixe-caractère de soulignement-nom de la clé.

    $array = array ("key1" => "Valeur_1", "key2" => "Valeur_2", "key3" => "Valeur_3") ;

    extract ($array, EXTR_PREFIX_ALL, "MomPrefixe") ;

    echo "$MomPrefixe_key1 $MomPrefixe_key2 $MomPrefixe_key3" ;

Là encore, le résultat obtenu à l'exécution des lignes de codes précédents est Valeur_1, Valeur_2, Valeur_3.

Notez que pour la fonction extract() puisse extraire un élément, il faut que la clé de l'élément soit un nom de variable valide : les clés dont les noms commencent par des chiffres, ou qui contiennent des espaces, ne peuvent être extraites.

Cette troisième leçon décrite certaines fonctions de manipulation de tableau qui apparaissent les plus utiles. Certaines fonctions également n'y sont volontairement pas abordées. Nous vous invitons à rechercher sur le Net.

Pour l'instant, nous terminons cette troisième leçon et nous verrons dans la prochaine, les manipulations de chaînes et d'expressions régulières, etc. ...



  Cliquez ici pour la leçon suivante ou dans le sommaire prévu à cet effet.   Haut de page
  Page précédente   Page suivante







Nombre de pages vues, à partir de cette date : le 23 MAI 2019

compteur de visite

    




Envoyez un courrier électronique à Administrateur Web Société pour toute question ou remarque concernant ce site Web. 

Version du site : 10. 5. 14 - Site optimisation 1280 x 1024 pixels - Faculté de Nanterre - Dernière modification : 19 MAI 2019.   

Ce site Web a été Créé le, 14 Mars 1999 et ayant Rénové, en MAI 2019.