Php trouve la clé par valeur. PHP array_search : recherche une valeur dans un tableau. Vérifier la présence d'une valeur dans un tableau. fonction in_array()

Souvent, lors de l'écriture de code, vous devez vérifier si une valeur d'élément particulière existe dans un tableau. Aujourd'hui, nous examinerons plusieurs fonctions avec lesquelles vous pouvez le faire.

Vérifier la présence d'une valeur d'élément dans un tableau peut être utilisé pour résoudre divers problèmes de programmation.

Nous pouvons obtenir différents tableaux de notre base de données et vérifier la présence d’une valeur particulière. La valeur souhaitée peut également être transmise par l'utilisateur de notre script lorsque, par exemple, il recherche quelque chose. Sur la base des résultats d'une telle recherche, vous pouvez effectuer certaines actions. Tout dépend de la tâche spécifique à accomplir, cependant, les algorithmes de recherche d'une valeur dans un tableau seront les mêmes.

Aujourd'hui, nous allons les examiner.

Vérifier la présence d'une valeur dans un tableau. fonction in_array()

Fonction dans_array() nous permettra de vérifier la présence de n’importe quelle valeur dans le tableau.

Si le résultat de son travail est réussi et que l'élément souhaité est trouvé dans le tableau, alors la fonction retournera vrai, c'est la vérité."

La fonction prend 2 paramètres obligatoires :<Что ищем>Et<Где ищем>.

Il peut également prendre un paramètre facultatif supplémentaire :<Тип данных>. Si ce troisième paramètre facultatif est défini sur vrai, le type de données est également vérifié. Autrement dit, « 2 » et 2 ne seront pas la même chose. Dans le premier cas c’est une chaîne, dans le second c’est un nombre. Et puis toute la fonction dans_array() ne renverra pas de valeur vrai.

Vous devez également vous rappeler que la fonction effectue des comparaisons sensibles à la casse.

Voyons comment fonctionne cette fonction à l'aide d'un exemple simple.
Nous avons besoin d'une sorte de tableau. A l'aide de la fonction, nous vérifierons la présence d'une valeur dans le tableau et afficherons un message spécifique à l'écran.

Après exécution, la fonction affichera le message « Oui », puisque l'élément « Marina » est présent dans notre tableau.

Remplacez le premier paramètre de la fonction par un élément inexistant et vous verrez le message « Non ».

Vérifier la présence d'une valeur dans un tableau. fonction array_search()

Il y a une autre fonction de recherche tableau_recherche(), qui, contrairement au précédent, renverra la clé de l'élément trouvé. Ceci, à son tour, peut être utile si nous travaillons avec un tableau associatif.

La fonction prend les mêmes paramètres que la précédente. Dans ce cas, le troisième paramètre est également facultatif.

Voyons comment il peut être utilisé lorsque vous travaillez avec un tableau associatif.

"octobre","argent"=>200,"name"=>"Mila"); $key = array_search("Mila",$Mass1); if($clé) echo $clé; ?>

Dans ce cas, nous verrons « nom » sur l'écran, c'est-à-dire la clé de l'élément souhaité avec la valeur « Mila ».

Ces deux fonctions sont très similaires et ne diffèrent essentiellement que par la valeur de retour.

Trouver une valeur dans un tableau multidimensionnel

Mais que se passe-t-il si nous travaillons avec un tableau multidimensionnel ? Après tout, ses éléments seront d'autres tableaux.

Ici, les algorithmes dont nous avons déjà parlé ne fonctionneront pas.

Ce n'est en fait pas si compliqué, il suffit de compliquer un peu tout le mécanisme et d'utiliser une boucle, par exemple, pour chaque(), qui fonctionne très bien avec les tableaux.

Disons que nous avons un tableau multidimensionnel. Ses valeurs immédiates sont d'autres tableaux pouvant contenir la valeur souhaitée de l'élément.

Tout ce que vous avez à faire est de parcourir les éléments du tableau d'origine pour chaque(). Chaque élément de ce tableau sera analysé en une clé ($key) et une valeur ($value).

La valeur sera chacun des tableaux situés à l’intérieur du tableau multidimensionnel principal. Nous travaillerons avec ces valeurs, en recherchant dans chaque tableau interne la valeur d'élément souhaitée.

S'il est trouvé, nous afficherons un message indiquant qu'un tel élément existe, et sinon, nous afficherons un autre message indiquant qu'un tel élément n'existe pas.

