PHP array_search: Érték keresése egy tömbben. Hogyan ellenőrizhető, hogy létezik -e érték egy php tömbben php keresés egy asszociatív tömbben érték szerint

Gyakran, amikor kódot ír, ellenőriznie kell, hogy egy elem adott értéke létezik -e egy tömbben. Ma több olyan funkciót fogunk megvizsgálni, amelyekkel ezt megteheti.

Egy elem értékének egy tömbben való jelenlétének ellenőrzése különféle programozási problémák megoldására használható.

Számos tömböt szerezhetünk be adatbázisunkból, és ellenőrizhetjük, hogy van -e benne egy vagy másik érték. A kívánt érték a szkriptünk felhasználójától is továbbítható, amikor például keres valamit. Az ilyen keresés eredményei alapján bizonyos műveleteket hajthat végre. Minden a konkrét feladattól függ, azonban a tömb értékének megtalálására szolgáló algoritmusok azonosak lesznek.

Ma megnézzük őket.

Egy érték jelenlétének ellenőrzése egy tömbben. In_array () függvény

Funkció in_array () lehetővé teszi számunkra, hogy ellenőrizhessük a tömb bármely értékét.

Ha a munkájának eredménye sikeres, és a tömb szükséges eleme megtalálható, akkor a függvény visszatér igaz, az az igazság."

A funkció 2 szükséges paramétert tartalmaz:<Что ищем>és<Где ищем>.

Ezenkívül további opcionális paramétereket is felvehet:<Тип данных>... Ha ez a harmadik opcionális paraméter igaz, akkor az adattípust is ellenőrzik. Vagyis a „2” és a 2 nem ugyanaz. Az első esetben ez egy karakterlánc, a másodikban egy szám. És akkor az egész funkció in_array () nem ad vissza értéket igaz.

Emlékeznie kell arra is, hogy a függvény a kis- és nagybetűk közötti összehasonlítást végzi.

Nézzük meg, hogyan működik ez a függvény egy egyszerű példával.
Szükségünk van valamilyen tömbre. A funkció használatával ellenőrizze, hogy van -e érték a tömbben, és jelenítsen meg egy adott üzenetet.

A funkció végrehajtása után az "Igen" üzenet jelenik meg, mivel a "Marina" elem jelen van a tömbünkben.

Módosítsa a függvény első paraméterét valamilyen nem létező elemre, és megjelenik a "Nem" üzenet.

Egy érték jelenlétének ellenőrzése egy tömbben. Array_search () függvény

Van még egy funkció a kereséshez array_search (), amely az előzővel ellentétben visszaadja a talált elem kulcsát. Ez viszont hasznos lehet, ha asszociatív tömbrel dolgozunk.

A függvény ugyanazokat a paramétereket veszi fel, mint az előző. Ebben az esetben a harmadik paraméter is opcionális.

Nézzük meg, hogyan használhatja azt asszociatív tömb használatakor.

"október", "pénz" => 200, "név" => "Mila"); $ key = array_search ("Mila", $ Mass1); if ($ key) echo $ key; ?>

Ebben az esetben látni fogjuk a képernyőn a „nevet”, vagyis a kulcsot a keresett elemből, amelynek értéke „Mila”.

Ez a két funkció nagyon hasonló, és valójában csak a visszatérési értékben tér el.

Érték keresése többdimenziós tömbben

De mi van akkor, ha többdimenziós tömbrel dolgozunk? Végül is más tömbök lesznek az elemei.

A már megvizsgált algoritmusok itt nem fognak működni.

Valójában minden nem olyan nehéz, csak egy kicsit bonyolítania kell az egész mechanizmust, és használnia kell egy hurkot, pl. az egyes () ami tök jól működik tömbökkel.

Tegyük fel, hogy van egy többdimenziós tömbünk. Közvetlen értékei más tömbök, amelyek tartalmazhatják a kívánt elemértéket.

Csak annyit kell tennie, hogy az eredeti tömb elemeit ismétli egy ciklusban. az egyes ()... A tömb minden eleme kulcsként ($ kulcs) és értékként ($ érték) lesz értelmezve.

