Elég régóta használom az array_search() függvényt, hogy értékeket keressek egy tömbben, mivel többször hallottam és olvastam, hogy észrevehetően gyorsabban működik, mint egy tömbben ciklusban keresni, de nem tudja, mennyivel gyorsabb. Végül magam is ellenőriztem és megszámoltam.

Összehasonlítottam egy tömb keresésének sebességét ezzel a funkcióval a szokásos tömbkereséssel foreach hurkokés közben. 10-100 tömbelemen észrevehetetlen a különbség, és az idő olyan rövid, hogy elhanyagolható. De a nagy tömböknél a különbség meglehetősen jelentősnek bizonyult. Ahogy a tömb mérete egy nagyságrenddel nőtt, a keresési idő is jelentősen megnőtt. Százezer elem mellett a foreach sebessége 0,013 másodpercre csökkent, míg - 0,017-re, addig az array_search() is lelassult, de így is egy nagyságrenddel gyorsabb maradt - 0,004 másodpercre. Egy nagy tömbökkel dolgozó nagy szkript esetén a ciklusban végzett keresés lecserélése az array_search() használatával végzett keresésre egyáltalán nem „bolha-optimalizálás”.

Ezzel kapcsolatban eszembe jutott egy nemrégiben egy munkahelyi kollégámmal folytatott megbeszélés arról, hogy egy programozónak tudnia kell-e mindezeket a beépített nyelvi funkciókat, vagy elég a „programozói gondolkodásmód” és az általános tudás. Anélkül, hogy éppen erről a gondolkodásmódról vitatkoznék, azt gondolom, hogy még mindig ismernie kell a függvényeket, talán nem az összes szintaxist részletesen, de legalább azt, hogy milyen függvények vannak, és általánosságban mire képesek.

UPD: szükség van egy programozói gondolkodásmódra is! És ha vigyázol a memóriáddal, az nem árt (a break és range inspirálta:)

A hack alatt található az idő kiszámításához használt script kód:

$tömeg=100000; // értékek száma a tömbben, amelyben keresni fogunk
$keresés=50000; // ezt az értéket fogjuk keresni a tömbben
$első_eredmény=tömb(); // eredmények tömbje az első opció átlagos értékének kiszámításához
$second_result=array(); // eredmények tömbje a második opció átlagértékének kiszámításához
$harmadik_eredmény=tömb(); // eredmények tömbje a harmadik opció átlagértékének kiszámításához

// létrehozza és kitölti a tömböt
$teszt_tömb = tartomány(0, $tömeg-1); // köszönet a SelenIT-nek))

/*
$teszt_tömb=tömb();
for ($i=0; $i<$mass; $i++)
{
$test_array=$i;
}
*/

// ciklus az átlagos értékek kiszámításához
for ($d=0; $d<30; $d++) {

//*************** Keresés az array_search használatával *******************

// Kezdje el számolni az időt
$idő_kezdés = mikroidő(1);
// keresés
$kulcs = array_search($keresés, $teszt_tömb, igaz);
// ha megtalálható
if ($key!==FALSE) // szükséges!== és nem!=, mert az első elem száma 0
{
echo $teszt_tömb[$kulcs];
}
$idő_vége = mikroidő(1);
// idővégi számlálás

// értéktömbbe írás
$első_eredmény= $idő_vége - $idő_kezdete;

//*************** Keresés egy tömbben foreach ciklussal *******************

// Kezdje el számolni az időt
$idő_kezdés = mikroidő(1);
// maga a keresés
foreach ($test_array mint $ta)
{
ha ($ta==$keresés)
{
echo $ta;
szünet;
}
}
$idő_vége = mikroidő(1);
// idővégi számlálás

// értéktömbbe írás
$second_result= $idő_vége - $idő_kezdete;

//*************** Keresés egy tömbben egy while ciklussal *******************

// Kezdje el számolni az időt
$idő_kezdés = mikroidő(1);

// határozza meg a tömb hosszát
$count=count($teszt_tömb);
$j=0;
// maga a keresés
míg ($j<$count)
{
if ($test_array[$j]==$search) // ha talált
{
echo $test_array[$j];
szünet;
}
$j++;
}
$idő_vége = mikroidő(1);
// idővégi számlálás

// értéktömbbe írás
$harmadik_eredmény= $idő_vége - $idő_kezdete;
}

$srednee1=tömbösszeg($első_eredmény)/count($első_eredmény);
$srednee2=tömbösszeg ($második_eredmény)/számlálás($második_eredmény);
$srednee3=tömbösszeg ($harmadik_eredmény)/számlálás($harmadik_eredmény);

Printf("átlagosan teljesített első kód: %.7f másodperc", $srednee1);
printf("átlagosan befejeződött második kód: %.7f másodperc", $srednee2);
printf("a harmadik kód átlagosan %.7f másodperc alatt készült el", $srednee3);

// eredmény:
// az első befejezett kód átlagosan: 0,0000295 másodperc
// átlagosan kitöltött második kód: 0,0153386 másodperc
// a harmadik kód kitöltése átlagosan: 0,0226001 másodperc