Voyons tout cela avec un exemple de code :

"anna","id"=>234); $Mass2 = array("name"=>"anton","id"=>24); $Mass2 = array("name"=>"ivan","id"=>007); foreach($Mass2 as $key => $value) ( $name .= in_array("ivan",$value); ) if($name) echo "OK ! Élément ici !"; else echo "Aucun élément have!"; ?>

Comme vous pouvez le voir, nous déclarons d’abord le tableau multidimensionnel lui-même.

De plus, ici, vous devez écrire non seulement un signe égal, mais « .= ».

Ceci est fait pour que la variable $name ne soit pas écrasée à chaque itération, mais soit complétée. Après tout, si à la première itération un élément est trouvé et que la valeur « true » est écrite dans la variable $name, mais qu'à la deuxième itération (c'est-à-dire dans le deuxième tableau interne), la valeur souhaitée de l'élément n'est pas présente , alors la valeur de la variable $name sera simplement écrasée et, à la fin, nous n'obtiendrons tout simplement pas le résultat correct.

Comme vous l'avez compris, le résultat de ce code sera le message « OK ! L'élément est là !

Essayez de remplacer l'élément que vous recherchez par un élément inexistant et vous verrez le message « Aucun élément n'est disponible ! »

Bien entendu, lorsqu'un certain élément est trouvé ou introuvable, nous ne pouvons pas simplement afficher des messages, mais effectuer d'autres actions. Tout dépend de ce que vous devez faire. Par exemple, si la valeur souhaitée se trouve dans le tableau, vous pouvez donner à l'utilisateur des informations spécifiques, etc.

C'est tout pour aujourd'hui! J'espère que la leçon était claire et utile ! Essayez d'écrire vous-même un code similaire pour tout comprendre.

Et j'attends vos commentaires.

Partagez la leçon avec vos amis en utilisant les boutons sociaux. réseaux situés en dessous. Et abonnez-vous également aux mises à jour du blog. Nous avons déjà rassemblé une assez bonne archive de matériel utile, et elles ne feront que se reconstituer !

Je vous souhaite une programmation réussie !

Anna Kotelnikova était avec vous !

(PHP 4 >= 4.0.5, PHP 5)

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

Description

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

Recherche dans la botte de foin la valeur de l'aiguille et renvoie la clé si elle est présente dans le tableau, FAUX sinon.

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

Commentaire: Jusqu'à PHP 4.2.0, tableau_recherche() renvoyé en cas d'échec NUL au lieu de FAUX .

Si vous transmettez la valeur VRAI comme troisième paramètre facultatif à strict , la fonction tableau_recherche() vérifiera également le type d'aiguille dans le tableau de botte de foin.

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

Exemple 1 : exemple d'utilisation tableau_recherche()

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

Attention

Cette fonction peut renvoyer sous forme de valeur booléenne FAUX, une valeur non booléenne convertie en FAUX, par exemple 0 ou "". Pour plus d’informations, consultez la section Type booléen. Utilisez l'opérateur === pour vérifier la valeur renvoyée par cette fonction.

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

La syntaxe est stable, mais change de version en version et peut ne pas toujours être compatible même de bas en haut. La portabilité des programmes est une réalisation bien oubliée du siècle dernier. La sémantique évolue 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 du langage. Cela peut être plus facilement compris en utilisant l’exemple des tableaux.

Construire des tableaux

Array en PHP a 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 = tableau(); // le tableau est décrit et ne contient rien

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

Créer un tableau en vérifiant une condition :

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

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