Az érték a fő többdimenziós tömb minden tömbje lesz. Ezekkel az értékekkel dolgozunk, és minden belső tömbben megkeressük a kívánt elemértéket.

Ha megtaláljuk, megjelenítünk egy üzenetet arról, hogy létezik ilyen elem, és ha nem, akkor egy másik üzenetet jelenítünk meg arról, hogy nincs ilyen elem.

Nézzük mindezt egy példakóddal:

"anna", "id" => 234); $ Mass2 = tömb ("name" => "anton", "id" => 24); $ Mass2 = array ("name" => "ivan", "id" => 007); foreach ($ Mass2 as $ key => $ value) ($ name. = in_array ("ivan", $ value);) if ($ name) echo "OK! Element here!"; else echo "Nincs elem!"; ?>

Amint látja, először magát a többdimenziós tömböt deklaráljuk.

Ebben az esetben feltétlenül ide kell írni nem csak egyenlőségjelet, hanem ". =".

Ez azért történik, hogy a $ name változó ne kerüljön felülírásra minden iterációnál, hanem kiegészüljön. Végül is, ha az első iterációnál megtaláljuk az elemet, és a "true" értéket a $ name változóba írjuk, a második iterációnál (vagyis a második belső tömbben) az elem kívánt értéke nem, akkor a $ name változó értéke egyszerűen felül lesz írva, és ennek eredményeként egyszerűen nem fogjuk megkapni a helyes eredményt.

Amint megérti, a kód munkájának eredménye az „OK! Itt az elem! "

Próbálja meg megváltoztatni a keresett elemet egy nem létező elemre, és megjelenik a „No have element!” Üzenet.

Természetesen, ha találunk vagy nem találunk egy bizonyos elemet, nem csak megjeleníthetjük az üzeneteket, hanem más műveleteket is végrehajthatunk. Minden attól függ, mit kell tennie. Például, ha van egy kívánt érték egy tömbben, megadhat a felhasználónak bizonyos információkat stb.

Ez minden mára! Remélem az oktatóanyag világos és hasznos volt! Próbáljon meg hasonló kódot írni, hogy mindent teljesen megértsen.

És várom a hozzászólásaitokat.

Ossza meg a leckét barátaival a közösségi gombok segítségével. lenti hálózatok. És iratkozzon fel a blog frissítéseire is. Már összegyűjtöttünk egy elég jó archívumot a hasznos anyagokról, és csak feltöltésre kerülnek!

Sikeres programozást kívánok!

Anna Kotelnikova veled volt!

(PHP 4> = 4.0.5, PHP 5)

array_search - tömböt keres az adott értékre, és sikeres esetén visszaadja a megfelelő kulcsot

Leírás

vegyes tömb_keresés(vegyes tű, tömb szénakazal [, bool szigorú])

Tűt keres a szénakazalban, és visszaadja a kulcsot, ha az szerepel a tömbben, HAMIS másképp.

Megjegyzés: Ha a tű karakterlánc, akkor kis- és nagybetűket kell összehasonlítani.

Megjegyzés: A PHP 4.2.0 előtt array_search () kudarc után tért vissza NULLA ahelyett HAMIS .

Ha átadja az értéket IGAZ opcionális harmadik paraméterként a függvény array_search () ellenőrzi a tűt is a szénakazal -tömbben.

Ha a tű többször is megjelenik a szénakazalban, az első talált kulcsot visszaküldi. Az összes talált értékhez tartozó kulcsok visszaadásához használja a funkciót array_keys () opcionális search_value paraméterrel.

Példa 1. Használati példa array_search () $ array = array (0 => "kék", 1 => "piros", 2 => 0x000000, 3 => "zöld", 4 => "piros"); $ key = array_search ("piros", $ tömb ); // $ kulcs = 1; $ key = array_search ("zöld", $ tömb); // $ kulcs = 2; (0x000000 == 0 == "zöld") $ key = array_search ("zöld", $ tömb, igaz); // $ kulcs = 3; ?>

