Am folosit funcția array_search() de destul de mult timp pentru a căuta valori într-o matrice, deoarece am auzit și am citit în mod repetat că funcționează considerabil mai rapid decât căutarea printr-o matrice într-o buclă, dar nu am făcut-o. stiu cat de repede este. În sfârșit, am ajuns să verific și să număr eu.
Am comparat viteza de căutare a unei matrice folosind această funcție cu căutarea obișnuită a matricei în bucle foreach iar în timp ce. Pe 10-100 de elemente de matrice, diferența este de neobservat și timpul este atât de scurt încât poate fi neglijat. Dar pentru matrice mari diferența s-a dovedit a fi destul de semnificativă. Pe măsură ce dimensiunea matricei a crescut cu un ordin de mărime, timpul de căutare a crescut și el semnificativ. Cu o sută de mii de elemente, viteza foreach a scăzut la 0,013 secunde și while - la 0,017, în timp ce array_search() a încetinit și el, dar a rămas cu un ordin de mărime mai rapid - 0,004 secunde. Pentru un script mare care lucrează cu matrice mari, înlocuirea unei căutări într-o buclă cu o căutare folosind array_search() nu va fi deloc o „optimizare de purici”.
În acest sens, mi-am amintit de o discuție recentă cu unul dintre colegii mei de la serviciu despre dacă un programator trebuie să cunoască toate aceste funcții de limbaj încorporate sau dacă „mentalitatea unui programator” și cunoștințele generale sunt suficiente. Fără să intru într-o discuție chiar despre această mentalitate, cred că mai trebuie să cunoști funcțiile, poate nu toată sintaxa în detaliu, dar măcar ce funcții există și ce pot face în termeni generali.
UPD: ai nevoie și de mentalitatea unui programator! Și să fii atent cu memoria ta nu va răni (inspirat de break and range:)
Sub hack este codul de script care a fost folosit pentru a calcula timpul:
$masa=100000; // numărul de valori din tabloul în care vom căuta
$search=50000; // vom căuta această valoare în tablou
$primul_rezultat=matrice(); // matrice de rezultate pentru a calcula valoarea medie a primei opțiuni
$al doilea_rezultat=matrice(); // matrice de rezultate pentru a calcula valoarea medie a celei de-a doua opțiuni
$al treilea_rezultat=matrice(); // matrice de rezultate pentru a calcula valoarea medie a celei de-a treia opțiuni
// creează și completează matricea
$test_array = interval(0, $masa-1); // Mulțumesc lui SelenIT))
/*
$test_array=array();
pentru ($i=0; $i<$mass; $i++)
{
$test_array=$i;
}
*/
// buclă pentru a calcula valorile medii
pentru ($d=0; $d<30; $d++) {
//*************** Căutați folosind array_search *******************
// Începeți să numărați timpul
$time_start = microtime(1);
// caută
$key = array_search($search, $test_array, true);
// dacă se găsește
if ($key!==FALSE) // este necesar!== și nu!=, deoarece numărul primului element este 0
{
echo $test_array[$key];
}
$time_end = microtime(1);
// sfârşitul numărării timpului
// scrie într-o matrice de valori
$first_result= $time_end - $time_start;
//*************** Căutați printr-o matrice cu o buclă foreach *******************
// Începeți să numărați timpul
$time_start = microtime(1);
// căutarea în sine
foreach ($test_array ca $ta)
{
dacă ($ta==$căutare)
{
echo $ta;
pauză;
}
}
$time_end = microtime(1);
// sfârşitul numărării timpului
// scrie într-o matrice de valori
$second_result= $time_end - $time_start;
//*************** Căutați printr-o matrice cu o buclă while *******************
// Începeți să numărați timpul
$time_start = microtime(1);
// determină lungimea matricei
$număr=număr($test_array);
$j=0;
// căutarea în sine
în timp ce ($j<$count)
{
if ($test_array[$j]==$căutare) // dacă a fost găsit
{
echo $test_array[$j];
pauză;
}
$j++;
}
$time_end = microtime(1);
// sfârşitul numărării timpului
// scrie într-o matrice de valori
$third_result= $time_end - $time_start;
}
$srednee1=sumă_matrice($primul_rezultat)/număr($primul_rezultat);
$srednee2=sumă_matrice ($rezult_a doua)/număr ($rezultat_a doua);
$srednee3=sumă_matrice ($treea_rezultat)/număr($treea_rezultat);
Printf("primul cod completat în medie: %.7f secunde", $srednee1);
printf("al doilea cod completat în medie în: %.7f secunde", $srednee2);
printf("al treilea cod completat in medie in: %.7f secunde", $srednee3);
// rezultat:
// primul cod completat în medie: 0,0000295 secunde
// cod secund completat în medie: 0,0153386 secunde
// al treilea cod completat în medie: 0,0226001 secunde
Una dintre operațiunile principale atunci când lucrați cu matrice este căutarea unei anumite valori. Funcția PHP array_search() este concepută pentru aceasta. Este capabil să proceseze atât colecții unidimensionale, cât și asociative, returnând cheia valorii căutate dacă se găsește în matrice.
Sintaxă
Descrierea oficială a funcției array_search() în PHP este următoarea:
Mixed array_search (valoare mixtă, matrice $colecție [, bool strict])
Parametrii de intrare:
- $collection - matricea in care se va efectua cautarea;
- valoare - valoarea dorită de orice tip;
- strict este un indicator boolean opțional care stabilește un mecanism strict de comparare care conștientizează tipul.
Mecanismul de funcționare
Funcția PHP array_search() compară valoarea una câte una cu toate valorile din tabloul de colecție. În mod implicit, comparația este efectuată fără a ține cont de tipurile de operanzi. Această setare poate fi modificată prin setarea steagului strict la TRUE. Comparațiile de șiruri sunt sensibile la majuscule și minuscule.
Dacă se găsește o potrivire, cheia corespunzătoare elementului găsit este returnată și funcția se oprește. Prin urmare, nu poate fi utilizat pentru a detecta mai multe apariții ale valorii dorite într-o matrice.
Dacă nu se găsesc potriviri, funcția va returna un boolean valoare FALS.
Ar trebui să verificați rezultatul returnat folosind operatorul de egalitate strictă (===). Acest lucru este important deoarece funcția poate returna o valoare care este turnată la FALSE, cum ar fi 0 sau șirul gol.
Exemple de utilizare
Exemplul 1. Când treceți un tablou multidimensional la funcția PHP array_search(), rezultatul lucrării va fi cheia elementului căutat.
"iarna", "sezonul 2" => "primavara", "sezonul 3" => "vara", "sezonul 4" => "toamna"); $rezultat1 = array_search("iarna", $array); $rezultat2 = array_search("vara", $array); $rezultat3 = array_search("aprilie", $array); ?>
În acest exemplu, $result1 va fi setat la „season1”, $result2 va fi setat la „season3”, iar $result3 va fi setat la valoarea booleană FALSE deoarece șirul „april” nu apare în tabloul sursă.
Exemplul 2. Funcția PHP array_search() poate procesa și o matrice unidimensională, considerând cheile acesteia ca următorii indici numerici.
Variabila $result va fi setată la 1, conform indexului elementului „hunter” din $array.
Exemplul 3. Posibilă eroare la analiza rezultatului.
"Washington", 1 => "Adams", 2 => "Jefferson", 3 => "Madison", 4 => "Monroe"); $rezultat = array_search("Washington", $presedinti); dacă (!$rezultat) ( ecou „G. Washington nu a fost primul președinte al SUA”; ) ?>
Deci, fără a verifica rezultatul cu egalitate strictă, puteți obține un mesaj neașteptat că George Washington nu a fost primul președinte al Statelor Unite.
Exemplul 4: Se returnează doar cheia primei potriviri găsite.
Chiar dacă valoarea pe care o căutați apare de trei ori în matrice, funcția va returna doar primul rezultat găsit - 0. Pentru a găsi mai multe potriviri, este recomandat să utilizați funcția PHP array_keys().
Căutarea unei valori într-o matrice este necesară în aproape fiecare aplicație PHP și script care lucrează cu date, pentru care există multe metode și funcții speciale. În funcție de sarcina și tipul de căutare, ar trebui să utilizați anumite instrumente, ținând cont de caracteristicile acestora, de viteza de execuție și de ușurința în utilizare. În continuare, ne vom familiariza cu funcțiile PHP pentru căutarea elementelor dintr-o matrice, posibile construcții și metode și, de asemenea, vom afla care metodă este cea mai rapidă.
Funcții de căutare într-o matrice:
array_search- folosit pentru a căuta o valoare într-o matrice. Dacă are succes, returnează cheia valorii căutate dacă nu se găsește nimic, returnează FALSE. Înainte de PHP 4.2.0, array_search() returna NULL mai degrabă decât FALSE la eșec.
Sintaxa funcției mixed array_search (mixed needle, array fanstack [, bool strict]).
foreach (array_expression ca $valoare)
declaraţie
foreach (array_expression as $key => $value)
declaraţie
Un exemplu de utilizare a unei funcții cu constructul foreach pentru a căuta un element de matrice, returnând TRUE la succes
Sintaxa construcției
în timp ce (expr)
declaraţie
Returnează cheia unui element de matrice la succes
Din tabelul de măsurători se poate observa că funcția array_search, arată cele mai bune rezultate atât atunci când căutați în matrice mici, cât și în matrice mari. În același timp, timpul de căutare folosind bucle crește semnificativ în funcție de dimensiunea matricei.