if (checkFunc($cSrcLine, $cUserLine) (

$aResult = "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 seront uniquement les chaînes « Oui » ou « Non ». Les éléments recevront des index de 0 à 12. Le même effet peut être obtenu en écrivant d'abord le « futur » tableau PHP dans une chaîne :

$cFutureArray = "";

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

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

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

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

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

$aResult = exploser("|", $cFutureArray);

Tableaux multidimensionnels

De nombreux systèmes de gestion de contenu (CMS) utilisent largement les tableaux. D’une part, c’est une bonne pratique, d’autre part, cela rend son utilisation difficile. Même si l'auteur comprend la doctrine du « tableau PHP dans un tableau », il ne doit pas en abuser : il n'y a pas que le développeur qui devra s'habituer à la notation complexe. Souvent, au bout d'un moment, le créateur lui-même se souviendra longtemps de ce qu'il a écrit au début :

"view_manager" => array(41, "template_path_stack" => array(__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",))))),

"contrôleurs" => array("invokables" => array(

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

Ceci est un exemple de la pratique "Tableau PHP dans un tableau" de ZF 2. Pas très inspirant au début, mais cela fonctionne et fait sans doute le succès de ce framework (exemple de ZendSkeletonApplication/module/Helloworld/config/module.config.php) .

Un 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 est resté nécessaire de disposer de tableaux d'un maximum de deux ou trois dimensions. C'est plus simple et plus clair ainsi, et d'un point de vue professionnel, 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 au sein d’un tableau en PHP, il est préférable de se limiter à deux ou trois niveaux. Malgré la stabilité et la fiabilité de PHP, il commet des erreurs lors du traitement des structures syntaxiques. Vous pouvez supporter cela si vous disposez d'un bon éditeur de code et si vous vous habituez à 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 pratiquer des erreurs sémantiques.

La règle consistant à contrôler les types de variables ou vos propres idées pour transformer la sémantique en syntaxe est souvent un luxe inabordable. Il s'agit d'une perte de vitesse de script, de lisibilité du code, ... car la simplicité dans le codage est toujours essentielle.

PHP a une caractéristique négative importante : en cas d'incertitude, le script se bloque tout simplement. Tous les débogueurs ne sont pas capables de gérer des circonstances imprévues, et cela dépend beaucoup de l'expérience et de l'intuition du développeur. Plus l'algorithme est simple, plus les informations sont structurées et plus les chances de détecter une erreur ou de l'éviter sont grandes.

Il est caractéristique que lorsque les premiers tableaux sont apparus, des variantes de données ont été proposées sous forme de structures - une tentative maladroite de créer quelque chose à partir de différents types de données. La première a survécu et a acquis une nouvelle syntaxe efficace, tandis que la seconde est devenue une histoire.

Tableaux simples et associatifs

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

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

$aAnketa["nom"] = "Ivanov";
$aAnketa["âge"] = 42;
$aAnketa["work"] = "Réalisateur";
$aAnketa["actif"] = vrai ;
$aTable = $aAnketa ;

$aAnketa["name"] = "Petrov";
$aAnketa["âge"] = 34;
$aAnketa["work"] = "Gestionnaire";
$aAnketa["actif"] = vrai ;
$aTable = $aAnketa ;

$aAnketa["name"] = "Afanassiev";
$aAnketa["âge"] = 28;
$aAnketa["work"] = "Travailleur";
$aAnketa["active"] = faux ;
$aTable = $aAnketa ;

$sOne .= imploser ("; ", $aTable) . "
"; // deuxième tableau PHP dans une 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 : "nom", "âge", "travail", "actif") :

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

Cet exemple simple montre comment un questionnaire créé peut être appliqué à tous les employés. Vous pouvez créer un tableau d'employés avec des index par matricule et, si vous avez besoin d'un employé spécifique, le sélectionner par matricule.

Si l'organisation a des divisions, ou s'il y a des travailleurs saisonniers, ou si vous devez identifier séparément les retraités actifs, ... la conception « tableau PHP dans un tableau » est très pratique, mais vous ne devez jamais vous laisser emporter par la dimension. Deux ou trois dimensions constituent la limite pour une solution efficace.

Clés pour travailler avec des tableaux

Si auparavant la façon dont tout était organisé importait, alors ces dernières années, les traditions de l'ère binaire, lorsque le programmeur voulait savoir exactement comment les éléments d'un tableau étaient stockés et voulait y avoir un accès direct, ont été complètement oubliées. De nombreux codages de caractères sont apparus et 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 n'importe lequel des types disponibles en PHP) sont numérotés 0, 1, 2, ... Dans le second cas, le programmeur spécifie son propre index, souvent appelé « clé », pour accéder la valeur souhaitée.

$aLine["fruit"] = "orange"; // ici clé du tableau PHP = "fruit"

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

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

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

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

suite à l'exécution de la boucle :

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

sera reçu :

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

La clé du tableau PHP lors de l'ajout des éléments « pêche » et « aubergine » 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 d'une boucle, le tableau d'origine est analysé et un nouveau est formé, dans lequel les éléments inutiles ne sont tout simplement pas écrits.

Cela pourrait être plus facile. Si l'on s'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 : implode() et explosive(), vous pouvez écrire un tableau PHP dans une chaîne avec un délimiteur et l'analyser à nouveau dans un autre tableau en utilisant un délimiteur 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 spéciales de recherche et in_array(), mais avant de décider de les utiliser, vous devriez envisager d'effectuer vous-même des recherches dans les tableaux PHP.

Tout projet possède des tableaux construits spécifiques, 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 le nom est déterminé 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("Texte", "Inline", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Table", "Image", "Objet", "Note de bas de page",
"Endnote", "CheckBox", "TextBox", "Field", "Line");

$fonctions = tableau();

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

En conséquence, le tableau $functions recevra les valeurs du tableau $elements, c'est-à-dire les noms des fonctions réelles qui fonctionnent avec de vrais éléments de document.

En appelant $functions sur $elements, vous pouvez obtenir une recherche parfaite et des résultats rapides.

Trier les éléments

La tâche de trier les données est importante et PHP propose plusieurs fonctions pour cela : sort(), rsort(), asort(), ksort(), ... Éléments ascendants et descendants, les deux secondes fonctions stockent les relations entre 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, n'oubliez pas que les éléments peuvent non seulement avoir des types différents, mais aussi un contenu pas entièrement naturel. Tout d'abord, vous devez faire très attention au tri des chaînes contenant des lettres russes, au tri des dates ainsi qu'aux nombres écrits dans différents formats.

La meilleure façon d'écrire vous-même une solution idéale, au moins au stade du test du script, est le tri manuel. Cela aidera à anticiper les situations imprévues.

Tableaux de chaînes

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

Un tableau converti en chaîne ouvre de nouvelles possibilités. Par exemple, la tâche de recherche de mots-clés dans un texte nécessite que ce qui est trouvé ne soit pas ajouté à nouveau.

$cSrcLine = "Texte Texte ListItemRun TextBox ListItem TextBox Case à cocher CheckBox TextBox Footnote";

$aSrc = exploser(" ", $cSrcLine);
$cDstLigne = "";

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

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

Par conséquent, la variable $cOne recevra uniquement les valeurs de la chaîne source qui y apparaissent une fois : "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Footnote".

La langue russe en clés et significations

Il n'est pas recommandé d'utiliser quoi que ce soit lié aux codages nationaux dans les structures syntaxiques. Le russe, comme toutes les autres langues dont les caractères s'étendent au-delà de a-z, ne créera pas de problèmes, étant dans la région des données, mais pas dans la syntaxe du code. Parfois, même une simple tâche en PHP « envoyer un tableau à l'imprimante ou à l'écran » entraînera des « bugs fous », et le plus souvent le script s'arrêtera simplement.

PHP est un langage fidèle et tolère les encodages nationaux, mais il existe de nombreuses situations dans lesquelles la quantité de travail effectuée doit être refaite uniquement parce qu'une valeur clé apparaît au bon endroit et au bon moment, ce qui n'est pas possible. reconnaître.

Syntaxe PHP et environnement linguistique

Il ne faut pas oublier que la syntaxe PHP est une chose, mais les constructions de cette syntaxe « traitent » d'autres applications, avec le système d'exploitation, avec les 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, mais il y a toutes sortes d'informations à l'entrée, à l'intérieur et à la sortie » permettra d'éviter les surprises imprévues. Une valeur PHP dans un tableau peut être « russe », mais sa clé doit être syntaxiquement correcte non seulement du point de vue de la langue donnée, mais également du point de vue de son environnement d'exploitation.

L'une des opérations principales lorsque l'on travaille avec des tableaux consiste à rechercher une valeur spécifique. La fonction PHP array_search() est conçue pour cela. Il est capable de traiter des collections unidimensionnelles et associatives, en renvoyant la clé de la valeur recherchée si elle est trouvée dans le tableau.

Syntaxe

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

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

Paramètres d'entrée:

$collection - le tableau dans lequel la recherche sera effectuée ;
valeur - la valeur souhaitée de n'importe quel type ;
strict est un indicateur booléen facultatif qui définit un mécanisme de comparaison strict tenant compte du type.

Mécanisme de fonctionnement

La fonction PHP array_search() compare les valeurs une par une avec toutes les valeurs du tableau de collection. Par défaut, la comparaison est effectuée sans tenir compte des types d'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 cesse de fonctionner. Par conséquent, il ne peut pas être utilisé pour détecter plusieurs occurrences de la valeur souhaitée dans un tableau.

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

Vous devez vérifier 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 la chaîne vide.

Exemples d'utilisation

Exemple 1. Lors du passage d'un tableau multidimensionnel à la fonction PHP array_search(), le résultat du travail sera la clé de l'élément recherché.

"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, $result1 sera défini sur "season1", $result2 sera défini sur "season3" et $result3 sera défini sur la valeur booléenne FALSE car la chaîne "avril" n'apparaît pas dans le tableau source.

Exemple 2. La fonction PHP array_search() peut également traiter un tableau unidimensionnel, en considérant ses clés comme les indices numériques suivants.

La variable $result sera mise à 1, selon l'index de l'élément "hunter" dans le $array.

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

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

Ainsi, sans vérifier le résultat avec une 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.

Même si la valeur que vous recherchez apparaît trois fois dans le tableau, la fonction ne renverra que le premier résultat trouvé - 0. Pour trouver plusieurs correspondances, il est recommandé d'utiliser la fonction PHP array_keys().

J'utilise la fonction array_search() depuis assez longtemps pour rechercher des valeurs dans un tableau, car j'ai entendu et lu à plusieurs reprises que cela fonctionne sensiblement plus rapidement que la recherche dans un tableau en boucle, mais je ne l'ai pas fait je sais à quel point c'est plus rapide. J'ai finalement réussi à le vérifier et à le compter moi-même.

J'ai comparé la vitesse de recherche dans un tableau à l'aide de cette fonction avec la recherche habituelle dans un tableau dans les boucles foreach et while. Sur 10 à 100 éléments du tableau, la différence est imperceptible et le temps est si court qu'il peut être négligé. Mais pour les grands réseaux, la différence s’est avérée assez significative. À mesure que la taille du réseau augmentait d’un ordre de grandeur, le temps de recherche augmentait également de manière significative. Avec cent mille éléments, la vitesse de foreach est tombée à 0,013 seconde, et while - à 0,017, tandis que array_search() a également ralenti, mais est toujours restée un ordre de grandeur plus rapide - 0,004 seconde. Pour un gros script fonctionnant avec de grands tableaux, remplacer une recherche dans une boucle par une recherche utilisant array_search() ne sera pas du tout une « optimisation aux puces ».

À cet égard, je me suis souvenu d'une récente discussion avec un de mes collègues de travail sur la question de 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, je pense qu'il faut quand même connaître les fonctions, peut-être pas toute la syntaxe en détail, mais au moins quelles sont les fonctions et ce qu'elles peuvent faire en termes généraux.

UPD : vous avez aussi besoin de l’état d’esprit d’un programmeur ! Et faire attention à votre mémoire ne fera pas de mal (inspiré par le break et la portée :)

Sous le hack se trouve le code de script utilisé pour calculer l'heure :

$masse=100 000 ; // 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
$third_result=array(); // tableau de résultats pour calculer la valeur moyenne de la troisième option

// crée et remplit le tableau
$test_array = range(0, $mass-1); // merci à SelenIT))

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

// boucle pour calculer les valeurs moyennes
pour ($d=0; $d<30; $d++) {

//*************** Recherche à l'aide de array_search *******************

// Commence à compter le temps
$time_start = microtime(1);
// recherche
$key = array_search($search, $test_array, true);
// si trouvé
if ($key!==FALSE) // il faut!== et non!=, car le numéro du premier élément est 0
{
echo $test_array[$clé];
}
$time_end = microtime(1);
// fin du décompte des temps

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

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

// Commence à compter le temps
$time_start = microtime(1);
// la recherche elle-même
foreach ($test_array comme $ta)
{
si ($ta==$recherche)
{
écho $ta;
casser;
}
}
$time_end = microtime(1);
// fin du décompte des temps

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

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

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

// détermine la longueur du tableau
$count=count($test_array);
$j=0 ;
// la recherche elle-même
tandis que ($j<$count)
{
if ($test_array[$j]==$search) // si trouvé
{
echo $test_array[$j];
casser;
}
$j++;
}
$time_end = microtime(1);
// fin du décompte des temps

// écrit dans un 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 complété en moyenne : %.7f secondes", $srednee1);
printf("second code complété en moyenne en : %.7f secondes", $srednee2);
printf("le troisième code complété en moyenne en : %.7f secondes", $srednee3);

// résultat:
// premier code complété en moyenne : 0,0000295 secondes
// deuxième code complété en moyenne : 0,0153386 secondes
// troisième code complété en moyenne : 0,0226001 secondes