Comment vérifier l'existence d'une valeur dans un tableau php. PHP: array_search - recherche rapide de tableau php recherche de tableau par valeur

Trouver une valeur dans un tableau est requis dans presque toutes les applications PHP, scripts qui fonctionnent avec des données, pour lesquels il existe de nombreuses façons et fonctions spéciales. Selon la tâche et le type de recherche, vous devez utiliser certains outils, en tenant compte de leurs fonctionnalités, de leur rapidité d'exécution et de leur facilité d'utilisation. Ensuite, nous nous familiariserons avec les fonctions PHP pour trouver des éléments dans un tableau, les constructions et méthodes possibles, et découvrirons également quel moyen est le plus rapide.

Fonctions de recherche de tableau:
array_search- sert à rechercher une valeur dans un tableau. En cas de succès, il renvoie la clé de la valeur souhaitée ; si rien n'est trouvé, il renvoie FALSE. Avant PHP 4.2.0, array_search() renvoyait NULL en cas d'échec plutôt que FALSE.

La syntaxe de la fonction est mixed array_search (mixed needle, array haystack [, bool strict]).

foreach (expression_array comme valeur $)
déclaration
foreach (array_expression as $ key => $ value)
déclaration

Un exemple d'utilisation d'une fonction avec la construction foreach pour trouver un élément de tableau, renvoie TRUE en cas de succès

Syntaxe de construction
tandis que (expr)
déclaration

Renvoie la clé de l'élément du tableau en cas de succès

A partir du tableau de mesures donné, on peut voir que la fonction array_search, affiche les meilleurs résultats lors de la recherche de petits et de grands tableaux. Dans le même temps, le temps de recherche à l'aide de boucles augmente considérablement en fonction de la taille du tableau.

(PHP 4> = 4.0.5, PHP 5)

array_search - Recherche un tableau pour la valeur donnée et renvoie la clé correspondante en cas de succès

La description

mixte array_search(aiguille mixte, tableau botte de foin [, bool strict])

Recherche une aiguille dans une botte de foin et renvoie la clé, si elle est présente dans le tableau, FAUX autrement.

Commenter: Si aiguille est une chaîne, une comparaison sensible à la casse est effectuée.

Commenter: Avant PHP 4.2.0, array_search () en cas d'échec, retourné NULà la place de FAUX .

Si vous passez la valeur VRAI comme troisième paramètre facultatif strict, la fonction array_search () vérifiera également l'aiguille dans le tableau de la botte de foin.

Si l'aiguille apparaît plus d'une fois dans la botte de foin, la première clé trouvée sera retournée. Pour renvoyer les clés de toutes les valeurs trouvées, utilisez la fonction array_keys () avec un paramètre facultatif search_value.

Exemple 1. Exemple d'utilisation array_search () $ array = array (0 => "bleu", 1 => "rouge", 2 => 0x000000, 3 => "vert", 4 => "rouge"); $ key = array_search ("rouge", $ array ); // clé $ = 1; $ key = array_search ("vert", $ array); // clé $ = 2; (0x000000 == 0 == "vert") $ key = array_search ("vert", $ array, true); // clé $ = 3; ?>

Attention

Cette fonction peut retourner sous forme de valeur booléenne FAUX, et une valeur non booléenne qui est convertie en FAUX, par exemple 0 ou "". Pour plus d'informations, consultez la section Type booléen. Utilisez l'opérateur === pour tester la valeur de retour de cette fonction.

L'une des principales opérations lorsque vous travaillez avec des tableaux est de trouver une valeur spécifique. C'est à cela que sert la fonction array_search() de PHP. Il est capable de gérer à la fois des collections unidimensionnelles et associatives, renvoyant la clé de la valeur souhaitée si elle est trouvée dans le tableau.

Syntaxe

La description formalisée de la fonction array_search() en PHP est la suivante :

Tableau_recherche mixte (valeur mixte, tableau $ collection [, bool strict])

