Php kulcs keresése érték szerint. PHP array_search: Érték keresése egy tömbben. Egy érték jelenlétének ellenőrzése egy tömbben. in_array() függvény

A kód írásakor gyakran ellenőrizni kell, hogy egy adott elemérték létezik-e egy tömbben. Ma több olyan funkciót is megvizsgálunk, amelyekkel ezt megteheti.

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

Különféle tömböket kaphatunk adatbázisunkból, és ellenőrizhetjük, hogy van-e benne egy adott érték. A kívánt értéket a szkriptünk felhasználója is továbbíthatja, amikor például keres valamit. Az ilyen keresés eredménye alapján bizonyos műveleteket hajthat végre. Minden az adott feladattól függ, azonban a tömbben lévő érték keresésének algoritmusai ugyanazok lesznek.

Ma ezeket nézzük meg.

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őrizzük bármely érték jelenlétét a tömbben.

Ha a munkájának eredménye sikeres és a kívánt elem megtalálható a tömbben, akkor a függvény visszatér igaz, az az igazság."

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

Egy további opcionális paramétert is igénybe vehet:<Тип данных>. Ha ez a harmadik választható paraméter a következőre van állítva igaz, akkor az adattípus is ellenőrzésre kerül. Vagyis a „2” és a 2 nem lesz ugyanaz. Az első esetben egy karakterlánc, a másodikban egy szám. És akkor az egész funkció in_array() nem ad vissza értéket igaz.

Ne feledje azt is, hogy a függvény a kis- és nagybetűk megkülönböztetését végzi.

Nézzük meg, hogyan működik ez a függvény egy egyszerű példa segítségével.
Szükségünk van valamilyen tömbre. A függvény segítségével ellenőrizzük, hogy van-e érték a tömbben, és egy adott üzenetet jelenítünk meg a képernyőn.

A végrehajtás után a függvény az „Igen” üzenetet jeleníti 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 egy másik kereső funkció is array_search(), amely az előzővel ellentétben visszaadja a talált elem kulcsát. Ez viszont hasznos lehet, ha asszociatív tömbbel dolgozunk.

A függvény ugyanazokat a paramétereket veszi fel, mint az előző. Ebben az esetben a harmadik paraméter szintén nem kötelező.

Nézzük meg, hogyan használható, ha asszociatív tömbbel dolgozunk.

"october","money"=>200,"name="=>"Mila"); $kulcs = array_search("Mila",$Tömeg1); if($kulcs) echo $kulcs; ?>

Ebben az esetben a képernyőn a „name” feliratot fogjuk látni, vagyis a kívánt elem kulcsát „Mila” értékkel.

Ez a két függvény nagyon hasonló, és lényegében csak a visszatérési értékben tér el egymástól.

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

De mi van akkor, ha többdimenziós tömbbel dolgozunk? Hiszen elemei más tömbök lesznek.

Itt a már tárgyalt algoritmusok nem működnek.

Valójában nem is olyan bonyolult, csak egy kicsit bonyolítani kell az egész mechanizmust, és például hurkot kell használni, az egyes(), ami remekü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 az elem kívánt értékét.

Mindössze annyit kell tennie, hogy az eredeti tömb elemeit végighurkolja az egyes(). Ennek a tömbnek minden eleme egy kulcsba ($key) és egy értékbe ($value) lesz értelmezve.

Az érték a fő többdimenziós tömbön belül található mindegyik tömb lesz. Ezekkel az értékekkel fogunk dolgozni, minden belső tömbben megkeresve a kívánt elemértéket.

Ha megtaláltuk, akkor egy üzenetet jelenítünk meg, amely szerint ilyen elem létezik, ha nem, akkor egy másik üzenetet jelenítünk meg, hogy ilyen elem nem létezik.

Lássuk mindezt egy példakóddal:

"anna","id"=>234); $Mass2 = array("név"=>"anton","id"=>24); $Mass2 = array("név"=>"ivan","id"=>007); foreach($Mass2 as $key => $value) ($name .= in_array("ivan",$value); ) if($name) echo "OK! Elem itt!"; else echo "Nincs elem!"; ?>

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

Sőt, itt nem csak egyenlőségjelet kell írni, hanem „.=”-t.

Ez azért történik, hogy a $name változót ne minden iterációnál felülírják, hanem kiegészítsék. Hiszen ha az első iterációnál találunk egy elemet, és a $name változóba a „true” értéket írjuk, de a második iterációnál (vagyis a második belső tömbben) nincs meg az elem kívánt értéke. , akkor a $name változó értéke egyszerűen felülíródik, és a végén egyszerűen nem a megfelelő eredményt kapjuk.