A tömbökkel végzett munka során az egyik fő művelet egy adott érték keresése. A PHP array_search() függvénye erre készült. Képes egydimenziós és asszociatív gyűjtemények feldolgozására is, visszaadva a keresett érték kulcsát, ha az megtalálható a tömbben.

Szintaxis

Az array_search() függvény formalizált leírása PHP-ben a következő:

Vegyes array_search (vegyes érték, tömb $collection [, bool strict])

Bemeneti paraméterek:

• $gyűjtemény - a tömb, amelyben a keresés végrehajtásra kerül;
• érték - bármilyen típusú kívánt érték;
• A strict egy opcionális logikai jelző, amely szigorú típus-tudatos összehasonlítási mechanizmust állít be.

Működési mechanizmus

PHP függvény Az array_search() egyenként összehasonlítja az értéket a gyűjteménytömb összes értékével. Alapértelmezés szerint az összehasonlítás az operandusok típusától függetlenül történik. Ez a beállítás módosítható a szigorú jelző IGAZ értékre állításával. A karakterlánc-összehasonlítások megkülönböztetik a kis- és nagybetűket.

Ha talál egyezést, akkor a talált elemnek megfelelő kulcs kerül visszaadásra, és a függvény működése leáll. Ezért nem használható a kívánt érték többszöri előfordulásának észlelésére egy tömbben.

Ha nem található egyezés, a függvény logikai értéket ad vissza érték HAMIS.

A visszaadott eredményt a szigorú egyenlőség operátorral (===) kell ellenőrizni. Ez azért fontos, mert a függvény olyan értéket adhat vissza, amely FALSE-ra van öntve, például 0 vagy üres karakterlánc.

Használati példák

1. példa Ha többdimenziós tömböt adunk át a PHP array_search() függvénynek, a munka eredménye lesz a keresett elem kulcsa.

"tél", "szezon2" => "tavasz", "szezon3" => "nyár", "szezon4" => "ősz"); $eredmény1 = array_search("tél", $tömb); $eredmény2 = array_search("nyár", $tömb); $eredmény3 = array_search("április", $tömb); ?>

Ebben a példában a $eredmény1 értéke "szezon1", a $eredmény2 értéke "szezon3" lesz, és a $eredmény3 logikai értéke FALSE lesz, mivel az "április" karakterlánc nem jelenik meg a forrástömbben.

2. példa A PHP array_search() függvény egydimenziós tömböt is tud feldolgozni, a kulcsait a következő numerikus indexeknek tekintve.

A $result változó 1-re lesz állítva, a $tömbben lévő "hunter" elem indexének megfelelően.

3. példa Lehetséges hiba az eredmény elemzésekor.

"Washington", 1 => "Adams", 2 => "Jefferson", 3 => "Madison", 4 => "Monroe"); $eredmény = array_search("Washington", $elnökök); if (!$eredmény) ( echo "G. Washington nem az USA első elnöke volt"; ) ?>

Tehát anélkül, hogy szigorú egyenjogúsággal ellenőriznénk az eredményt, váratlan üzenetet kaphatunk arról, hogy nem George Washington volt az Egyesült Államok első elnöke.

4. példa: Csak az első talált egyezés kulcsa kerül visszaadásra.

Annak ellenére, hogy a keresett érték háromszor fordul elő a tömbben, a függvény csak az első talált eredményt adja vissza - 0. Több egyezés megtalálásához javasoljuk a PHP array_keys() függvényét.

Egy érték keresése tömbben szinte minden PHP alkalmazásban és adatokkal dolgozó szkriptben szükséges, amihez számos módszer és speciális függvény létezik. A feladattól és a keresés típusától függően bizonyos eszközöket kell használnia, figyelembe véve azok jellemzőit, a végrehajtás sebességét és a könnyű használhatóságot. Ezután megismerkedünk a PHP függvényekkel, amelyek segítségével egy tömbben kereshetünk elemeket, a lehetséges konstrukciókat és metódusokat, valamint azt is, hogy melyik módszer a leggyorsabb.

Függvények tömbben történő kereséshez:
array_search- érték keresésére szolgál egy tömbben. Ha sikeres, akkor a keresett érték kulcsát adja vissza, ha nem talál semmit, akkor a FALSE értéket adja vissza. A PHP 4.2.0 előtt az array_search() hiba esetén FALSE helyett NULL értéket adott vissza.

A mix array_search függvény szintaxisa (vegyes tű, tömb szénakazal [, bool strict]).

foreach (tömb_kifejezés $értékként)
nyilatkozat
foreach (tömb_kifejezés $kulcsként => $érték)
nyilatkozat

Példa egy függvény használatára a foreach konstrukcióval egy tömbelem keresésére, siker esetén TRUE-t ad vissza

Építési szintaxis
míg (kif.)
nyilatkozat

Egy tömbelem kulcsát adja vissza a sikerhez

A mérési táblázatból látható, hogy a függvény array_search, a legjobb eredményeket mutatja kis és nagy tömbökben történő kereséskor is. Ugyanakkor a hurkok segítségével történő keresési idő jelentősen megnő a tömb méretétől függően.