Paramètres d'entrée:

• $ collection - le tableau à rechercher ;
• value - la valeur souhaitée de tout type;
• strict est un indicateur booléen facultatif qui définit un mécanisme de comparaison sensible au type strict.

Mécanisme de travail

La fonction array_search() de PHP compare la valeur une par une avec toutes les valeurs du tableau de collection. Par défaut, la comparaison est effectuée sans tenir compte des types des opérandes. Ce paramètre peut être modifié en définissant l'indicateur strict sur TRUE. Les comparaisons de chaînes sont sensibles à la casse.

Si une correspondance est trouvée, la clé correspondant à l'élément trouvé est renvoyée et la fonction est terminée. Par conséquent, il ne peut pas détecter plusieurs occurrences de la valeur souhaitée dans le tableau avec son aide.

Si aucune correspondance n'est trouvée, la fonction renverra la valeur booléenne FALSE.

Vous devez tester le résultat renvoyé à l'aide de l'opérateur d'égalité stricte (===). Ceci est important car la fonction peut renvoyer une valeur convertie en FALSE, telle que 0 ou une chaîne vide.

Exemples d'utilisation

Exemple 1. Lorsqu'un tableau multidimensionnel est passé à la fonction PHP array_search(), le résultat de l'opération sera la clé de l'élément requis.

"hiver", "saison2" => "printemps", "saison3" => "été", "saison4" => "automne"); $ result1 = array_search ("hiver", $ array); $ result2 = array_search ("été", $ array); $ result3 = array_search ("avril", $ array); ?>

Dans cet exemple, la variable $ result1 sera définie sur "season1", $ result2 sera égal à "season3", et $ result3 sera défini sur la valeur booléenne FALSE, car la chaîne "avril" n'apparaît pas dans l'original déployer.

Exemple 2. La fonction PHP array_search() peut également traiter un tableau à une dimension, en considérant ses clés comme les prochains indices numériques dans l'ordre.

La variable $ result se verra attribuer la valeur 1, selon l'index de l'élément "hunter" dans le tableau $.

Exemple 3. Erreur possible lors de l'analyse du résultat.

"Washington", 1 => "Adams", 2 => "Jefferson", 3 => "Madison", 4 => "Monroe"); $ result = array_search ("Washington", $ presidents); si (!$ résultat) (écho "G. Washington n'était pas le premier président des USA" ;)?>

Ainsi, sans vérifier le résultat par stricte égalité, vous pouvez obtenir un message inattendu selon lequel George Washington n'était pas le premier président des États-Unis.

Exemple 4. Seule la clé de la première correspondance trouvée est renvoyée.

Malgré le fait que la valeur souhaitée apparaît trois fois dans le tableau, la fonction ne renverra que le premier résultat trouvé - 0. Pour rechercher plusieurs correspondances, il est recommandé d'utiliser la fonction PHP array_keys().

La programmation est syntaxe et sémantique. Le premier est déterminé par les règles du langage, le second est déterminé par l'expérience du développeur. En ce qui concerne les tableaux, le développeur peut soumettre la syntaxe à la sémantique. Ce n'est pas encore un objet, mais ce n'est plus un tableau au sens traditionnel du terme. PHP permet de créer des tableaux à partir de variables de différents types, y compris elles-mêmes. Un élément d'un tableau peut être une fonction, c'est-à-dire la possibilité de charger un tableau avec un vrai algorithme, une vraie signification.

La syntaxe est stable, mais varie d'une version à l'autre et peut ne pas toujours être compatible vers le haut. La portabilité des programmes est une réalisation bien oubliée du siècle dernier. La sémantique se développe et peut toujours être appliquée non seulement dans n'importe quelle version de n'importe quelle langue ; c'est devenu une tradition d'utiliser des constructions syntaxiques pour exprimer ce qui n'était même pas prévu par les règles de la langue. En utilisant les tableaux comme exemple, cela peut être compris le plus simplement.

Construire des tableaux