Amint megérti, ennek a kódnak az eredménye az „OK! Az elem itt van!

Próbálja megváltoztatni a keresett elemet egy nem létezőre, és megjelenik a „Nincs elem!” üzenet.

Természetesen, ha egy bizonyos elem megtalálható vagy nem található, akkor nem csak üzeneteket jeleníthetünk meg, hanem más műveleteket is végezhetünk. Minden attól függ, mit kell tenned. Például, ha a kívánt érték benne van a tömbben, megadhat a felhasználónak néhány konkrét információt stb.

Ez minden mára! Remélem világos és hasznos volt a lecke! Próbáljon meg ön is hasonló kódot írni, hogy mindent 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. alább található hálózatok. És iratkozz fel a blogfrissítésekre is. Elég jó archívumot gyűjtöttünk már össze hasznos anyagokból, és csak bővülni fog!

Sikeres programozást kívánok!

Anna Kotelnikova veled volt!

(PHP 4 >= 4.0.5, PHP 5)

tömb_kereső -- Megkeres egy adott értéket egy tömbben, és siker esetén a megfelelő kulcsot adja vissza

Leírás

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

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

Megjegyzés: Ha a tű egy karakterlánc, akkor kis- és nagybetűk közötti összehasonlítást hajtanak végre.

Megjegyzés: PHP 4.2.0-ig, array_search() visszaküldik, ha nem sikerült NULLA ahelyett HAMIS .

Ha átadja az értéket IGAZ mint opcionális harmadik paraméter a strict , a függvény array_search() ellenőrzi a tű típusát is a szénakazalban.

Ha egynél többször van tű a szénakazalban, akkor az első megtalált kulcsot adjuk vissza. Az összes talált érték kulcsának visszaadásához használja a függvényt array_keys() opcionális keresési_érték paraméterrel.

1. példa: Használati példa array_search()

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

Figyelem

Ez a függvény logikai értékként térhet vissza HAMIS, egy nem logikai érték, amelyre a rendszer leadja HAMIS, például 0 vagy "". További információkért tekintse meg a Boole-típusú részt. Az === operátor segítségével ellenőrizze a függvény által visszaadott értéket.

A programozás a szintaxisról és a szemantikáról szól. Az elsőt a nyelv szabályai, a másodikat a fejlesztő tapasztalatai határozzák meg. A tömbök tekintetében a fejlesztő kifejezetten be tudja tölteni a szintaxist szemantikával. Ez még nem objektum, de már nem is hagyományos értelemben vett tömb. A PHP lehetőséget ad különféle típusú változók tömbjének létrehozására, beleértve önmagukat is. Egy tömbelem lehet függvény, vagyis a tömb valós algoritmussal, valós jelentéssel való betöltésének képessége.

A szintaxis stabil, de verzióról verzióra változik, és előfordulhat, hogy még alulról felfelé sem mindig kompatibilis. A programhordozhatóság a múlt század jól elfeledett vívmánya. A szemantika folyamatosan fejlődik, és nem csak bármely nyelv bármely változatában alkalmazható; Hagyománnyá vált, hogy szintaktikai konstrukciókkal fejezik ki azt, amit a nyelv szabályai nem is írtak elő. Ez a legkönnyebben tömbök példáján keresztül érthető meg.

Tömbök felépítése

A PHP tömbje kényelmes szintaxissal és funkciókkal rendelkezik. Ezt előre le lehet írni, de gyakran kényelmes, ha szükség szerint menet közben készítünk tömböket.

public $aNone = array(); // a tömb le van írva, és nem tartalmaz semmit

public $aFact = array("avokádó", "barack", "cseresznye"); // ennek a tömbnek három eleme van

Tömb létrehozása feltétel ellenőrzése közben:

$cSrcLine = "elemzett adatsor";

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

if (checkFunc($cSrcLine, $cUserLine) (

$aResult = "Igen"; // hozzáadás a PHP tömbhöz

$aResult = "Nem";

A példa végrehajtásának eredményeként egy 13 elemből álló tömb jön létre, amelynek értéke csak az „Igen” vagy a „Nem” karakterlánc lesz. Az elemek 0 és 12 közötti indexeket kapnak. Ugyanezt a hatást érhetjük el, ha először a „jövő” PHP tömböt egy karakterláncba írjuk:

$cFutureArray = "";

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

$cUserLine = inputUserLine(); // írj be valamit

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

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

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

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

Többdimenziós tömbök

Sok tartalomkezelő rendszer (CMS) nagy mértékben használja a tömböket. Ez egyrészt jó gyakorlat, másrészt megnehezíti a használatát. Még ha a szerző megérti is a „PHP tömb egy tömbben” doktrínát, nem szabad visszaélnie vele: nemcsak a fejlesztőnek kell hozzászoknia a bonyolult jelöléshez. Gyakran egy idő után maga az alkotó is sokáig emlékszik arra, amit először írt:

"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",))))),

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

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