Figyelem

Ez a függvény logikai értékként térhet vissza HAMIS, és egy nem logikai érték, amelyre megadják HAMIS, például 0 vagy "". További információért lásd a Boolean Type részt. A === operátorral tesztelje ennek a függvénynek a visszatérési értékét.

Már régóta használom az array_search () függvényt egy tömb értékeinek keresésére, mivel többször hallottam és olvastam, hogy érezhetően gyorsabban működik, mint egy ciklusban lévő tömbön keresztül keresni, de nem tudtam mennyivel gyorsabb. Végül kézbe vettük az ellenőrzést és a számolást.

Összehasonlítottam a keresési sebességet egy tömbben ezzel a funkcióval a szokásos iterációval egy tömbön keresztül a foreach -ban és ciklusokban. 10-100 tömb elemnél a különbség észrevehetetlen, és az idő olyan rövid, hogy elhanyagolhatók. De a nagy tömbök esetében a különbség nagyon jelentősnek bizonyult. A tömb méretének nagyságrenddel történő növekedésével a keresési idő is jelentősen nőtt. Százezer elemmel a foreach sebessége 0,013 másodpercre csökkent, és míg - 0,017 -re, míg a array_search () szintén lelassult, de így is nagyságrenddel gyorsabb maradt - 0,004 másodperc. Egy nagy szkript esetén, amely nagy tömbökkel működik, a ciklusban végzett keresés lecserélése a array_search () használatával végzett keresésre egyáltalán nem lesz "bolhaoptimalizálás".

Ezzel kapcsolatban felidéztem az egyik munkatársammal a közelmúltban folytatott megbeszélést - arról, hogy egy programozónak ismernie kell -e a nyelv mindezen beépített funkcióit, vagy elegendő a "programozó gondolkodásmód" és az általános tudás. Anélkül, hogy vitába bocsátkoznánk erről a gondolkodásmódról, úgy gondolom, hogy még mindig ismernie kell a funkciókat, talán nem minden szintaxist részletesen, de legalább azt, hogy milyen funkciók léteznek, és mire képesek általánosságban.

UPD: programozói gondolkodásmódra van szüksége, szüksége van rá is! És a tudatosság a memóriával nem árt (a szünet és a tartomány ihlette :)

A habrakat alatt az a szkriptkód, amellyel az időt számolták:

$ tömeg = 100000; // a tömb értékeinek száma, amelyben keresni fogunk
$ keresés = 50 000; // ezt az értéket fogjuk keresni a tömbben
$ első_eredmény = tömb (); // eredménytömb az első lehetőség átlagos értékének kiszámításához
$ second_result = tömb (); // eredménytömb, a második lehetőség átlagos értékének kiszámításához
$ harmadik_eredmény = tömb (); // eredménytömb, a harmadik opció átlagának kiszámításához

// hozza létre és töltse ki a tömböt
$ test_array = tartomány (0, $ tömeg-1); // köszönöm SelenIT))

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

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

// *************** Keresés tömbkereséssel *******************

// Kezdje el számolni az időt
$ time_start = mikrotime (1);
// Keresés
$ kulcs = tömbkeresés ($ keresés, $ teszt_tömb, igaz);
// ha megtalálják
if ($ key! == FALSE) // szükséges! == és nem! =, mert az első elem száma 0
{
echo $ test_array [$ kulcs];
}
$ time_end = mikrotime (1);
// időszámítás

// írjon az értékek tömbjébe
$ first_result = $ time_end - $ time_start;

// *************** Tömb keresése foreach hurokkal *******************

// Kezdje el számolni az időt
$ time_start = mikrotime (1);
// keresse magát
foreach ($ test_array as $ ta)
{
ha ($ ta == $ keresés)
{
echo $ ta;
szünet;
}
}
$ time_end = mikrotime (1);
// időszámítás

// írjon az értékek tömbjébe
$ second_result = $ time_end - $ time_start;