Les tableaux PHP ont une syntaxe et des fonctionnalités pratiques. Cela peut être décrit à l'avance, mais il est souvent pratique de créer des tableaux à la volée selon les besoins.

public $ aNone = array (); // le tableau est décrit et ne contient rien

public $ aFact = array ("avocat", "pêche", "cerise"); // ce tableau a trois éléments

Création d'un tableau en cours de vérification d'une condition :

$ cSrcLine = "ligne de données analysées" ;

pour ($ i = 0; $ i<13; $i++) {

if (checkFunc ($ cSrcLine, $ cUserLine) (

$ unRésultat = "Oui" ; // ajouter au tableau PHP

$ aRésultat = "Non" ;

À la suite de l'exécution de cet exemple, un tableau de 13 éléments sera créé, dont les valeurs ne seront que les chaînes "Oui" ou "Non". Les éléments recevront des indices de 0 à 12. Le même effet peut être obtenu en écrivant préalablement le "futur" tableau PHP dans une chaîne :

$ cFutureArray = "";

pour ($ i = 0; $ i<13; $i++) {

$ cUserLine = inputUserLine (); // entrer quelque chose

si ($ i> 0) ($ cFutureArray. = "|";)

if (checkFunc ($ cSrcLine, $ cUserLine) ($ cFutureArray. = "Oui" ;

) else ($ cFutureArray. = "Non";)

$ aRésultat = exploser ("|", $ cFutureArray);

Tableaux multidimensionnels

De nombreux systèmes de gestion de site (SMS) utilisent massivement les baies. D'une part, c'est une bonne pratique, d'autre part, elle la rend difficile à appliquer. Même si l'auteur comprend la doctrine du "PHP-array-in-array", alors il ne faut pas en abuser : non seulement le développeur devra s'habituer à la notation complexe. Souvent, après un certain temps, le créateur lui-même se souviendra longtemps de ce qu'il a écrit au début :

"view_manager" => tableau (41, "template_path_stack" => tableau (__ DIR__. "/../view",),

"router" => array ("routes" => array ("sayhello" => array (

"type" => "Zend\Mvc\Router\Http\Literal",

"options" => array ("route" => "/ sayhello", "defaults" => array (

"controller" => "Helloworld \ Controller \ Index", "action" => "index",))))),

"controllers" => array ("invokables" => array (

"Helloworld \ Controller \ Index" => "Helloworld \ Controller \ IndexController"))

Il s'agit de l'exemple de pratique PHP Array in Array de ZF 2. Pas très inspirant au début, mais cela fonctionne et fait peut-être le succès du framework (exemple de ZendSkeletonApplication / module / Helloworld / config / module.config.php).

Le tableau est une construction de données importante lors de la conception et du développement. Sa version multidimensionnelle était autrefois populaire, mais au fil du temps, il reste un besoin pour des tableaux d'un maximum de deux ou trois dimensions. C'est plus simple et plus compréhensible, mais du point de vue du professionnalisme, quand quelque chose commence à se multiplier, cela signifie que quelque chose ne va pas dans l'énoncé du problème ou dans le code.

Simple, accessible et compréhensible

Lors de la création d'un tableau dans un tableau en php, il est préférable de se limiter à deux ou trois niveaux. Malgré la stabilité et la fiabilité, PHP fait des erreurs lors du traitement de la syntaxe. Vous pouvez supporter cela, ayant un bon éditeur de code, habitué à compter avec précision les parenthèses et les virgules. Cependant, PHP ne contrôle pas les types de données (c'est le karma de la programmation moderne) et permet au développeur de s'entraîner aux erreurs sémantiques.

La règle pour contrôler les types de variables ou vos propres idées pour convertir la sémantique en syntaxe est souvent un luxe inacceptable. Il s'agit d'une perte de vitesse de script, de lisibilité du code, ... donc, la facilité de codage est toujours essentielle.

PHP a un inconvénient important : lorsqu'une ambiguïté survient, le script se bloque tout simplement. Tous les débogueurs ne traitent pas les imprévus, et beaucoup dépend de l'expérience et de l'intuition du développeur. Plus l'algorithme est simple, plus l'information structurée est accessible, plus il y a de chances de trouver une erreur ou de ne pas l'admettre du tout.

En règle générale, lorsque les premiers tableaux sont apparus, les options de données étaient proposées sous la forme de structures - une tentative maladroite de créer quelque chose à partir de divers types de données. Les premiers ont survécu et ont acquis une nouvelle syntaxe efficace, tandis que les seconds appartiennent à l'histoire.

Tableaux simples et associatifs

Un enregistrement de tableau à deux dimensions est une autre paire de crochets "[" et "]", par exemple : $ aSrcData signifie une référence à un élément de tableau inclus dans le tableau $ aSrcData. Il n'y a aucune obligation en PHP de déclarer les données à l'avance. Toute information déclarée peut toujours être vérifiée pour l'existence.

Il est très efficace de créer quelque chose uniquement lorsque cela est nécessaire, sous la forme sous laquelle il était nécessaire, et de le détruire lorsqu'il n'est plus nécessaire. En utilisant des noms sensés comme clés (indices), vous pouvez obtenir des constructions lisibles qui sont significatives dans le contexte de la place actuelle dans l'algorithme :

$ aAnketa ["nom"] = "Ivanov";
$ aAnketa ["âge"] = 42 ;
$ aAnketa ["travail"] = "Directeur" ;
$ aAnketa ["actif"] = vrai;
$ aTable = $ aAnketa;

$ aAnketa ["nom"] = "Petrov";
$ aAnketa ["âge"] = 34 ;
$ aAnketa ["travail"] = "Gestionnaire";
$ aAnketa ["actif"] = vrai;
$ aTable = $ aAnketa;

$ aAnketa ["nom"] = "Afanasiev";
$ aAnketa ["âge"] = 28 ;
$ aAnketa ["travail"] = "Ouvrier" ;
$ aAnketa ["actif"] = faux ;
$ aTable = $ aAnketa;

$ sOne. = imploser (";", $ aTable). "
"; // deuxième tableau PHP à chaîne
$ sOne. = $ aTable ["travail"]; // accès à un élément du deuxième tableau

Le résultat de cet exemple (le premier tableau est normal, les clés qu'il contient commencent à 0, le deuxième tableau est associatif, il a quatre clés : "name", "age", "work", "active") :

$ sOne = "Petrov ; 34 ; Manager ; 1
Directeur";

Dans cet exemple simple, vous pouvez voir comment le questionnaire créé peut être appliqué à tous les employés. Vous pouvez créer un tableau de salariés avec des index par matricule et, si vous avez besoin d'un salarié en particulier, le sélectionner par matricule.

Si l'organisation a des divisions, ou des travailleurs saisonniers, ou doit séparer les retraités qui travaillent ... le tableau PHP dans la construction de tableau est très pratique, mais vous ne devriez jamais vous laisser emporter par la dimensionnalité. Deux ou trois dimensions sont la limite pour une solution efficace.

Clés pour travailler avec des tableaux

Si auparavant la manière dont tout était organisé importait, ces dernières années, les traditions de l'ère binaire, lorsqu'un programmeur voulait savoir exactement comment les éléments d'un tableau étaient stockés et y accéder directement, étaient complètement oubliées. Il existe de nombreux encodages de caractères qui occupent plus d'un octet en mémoire. Le mot "bit" ne peut désormais être trouvé que dans les opérations de recherche de bits, mais la recherche dans un tableau PHP est un sujet distinct. L'accès aux éléments peut être simple et associatif. Dans le premier cas, les éléments du tableau (ayant l'un des types disponibles en PHP) sont numérotés 0, 1, 2, ... Dans le second cas, le programmeur spécifie son propre indice, souvent appelé la "clé" de accéder à la valeur souhaitée.

$ aLigne ["fruit"] = "orange"; // ici PHP array key = "fruit"

ou (pour que tout soit correct, en respectant l'encodage de la page et du code) :

$ aLigne = iconv ("UTF-8", "CP1251", "orange");

Lors de l'ajout d'une nouvelle valeur au tableau $ aLine :

$ aLigne = iconv ("UTF-8", "CP1251", "pêche");
$ aLigne = iconv ("UTF-8", "CP1251", "concombre");
$ aLigne = iconv ("UTF-8", "CP1251", "aubergine");

à la suite de l'exécution de la boucle :

foreach ($ aLine as $ ck => $ cv) (
$ cOne. = $ ck. "=". $ cv. "
";
}

recevra:

fruit = orange
0 = pêche
légume = concombre
1 = aubergine

Lors de l'ajout des éléments "pêche" et "aubergine", la clé PHP du tableau est formée séquentiellement à partir de 0, et lors de la spécification de sa valeur, elle sera égale à cette valeur.

Supprimer des éléments d'un tableau

Le moyen le plus simple est lors de son traitement. Dans ce cas, par exemple, à la suite de l'exécution de la boucle, le tableau d'origine est analysé et un nouveau est formé, dans lequel les éléments inutiles ne sont tout simplement pas écrits.

Vous pouvez le faire plus facilement. Si on applique au dernier exemple :

unset ($ aLine); // supprime l'élément du tableau PHP

alors le résultat sera :

fruit = orange
légume = concombre
1 = aubergine

Il existe de nombreuses options pour manipuler les éléments du tableau. Par exemple, en utilisant les fonctions : imploser () et éclater (), vous pouvez écrire un tableau PHP dans une chaîne avec un séparateur et l'analyser dans un autre tableau en utilisant un séparateur différent.

Pour supprimer simplement un tableau entier en PHP, écrivez simplement : unset ($ aLine);

C'est assez.

Rechercher dans un tableau

PHP contient des fonctions de recherche spéciales et in_array(), cependant, avant de décider de les utiliser, vous devriez envisager de rechercher vous-même le tableau PHP.

Tout projet a des tableaux construits concrets, en particulier lorsqu'une partie de la sémantique est transférée à la syntaxe et est représentée par un ensemble de clés significatives très spécifiques. Cela vous permet d'effectuer vos propres fonctions de recherche, qui peuvent également être étiquetées de manière significative.

En PHP, vous pouvez appeler des fonctions dont les noms sont déterminés lors de l'exécution du programme. Un exemple très pratique de la bibliothèque PHPWord qui permet de lire et de créer des documents MS Word :

$ elements = array ("Text", "Inline", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Table", "Image", "Objet", "Note de bas de page",
"Note de fin", "CheckBox", "TextBox", "Champ", "Line");

$ fonctions = tableau ();

pour ($ i = 0; $ i< count($elements); $i++) {
$ fonctions [$ i] = "ajouter". éléments $ [$ i] ;
}

En conséquence, le tableau de fonctions $ recevra les valeurs du tableau d'éléments $, c'est-à-dire les noms de fonctions réelles qui effectuent un travail avec des éléments réels du document.

En appelant des fonctions $ sur des éléments $, vous pouvez obtenir une recherche parfaite et des résultats rapides.

Trier les articles

La tâche de tri des données est importante, et PHP propose plusieurs fonctions pour cela : sort(), rsort(), asort(), ksort(), ... Éléments ascendants et descendants, les deux secondes fonctions préservent la relation entre les clés et valeurs. Parfois, il est logique de mélanger les valeurs du tableau de manière aléatoire - shuffle ().

Lorsque vous utilisez des fonctions PHP pour le tri, gardez à l'esprit que les éléments peuvent non seulement être de types différents, mais également ne pas avoir de contenu complètement naturel. Tout d'abord, vous devez faire très attention au tri des chaînes contenant des lettres russes, du tri des dates, ainsi que des nombres écrits dans différents formats.

La meilleure façon d'écrire vous-même la solution parfaite, au moins pendant la phase de test du script, est de trier manuellement. Elle vous aidera à anticiper les situations imprévues.

Tableaux en ligne

Grâce aux fonctions imploser () et exploser (), un tableau peut être facilement transformé en chaîne et renvoyé. Cela vous permet de stocker des données sous une forme compacte et de les développer dans un état pratique selon vos besoins.

Un tableau transformé en chaîne ouvre de nouvelles possibilités. Par exemple, la tâche de trouver des mots-clés dans le texte nécessite que les trouvés ne soient pas ajoutés à nouveau.

$ cSrcLine = "Texte Text ListItemRun TextBox ListItem TextBox CheckBox CheckBox TextBox Footnote";

$ aSrc = éclater ("", $ cSrcLine);
$ cDstLigne = "";

pour ($ i = 0; $ i< count($aSrc); $i++) {
$ cRechercher = "[". $ aSrc [$ i]. "]" ;
if (! is_integer (strpos ($ cDstLine, $ cFind))) (
$ cDstLine. = $ cFind;
}
}
$ aDst = éclater ("] [", $ cDstLine);

$ cOne = imploser (";", $ aDst);

En conséquence, la variable $ cOne ne recevra que les valeurs de la chaîne d'origine qui s'y trouvent une fois : "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Footnote".

La langue russe dans les clés et les valeurs

Il n'est pas recommandé d'utiliser quoi que ce soit lié aux encodages nationaux dans les constructions syntaxiques. La langue russe, comme toutes les autres langues dont les caractères vont au-delà de a-z, ne créera pas de problèmes dans la zone de données, mais pas dans la syntaxe du code. Parfois, même une simple tâche PHP « imprimer un tableau sur une imprimante ou sur un écran » conduira à « krakozyabra », et le plus souvent, elle arrêtera simplement le script.

PHP est un langage fidèle et tolérant les encodages nationaux, mais il existe de nombreuses situations où la quantité de travail effectué doit être refaite simplement parce qu'une valeur clé apparaît au bon endroit et au bon moment, ce qui ne sera pas possible reconnaître.

Syntaxe PHP et environnement de langage

Il faut se rappeler que la syntaxe PHP est une chose, mais les constructions de cette syntaxe « traitent » d'autres applications, avec le système d'exploitation, avec des options matérielles. Les options sont nombreuses, il n'est jamais possible de tout prévoir.

La règle "il n'y a que du code dans le code, et toutes les informations sont à l'entrée, à l'intérieur et à la sortie" aidera à éviter les surprises inattendues. La valeur PHP dans le tableau peut être "russe", mais la clé doit être syntaxiquement correcte non seulement du point de vue de la langue donnée, mais aussi du point de vue de son environnement.

J'utilise la fonction array_search () pour rechercher des valeurs dans un tableau depuis assez longtemps, car j'ai entendu et lu à plusieurs reprises que cela fonctionnait nettement plus rapidement que la recherche dans un tableau en boucle, mais je ne savais pas combien c'est plus rapide. Enfin, nous avons mis la main sur la vérification et le comptage.

J'ai comparé la vitesse de recherche dans un tableau à l'aide de cette fonction avec l'itération habituelle sur un tableau dans les boucles foreach et while. À 10-100 éléments de tableau, la différence est imperceptible et le temps est si court qu'ils peuvent être négligés. Mais pour les grandes baies, la différence s'est avérée très significative. Avec une augmentation de la taille du tableau d'un ordre de grandeur, le temps de recherche a également augmenté de manière significative. Avec cent mille éléments, la vitesse de foreach est tombée à 0,013 seconde, et tandis que - à 0,017, tandis que array_search () a également ralenti, mais est restée un ordre de grandeur plus rapide - 0,004 seconde. Pour un gros script qui fonctionne avec de grands tableaux, remplacer la recherche dans une boucle par une recherche utilisant array_search() ne sera pas du tout une "optimisation aux puces".

À cet égard, j'ai rappelé une discussion récente avec l'un de mes collègues de travail - à savoir si un programmeur doit connaître toutes ces fonctions intégrées du langage, ou si un "état d'esprit de programmeur" et des connaissances générales suffisent. Sans entrer dans une discussion sur cet état d'esprit même, je pense que vous avez encore besoin de connaître les fonctions, peut-être pas toute la syntaxe en détail, mais au moins quelles fonctions sont là et ce qu'elles peuvent en termes généraux.

UPD : vous avez besoin d'un état d'esprit de programmeur, vous en avez besoin aussi ! Et la pleine conscience avec la mémoire ne fera pas de mal (inspirée du break and range :)

Sous l'habrakat, le code de script utilisé pour calculer le temps :

$ masse = 100000 ; // le nombre de valeurs dans le tableau dans lequel on va chercher
$ recherche = 50 000 ; // on va chercher cette valeur dans le tableau
$ first_result = tableau (); // tableau de résultats, pour calculer la valeur moyenne de la première option
$ second_result = tableau (); // tableau de résultats, pour calculer la valeur moyenne de la deuxième option
$ troisième_résultat = tableau (); // tableau de résultats, pour calculer la moyenne de la troisième option

// créer et remplir le tableau
$ test_array = plage (0, $ masse-1); // merci SelenIT))

/*
$ test_array = tableau ();
pour ($ i = 0; $ i<$mass; $i++)
{
$ tableau_test = $ i;
}
*/

// boucle de calcul des valeurs moyennes
pour ($ d = 0; $ d<30; $d++) {

// *************** Recherche avec array_search *******************

// Commencer à compter le temps
$ time_start = microtime (1) ;
// Chercher
$ key = array_search ($ search, $ test_array, true);
// si trouvé
if ($ key! == FALSE) // c'est nécessaire! == et non! =, car le numéro du premier élément est 0
{
echo $ test_array [$ clé];
}
$ time_end = microtime (1) ;
// fin du comptage des temps

// écrit dans le tableau de valeurs
$ first_result = $ time_end - $ time_start;

// *************** Recherche d'un tableau avec une boucle foreach *******************

// Commencer à compter le temps
$ time_start = microtime (1) ;
// recherche lui-même
foreach ($ test_array as $ ta)
{
si ($ ta == $ recherche)
{
echo $ ta;
Pause;
}
}
$ time_end = microtime (1) ;
// fin du comptage des temps

// écrit dans le tableau de valeurs
$ second_result = $ time_end - $ time_start;

// *************** Recherche dans un tableau avec une boucle while *******************

// Commencer à compter le temps
$ time_start = microtime (1) ;

// déterminer la longueur du tableau
$ count = count ($ test_array);
$j = 0 ;
// recherche lui-même
tandis que ($ j<$count)
{
if ($ test_array [$ j] == $ recherche) // si trouvé
{
echo $ tableau_test [$ j];
Pause;
}
$j++;
}
$ time_end = microtime (1) ;
// fin du comptage des temps

// écrit dans le tableau de valeurs
$ third_result = $ time_end - $ time_start;
}

$ srednee1 = array_sum ($ first_result) / count ($ first_result);
$ srednee2 = array_sum ($ second_result) / count ($ second_result);
$ srednee3 = array_sum ($ third_result) / count ($ third_result);

Printf ("premier code exécuté en : % .7f secondes en moyenne", $ srednee1) ;
printf ("le deuxième code exécuté en : % .7f secondes en moyenne", $ srednee2) ;
printf ("troisième code exécuté en : % .7f secondes en moyenne", $ srednee3) ;

// résultat:
// le premier code est exécuté en moyenne en : 0,0000295 secondes
// le deuxième code est exécuté en moyenne en : 0,0153386 secondes
// le troisième code est exécuté en moyenne en : 0,0226001 secondes