Ez egy példa a "PHP tömb egy tömbön belül" gyakorlatára a ZF 2-ből. Elsőre nem túl inspiráló, de működik, és vitathatatlanul sikeressé teszi ezt a keretrendszert (példa a ZendSkeletonApplication/module/Helloworld/config/module.config.php-ből) .

A tömb fontos adatkonstrukció a tervezés és fejlesztés során. Többdimenziós változata egykor népszerű volt, de idővel továbbra is szükség volt maximum két- vagy háromdimenziós tömbökre. Ez így egyszerűbb és áttekinthetőbb, és szakmai szempontból, ha valami elkezd szaporodni, az azt jelenti, hogy valami nincs rendben a problémafelvetésben vagy a kódban.

Egyszerű, elérhető és érthető

Ha PHP-ben tömböt hoz létre egy tömbön belül, a legjobb, ha két vagy három szintre korlátozza magát. A PHP stabilitása és megbízhatósága ellenére hibákat követ el a szintaktikai struktúrák feldolgozása során. Ezt akkor tudod elviselni, ha van egy jó kódszerkesztőd, és megszoktad a zárójelek és vesszők pontos számolását. A PHP azonban nem ellenőrzi az adattípusokat (ez a modern programozás karmája), és lehetővé teszi a fejlesztő számára a szemantikai hibák gyakorlását.

Az a szabály, hogy szabályozza a változók típusát vagy saját ötleteit a szemantika szintaxissá alakításához, gyakran megfizethetetlen luxus. Ez a szkript sebességének, a kód olvashatóságának elvesztése, ... mert a kódolás egyszerűsége mindig elengedhetetlen.

A PHP-nek van egy jelentős negatív tulajdonsága: ha bizonytalanság merül fel, a szkript egyszerűen lefagy. Nem minden hibakereső képes kezelni az előre nem látható körülményeket, és sok múlik a fejlesztő tapasztalatán és intuícióján. Minél egyszerűbb az algoritmus, minél könnyebben strukturált az információ, annál nagyobb az esély a hiba megtalálására vagy annak teljes megelőzésére.

Jellemző, hogy amikor az első tömbök megjelentek, az adatok változatait struktúrák formájában javasolták - ügyetlen kísérlet arra, hogy különböző adattípusokból valamit létrehozzanak. Az előbbi túlélte és új, hatékony szintaxist kapott, míg az utóbbi történelemmé vált.

Egyszerű és asszociatív tömbök

A kétdimenziós tömb jelölése egy másik zárójelpár "[" és "]", például: $aSrcData az $aSrcData tömbben található tömbelem elérését jelenti. PHP-ben nem kötelező előre deklarálni az adatokat. Bármely közölt információ létezése mindig ellenőrizhető.

Nagyon hatásos, ha valamit csak akkor alkotunk meg, amikor szükség van rá, abban a formában, amilyenben megkívánták, és akkor semmisítjük meg, amikor az igény megszűnt. Ha értelmes neveket használunk kulcsként (indexként), akkor olyan olvasható konstrukciókat kaphatunk, amelyek az algoritmus aktuális helyének kontextusában értelmesek:

$aAnketa["név"] = "Ivanov";
$aAnketa["életkor"] = 42;
$aAnketa["munka"] = "Igazgató";
$aAnketa["aktív"] = igaz;
$aTable = $aAnketa;

$aAnketa["név"] = "Petrov";
$aAnketa["életkor"] = 34;
$aAnketa["work"] = "Menedzser";
$aAnketa["aktív"] = igaz;
$aTable = $aAnketa;

$aAnketa["név"] = "Afanasjev";
$aAnketa["életkor"] = 28;
$aAnketa["work"] = "Munkás";
$aAnketa["aktív"] = hamis;
$aTable = $aAnketa;

$sOne .= implode ("; ", $aTable) . "
"; // második PHP tömb egy karakterláncba
$sOne .= $aTable["munka"]; // a második tömb egyik elemének elérése

A példa eredménye (az első tömb normál, a benne lévő kulcsok 0-tól kezdődnek, a második tömb asszociatív, négy kulcsa van: "név", "kor", "munkahely", "aktív"):