// *************** Keresés hurokban lévő tömbben, miközben *******************

// Kezdje el számolni az időt
$ time_start = mikrotime (1);

// határozza meg a tömb hosszát
$ count = count ($ test_array);
$ j = 0;
// keresse magát
míg ($ j<$count)
{
if ($ test_array [$ j] == $ search) // ha megtalálta
{
echo $ test_array [$ j];
szünet;
}
$ j ++;
}
$ time_end = mikrotime (1);
// időszámítás

// írjon az értékek tömbjébe
$ third_result = $ time_end - $ time_start;
}

$ srednee1 = array_sum ($ first_result) / count ($ first_result);
$ srednee2 = array_sum ($ second_result) / count ($ second_result);
$ srednee3 = tömbösszeg ($ harmadik_eredmény) / szám ($ harmadik_eredmény);

Printf ("az első kód elkészült: átlagosan% .7f másodperc", $ srednee1);
printf ("a második kód: átlagosan% .7f másodperc alatt végrehajtva", $ srednee2);
printf ("harmadik kód: átlagosan% .7f másodperc alatt végrehajtva", $ srednee3);

// eredmény:
// az első kód végrehajtása átlagosan: 0.0000295 másodperc
// a második kód átlagosan 0,0153386 másodperc alatt fut le
// a harmadik kód átlagosan 0,0226001 másodperc alatt fut le

A tömbökkel való munka során az egyik fő művelet egy adott érték megtalálása. Erre szolgál a PHP array_search () függvénye. Képes mind az egydimenziós, mind az asszociatív gyűjtemények kezelésére, és visszaadja a kívánt érték kulcsát, ha megtalálható a tömbben.

Szintaxis

A array_search () függvény formális leírása a PHP -ben a következő:

Vegyes tömbkeresés (vegyes érték, tömb $ gyűjtemény [, bool szigorú])

Bemeneti paraméterek:

• $ collection - a keresendő tömb;
• érték - bármely típus kívánt értéke;
• szigorú egy opcionális logikai jelző, amely szigorú típustudatos összehasonlítási mechanizmust állít be.

A munka mechanizmusa

A PHP array_search () függvénye egyenként összehasonlítja az értékeket a gyűjtemény tö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 megváltoztatható, ha a szigorú zászlót IGAZ -ra állítja. A karakterlánc -összehasonlítások kis- és nagybetűket különböztetnek meg.

Ha talál egyezést, akkor a talált elemnek megfelelő kulcs kerül visszaadásra, és a funkció leáll. Ezért nem tudja észlelni a kívánt érték többszörös előfordulását a tömbben a segítségével.

Ha nem talál egyezést, a függvény visszaadja a HAMIS logikai értéket.

A visszaadott eredményt a szigorú egyenlőség operátorral (===) kell tesztelnie. Ez azért fontos, mert a függvény visszaadhat egy HAMIS értékre adott értéket, például 0 -t vagy egy üres karakterláncot.

Példák a felhasználásra

1. példa Ha többdimenziós tömböt adunk át a PHP array_search () függvénynek, a művelet eredménye lesz a szükséges elem kulcsa.

"tél", "szezon2" => "tavasz", "szezon3" => "nyár", "szezon4" => "ősz"); $ result1 = array_search ("tél", $ tömb); $ result2 = array_search ("nyár", $ tömb); $ result3 = array_search ("április", $ tömb); ?>

Ebben a példában a $ result1 változó értéke "season1", a $ result2 értéke "season3" lesz, a $ result3 pedig a logikai FALSE értékre lesz állítva, mivel az "april" karakterlánc nem jelenik meg az eredetiben sor.

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

A $ eredmény változónak az 1 érték lesz hozzárendelve a $ tömb "vadász" elemének indexe szerint.

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

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

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

4. példa Csak az első találat kulcsát adja vissza.

Annak ellenére, hogy a szükséges érték háromszor fordul elő a tömbben, a függvény csak az első találatot adja vissza - 0. Több találat kereséséhez ajánlott a PHP array_keys () függvény használata.