$sOne = "Petrov; 34; menedzser; 1
Menedzser";

Ez az egyszerű példa bemutatja, hogy egy elkészített kérdőív hogyan alkalmazható minden alkalmazottra. Létrehozhat alkalmazottak tömbjét személyi számok szerinti indexekkel, és ha egy adott alkalmazottra van szüksége, akkor személyi szám alapján választhatja ki.

Ha a szervezetnek vannak részlegei, vagy szezonális munkások vannak, vagy külön kell azonosítani a dolgozó nyugdíjasokat, akkor a „PHP tömb tömbben” kialakítás nagyon kényelmes, de soha nem szabad elragadtatni magát a dimenziótól. Két vagy három dimenzió jelenti a határt a hatékony megoldásnak.

Billentyűk a tömbökhöz

Ha korábban az számított, hogy minden hogyan van elrendezve, akkor az utóbbi években teljesen feledésbe merültek a bináris korszak hagyományai, amikor a programozó tudni akarta, hogyan tárolják pontosan egy tömb elemeit, és közvetlenül hozzá akartak férni hozzájuk. Számos karakterkódolás jelent meg, amelyek egynél több bájtot foglalnak el a memóriában. A "bit" szó már csak a bitkeresési műveletekben található meg, de a PHP tömbben való keresés egy külön téma. Az elemekhez való hozzáférés egyszerű és asszociatív lehet. Az első esetben a tömbelemek (amelyek a PHP-ben elérhető bármelyik típussal rendelkeznek) 0, 1, 2, ... számozással vannak ellátva. A második esetben a programozó megadja a saját indexét, amelyet gyakran „kulcsnak” neveznek, hogy elérje. a kívánt értéket.

$aLine["gyümölcs"] = "narancs"; // itt PHP array key = "gyümölcs"

vagy (hogy minden helyes legyen, figyelembe véve az oldal kódolását és kódját):

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

Amikor új értéket ad hozzá a $aLine tömbhöz:

$aLine = iconv("UTF-8", "CP1251", "barack");
$aLine = iconv("UTF-8", "CP1251", "uborka");
$aLine = iconv("UTF-8", "CP1251", "padlizsán");

a ciklus végrehajtásának eredményeként:

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

fog kapni:

gyümölcs=narancs
0 = őszibarack
zöldség=uborka
1 = padlizsán

A PHP tömbkulcs a „barack” és a „padlizsán” elemek hozzáadásakor 0-tól sorban jön létre, és értékének megadásakor ezzel az értékkel lesz egyenlő.

Elemek eltávolítása egy tömbből

A legegyszerűbb módja a feldolgozás során. Ilyenkor például egy ciklus végrehajtása következtében az eredeti tömb beolvasása megtörténik, és létrejön egy új, amelybe egyszerűen nem íródnak be a felesleges elemek.

Lehetne egyszerűbb is. Ha az utolsó példára alkalmazzuk:

unset($aLine); // PHP tömbelem eltávolítása

akkor az eredmény ez lesz:

gyümölcs=narancs
zöldség=uborka
1 = padlizsán

Számos lehetőség van a tömbelemek manipulálására. Például az implode() és explode() függvények használatával egy PHP tömböt írhatunk egy karakterláncba egy határolóval, és egy másik határolóval visszaelemezhetjük egy másik tömbbe.

Egy teljes tömb egyszerű törléséhez PHP-ben, csak írja be: unset($aLine);

Ez elég.

Keresés egy tömbben

A PHP tartalmaz speciális keresési és in_array() függvényeket, de mielőtt a használatuk mellett döntene, érdemes megfontolni, hogy saját maga végezzen PHP tömb keresést.

Minden projektnek vannak meghatározott tömbjei, különösen akkor, ha a szemantika egy része átkerül a szintaxisba, és nagyon specifikus értelmes kulcsok halmaza képviseli. Ez lehetővé teszi a saját keresési funkciók végrehajtását, amelyek értelmes módon is címkézhetők.

A PHP-ben olyan függvényeket hívhatunk meg, amelyek neve a program végrehajtása során kerül meghatározásra. Egy nagyon praktikus példa a PHPWord könyvtárból, amely lehetővé teszi MS Word dokumentumok olvasását és létrehozását:

$elemek = array("Szöveg", "Inline", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Table", "Image", "Object", "Footnote",
"Végjegyzet", "CheckBox", "Szövegdoboz", "Mező", "Vonal");

$függvények = array();

for ($i = 0; $i< count($elements); $i++) {
$functions[$i] = "hozzáadás" . $elemek[$i];
}

Ennek eredményeként a $functions tömb megkapja a $elements tömb értékeit, vagyis azoknak a valós függvényeknek a nevét, amelyek valódi dokumentumelemekkel működnek.

A $functions meghívásával a $elemeken tökéletes keresést és gyors eredményeket érhet el.

Elemek rendezése

Az adatok rendezésének feladata fontos és ehhez a PHP több funkciót is kínál: sort(), rsort(), asort(), ksort(), ... Növekvő és csökkenő elemek, a második két függvény a kulcsok és értékek közötti kapcsolatokat tárolja. . Néha érdemes véletlenszerűen keverni a tömbértékeket - shuffle().

A PHP függvények rendezése során nem szabad megfeledkezni arról, hogy az elemek nem csak különböző típusúak, de nem is teljesen természetes tartalommal rendelkezhetnek. Először is nagyon óvatosnak kell lennie az orosz betűket tartalmazó karakterláncok, a dátumok, valamint a különböző formátumban írt számok rendezésénél.

A legjobb módja annak, hogy saját maga írjon ideális megoldást, legalábbis a forgatókönyv tesztelésének szakaszában, a kézi rendezés. Segít megelőzni a váratlan helyzeteket.

String Arrays

Az implode() és explode() függvényeknek köszönhetően egy tömb egyszerűen stringgé alakítható és visszaadható. Ez lehetővé teszi az adatok kompakt ábrázolásban történő tárolását, és szükség szerint kényelmes állapotba való kiterjesztését.

A karakterláncokká konvertált tömb új lehetőségeket nyit meg. Például a szövegben a kulcsszavak keresése megköveteli, hogy a talált tartalmat ne adják hozzá újra.

$cSrcLine = "Szöveg szöveg ListItemRun TextBox ListItem TextBox Check Box TextBox lábjegyzet";

$aSrc = explode(" ", $cSrcLine);
$cDstLine = "";

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

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

Ennek eredményeként a $cOne változó csak azokat az értékeket kapja meg a forráskarakterláncból, amelyek ott egyszer megjelennek: "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Footnote".

Az orosz nyelv kulcsaiban és jelentéseiben

A szintaktikai struktúrákban nem ajánlott semmit a nemzeti kódolásokkal kapcsolatosan használni. Az orosz, mint az összes többi nyelv, amelynek karakterei túlmutatnak a-z-n, nem okoznak problémát, mivel az adattartományban vannak, de nem a kód szintaxisában. Néha még egy egyszerű feladat is a PHP-ben „egy tömb kiírása a nyomtatóra vagy a képernyőre” „őrült hibákhoz” vezet, és gyakrabban a szkript egyszerűen leáll.

A PHP hűséges nyelv és toleráns a nemzeti kódolásokkal szemben, de sok olyan helyzet adódik, amikor az elvégzett munkamennyiséget csak azért kell újra elvégezni, mert a megfelelő helyen és időben megjelenik egy kulcsérték, ami nem lehetséges elismerik.

PHP szintaxis és nyelvi környezet

Emlékeztetni kell arra, hogy a PHP szintaxis egy dolog, de ennek a szintaxisnak a konstrukciói más alkalmazásokkal, az operációs rendszerrel, a hardver opciókkal „bánnak”. Sok lehetőség van, soha nem lehet mindent biztosítani.

A „csak kód van a kódban, de mindenféle információ van a bemeneten, belül és kimeneten” szabály segít elkerülni a váratlan meglepetéseket. Egy PHP-érték egy tömbben lehet „orosz”, de a kulcsának szintaktikailag helyesnek kell lennie nemcsak az adott nyelv, hanem a működési környezet szempontjából is.

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ípustudatos összehasonlítási mechanizmust állít be.

Működési mechanizmus

A PHP array_search() függvény egyesével összehasonlítja az értékeket 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 futása 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 a FALSE logikai értéket adja vissza.

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.

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 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 képes 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.

Példa 3. 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.

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égre eljutottam magam ahhoz, hogy ellenőrizzem és megszámoljam.

Összehasonlítottam a tömbben történő keresés sebességét ezzel a funkcióval a szokásos tömbön keresztüli kereséssel a foreach és a while ciklusokban. 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 mentalitásról vitatkoznék, azt hiszem, 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 mit tudnak általánosságban csinálni.

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

A hack alatt található az idő kiszámításához használt szkriptkó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ámolá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ámolá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ámolá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 a második kód befejeződött: %.7f másodperc alatt", $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