(PHP 4 >= 4.0.5, PHP 5)
array_search -- Vyhledá pole pro danou hodnotu a v případě úspěchu vrátí odpovídající klíč
Popis
smíšený pole_search(smíšená jehla, pole sena [, bool strict])Vyhledá v kupce sena jehlu a vrátí klíč, pokud existuje, v poli, NEPRAVDIVÉ v opačném případě.
Komentář: Je-li jehla struna, provede se porovnání rozlišující malá a velká písmena.
Komentář: Před PHP 4.2.0, array_search() vráceno při neúspěchu NULA namísto NEPRAVDIVÉ .
Pokud předáte hodnotu SKUTEČNÝ jako volitelný třetí parametr funkce strict array_search() také zkontroluje typ jehly v poli kupky sena.
Pokud je jehla v kupce sena přítomna více než jednou, bude vrácen první nalezený klíč. Chcete-li vrátit klíče pro všechny nalezené hodnoty, použijte funkci array_keys() s volitelným parametrem search_value .
Příklad 1: Příklad použití array_search()
|
| Pozornost |
Tato funkce se může vrátit jako logická hodnota NEPRAVDIVÉ a jinou než booleovskou hodnotu, která je přetypována na NEPRAVDIVÉ, například 0 nebo "". Další informace naleznete v tématu Booleovský typ. Pomocí operátoru === otestujte hodnotu vrácenou touto funkcí. |
Funkci array_search() používám už nějakou dobu k hledání hodnot v poli, protože jsem slyšel a četl, že je to znatelně rychlejší než prohledávání pole ve smyčce, ale nevěděl jsem jak moc bylo to rychlejší. Konečně jsem se dostal ke kontrole a počítání.
Porovnal jsem rychlost vyhledávání v poli pomocí této funkce s obvyklou iterací pole v cyklech foreach a while. Při 10-100 prvcích pole je rozdíl nepostřehnutelný a čas je tak krátký, že jej lze zanedbat. Ale u velkých polí se rozdíl ukázal jako docela významný. S nárůstem velikosti pole o řád se výrazně prodloužila i doba vyhledávání. Se 100 000 prvky klesl foreach na 0,013 sekundy a while na 0,017, zatímco array_search() se také zpomalilo, ale stále zůstalo o řád rychlejší na 0,004 sekundy. U velkého skriptu, který pracuje s velkými poli, by nahrazení hledání ve smyčce hledáním pole_search() nebylo vůbec bleší optimalizací.
V této souvislosti jsem si vzpomněl na nedávnou diskuzi s jedním z mých kolegů v práci – o tom, zda programátor potřebuje znát všechny tyto zabudované funkce jazyka, nebo mu stačí „programátorské myšlení“ a všeobecné znalosti. Aniž bych se pouštěl do diskuse o tomto způsobu myšlení, myslím si, že stále potřebujete znát funkce, možná ne celou syntaxi podrobně, ale alespoň jaké funkce tam jsou a co obecně umí.
UPD: potřebujeme programátorské myšlení, potřebujeme ho také! A všímavost s pamětí neuškodí (inspirováno breakem a rozsahem:)
Pod habrakat, kód skriptu, který počítal čas:
$hmotnost=100000; // počet hodnot v poli, ve kterém budeme hledat
$hledat=50000; // v poli budeme hledat tuto hodnotu
$first_result=array(); // pole výsledků pro výpočet průměrné hodnoty první možnosti
$second_result=array(); // pole výsledků pro výpočet průměrné hodnoty druhé možnosti
$třetí_výsledek=pole(); // pole výsledků pro výpočet průměrné hodnoty třetí možnosti
// vytvoří a naplní pole
$test_array = range(0, $hmotnost-1); // díky SelenIT))
/*
$test_array=pole();
pro ($i=0; $i<$mass; $i++)
{
$test_array=$i;
}
*/
// smyčka pro výpočet průměrů
pro ($d=0; $d<30; $d++) {
//*************** Vyhledávání pomocí array_search *******************
// Začněte počítat čas
$time_start = microtime(1);
// Vyhledávání
$key = array_search($search, $test_array, true);
// pokud je nalezen
if ($key!==FALSE) // je nutné!== a ne!=, protože číslo prvního prvku je 0
{
echo $test_array[$key];
}
$time_end = microtime(1);
// konec doby počítání
// zápis do pole hodnot
$first_result= $time_end - $time_start;
//*************** Vyhledávání pole se smyčkou foreach *******************
// Začněte počítat čas
$time_start = microtime(1);
// hledání samo
foreach ($test_array jako $ta)
{
if ($ta==$search)
{
echo $ta;
přestávka;
}
}
$time_end = microtime(1);
// konec doby počítání
// zápis do pole hodnot
$second_result= $time_end - $time_start;
//*************** Vyhledávání pole se smyčkou while *******************
// Začněte počítat čas
$time_start = microtime(1);
// určení délky pole
$pocet=pocet($test_pole);
$j=0;
// hledání samo
zatímco ($j<$count)
{
if ($test_array[$j]==$search) // pokud bylo nalezeno
{
echo $test_array[$j];
přestávka;
}
$j++;
}
$time_end = microtime(1);
// konec doby počítání
// zápis do pole hodnot
$third_result= $time_end - $time_start;
}
$srednee1=součet_pole ($first_result)/count($first_result);
$srednee2=součet_pole ($second_result)/count($second_result);
$srednee3=součet_pole ($třetí_výsledek)/počet($třetí_výsledek);
Printf("První kód spuštěn v průměru za: %.7f sekund", $srednee1);
printf("Druhý kód spuštěn v průměru za: %.7f sekund", $srednee2);
printf("3. kód spuštěn v průměru za: %.7f sekund", $srednee3);
// výsledek:
// první kód se provede v průměru za: 0,0000295 sekund
// druhý kód dokončen v průměru: 0,0153386 sekund
// třetí kód je dokončen v průměru za: 0,0226001 sekund
Při psaní kódu je často nutné zkontrolovat, zda určitá hodnota prvku v poli existuje. Dnes se podíváme na několik funkcí, pomocí kterých to lze provést.
Kontrola přítomnosti hodnoty prvku v poli může být použita při řešení různých problémů v programování.
Můžeme získat různá pole z naší databáze a zkontrolovat přítomnost konkrétní hodnoty v ní. Požadovanou hodnotu lze přenést i od uživatele našeho skriptu, když například něco hledá. Na základě výsledků takového vyhledávání můžete provádět určité akce. Vše závisí na konkrétní úloze, ale algoritmy pro nalezení hodnoty v poli budou stejné.
Dnes si je zopakujeme.
Kontrola, zda je hodnota v poli. funkce in_array().
Funkce in_array() nám umožní zkontrolovat, zda v poli existuje hodnota.
Pokud je výsledek jeho práce úspěšný a požadovaný prvek v poli je nalezen, funkce se vrátí skutečný tedy "pravda".
Funkce má 2 požadované parametry:<Что ищем>a<Где ищем>.
Může také trvat jeden volitelný parametr:<Тип данных>. Pokud má tento třetí volitelný parametr hodnotu skutečný, pak je také zkontrolován datový typ. To znamená, že „2“ a 2 nebudou stejné. V prvním případě se jedná o řetězec, v druhém o číslo. A pak celá funkce in_array() nevrátí hodnotu skutečný.
Musíte si také pamatovat, že funkce provádí porovnání s rozlišováním malých a velkých písmen.
Podívejme se, jak tato funkce funguje na jednoduchém příkladu.
Potřebujeme nějaký druh pole. Pomocí funkce zkontrolujeme přítomnost hodnoty v poli a zobrazíme konkrétní zprávu na obrazovce.
Po dokončení funkce se na obrazovce zobrazí zpráva „Ano“, protože v našem poli je prvek „Marina“.
Změňte první parametr ve funkci na nějaký neexistující prvek a uvidíte zprávu "Ne".
Kontrola, zda je hodnota v poli. funkce array_search().
Existuje další funkce vyhledávání array_search(), který na rozdíl od předchozího vrátí klíč nalezeného prvku. To se zase může hodit, pokud pracujeme s asociativním polem.
Funkce má stejné parametry jako předchozí. Třetí parametr je však také volitelný.
Podívejme se, jak jej lze použít s asociativním polem.
"říjen","peníze"=>200,"jméno"=>"Mila"); $key = array_search("Mila",$Mass1); if($key) echo $key; ?>
V tomto případě na obrazovce uvidíme „name“, tedy klíč k hledanému prvku s hodnotou „Mila“.
Tyto dvě funkce jsou si velmi podobné a v podstatě se liší pouze návratovou hodnotou.
Hledání hodnoty ve vícerozměrném poli
Ale co když pracujeme s vícerozměrným polem? Koneckonců, jeho prvky budou jiná pole.
Zde nebudou fungovat algoritmy, které jsme již zvažovali.
Ve skutečnosti není vše tak složité, jen je potřeba celý mechanismus trochu zkomplikovat a použít např. smyčku, pro každého(), který funguje dobře s poli.
Řekněme, že máme vícerozměrné pole. Jeho okamžité hodnoty jsou další pole, která mohou obsahovat požadovanou hodnotu prvku.
Vše, co je třeba udělat, je opakovat prvky původního pole ve smyčce pro každého(). Každý prvek tohoto pole bude analyzován na klíč ($key) a hodnotu ($value).
Hodnota bude každé z polí umístěných uvnitř hlavního vícerozměrného pole. S těmito hodnotami budeme pracovat a hledat v každém vnitřním poli požadovanou hodnotu prvku.
Po nalezení zobrazíme zprávu, že takový prvek existuje, a pokud ne, zobrazíme další zprávu, že žádný takový prvek neexistuje.
Podívejme se na to vše na příkladu kódu:
"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! Zde prvek!"; else echo "Žádný prvek!"; ?>
Jak vidíte, nejprve deklarujeme samotné vícerozměrné pole.
Zároveň je zde nutné psát nejen rovnítko, ale „.=“.
Děje se tak tak, aby se proměnná $name při každé iteraci nepřepisovala, ale doplňovala. Pokud je totiž při první iteraci prvek nalezen a do proměnné $name se zapíše hodnota „true“ a při druhé iteraci (tj. ve druhém vnitřním poli) není požadovaná hodnota prvku, pak hodnota proměnné $name bude jednoduše přepsána a v důsledku toho prostě nedostaneme správný výsledek.
Jak víte, výsledkem tohoto kódu bude zpráva „OK! Element zde!".
Pokuste se změnit požadovaný prvek na neexistující a zobrazí se zpráva „No have element!“.
Samozřejmě, když je určitý prvek nalezen nebo nenalezen, můžeme nejen zobrazovat zprávy, ale provádět některé další akce. Vše závisí na tom, co musíte udělat. Pokud je například v poli požadovaná hodnota, můžete uživateli poskytnout nějaké konkrétní informace atd.
To je pro dnešek vše! Doufám, že lekce byla jasná a užitečná! Zkuste si podobný kód napsat sami, abyste všemu úplně rozuměli.
A čekám na vaše komentáře.
Sdílejte lekci se svými přáteli pomocí sociálních tlačítek. sítě níže. Přihlaste se také k odběru aktualizací blogu. Už jsme shromáždili docela dobrý archiv užitečných materiálů a budou se jen doplňovat!
Přeji úspěšné programování!
Anna Kotelniková byla s vámi!
Programování je o syntaxi a sémantice. První je určena pravidly jazyka, druhá - zkušenostmi vývojáře. Pokud jde o pole, vývojář může jemně načíst syntaxi se sémantikou. Ještě to není objekt, ale už to není pole v tradičním slova smyslu. PHP vám umožňuje vytvářet pole z proměnných různých typů, včetně vás samotných. Prvek pole může být funkce, to znamená schopnost načíst pole skutečným algoritmem, skutečný význam.
Syntaxe je stabilní, ale mění se verze od verze a nemusí být vždy kompatibilní, a to ani zdola nahoru. Přenositelnost programů je dobře zapomenutým výdobytkem minulého století. Sémantika se vyvíjí a lze ji vždy aplikovat nejen v jakékoli verzi jakéhokoli jazyka; stalo se tradicí používat syntaktické konstrukce k vyjádření věcí, které nebyly ani stanoveny pravidly jazyka. Na příkladu polí to lze pochopit nejjednodušeji.
Konstrukce pole
Pole v PHP má pohodlnou syntaxi a funkčnost. To lze popsat předem, ale často je vhodné vytvářet pole za chodu podle potřeby.
public $aNone = pole(); // pole je popsáno a nic neobsahuje
public $aFact = array("avokádo", "broskev", "třešeň"); // toto pole má tři prvky
Vytvoření pole při kontrole podmínky:
$cSrcLine = "řádek analyzovaných dat";
pro ($i=0; $i<13; $i++) {
if (checkFunc($cSrcLine, $cUserLine) (
$aResult = "Ano"; // přidat do pole PHP
$aResult = "Ne";
V důsledku provedení tohoto příkladu se vytvoří pole 13 prvků, jejichž hodnoty budou pouze řetězce „Ano“ nebo „Ne“. Prvky budou indexovány od 0 do 12. Stejného efektu lze dosáhnout, pokud nejprve zapíšete „budoucí“ pole PHP do řetězce:
$cFutureArray = "";
pro ($i=0; $i<13; $i++) {
$cUserLine = inputUserLine(); // zadejte něco
if ($i > 0) ( $cFutureArray .= "|"; )
if (checkFunc($cSrcLine, $cUserLine) ( $cFutureArray .= "Ano";
) else ( $cFutureArray .= "Ne"; )
$aResult = explode("|", $cFutureArray);
Vícerozměrná pole
Mnoho redakčních systémů (CMS) využívá pole „ve velkém“. Na jednu stranu je to dobrá praxe, na druhou stranu to znesnadňuje aplikaci. I když autor rozumí doktríně „PHP-pole v poli“, pak by se nemělo zneužívat: nejen vývojář si bude muset zvyknout na složitý zápis. Často si po chvíli sám tvůrce bude ještě dlouho pamatovat, co původně napsal:
"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"))
Toto je ukázka PHP array-in-array od ZF 2. Zpočátku to není příliš inspirativní, ale funguje a pravděpodobně dělá tento framework úspěšný (příklad z modulu ZendSkeletonApplication/module/Helloworld/config/module.config.php).
Pole je důležitým datovým konstruktem během návrhu a vývoje. Jeho vícerozměrná varianta byla kdysi populární, ale postupem času potřeba polí maximálně dvou nebo tří rozměrů zůstala. Takto je to jednodušší a přehlednější a z pohledu profesionality, když se něco začne množit, znamená to, že je v problémovém prohlášení nebo v kódu něco špatně.
Jednoduché, dostupné a srozumitelné
Při vytváření pole v poli v php je nejlepší omezit se na dvě nebo tři úrovně. Navzdory stabilitě a spolehlivosti PHP dělá chyby při zpracování syntaktických konstrukcí. Můžete se s tím smířit, pokud máte dobrý editor kódu a zvyknete si na přesné počítání závorek a čárek. PHP však neovládá datové typy (to je karma moderního programování) a umožňuje vývojáři procvičovat sémantické chyby.
Pravidlo kontroly typů proměnných nebo vlastních nápadů přeměny sémantiky na syntax je často nedostupným luxusem. To je ztráta rychlosti skriptu, čitelnosti kódu, ... protože jednoduchost v kódování je vždy zásadní.
PHP má významnou negativní vlastnost: když dojde k nejasnostem, skript se jednoduše zasekne. Ne všechny debuggery zvládají nepředvídané okolnosti a hodně záleží na zkušenostech a intuici vývojáře. Čím jednodušší je algoritmus, tím dostupnější jsou informace strukturované, tím je pravděpodobnější, že najdou chybu nebo ji vůbec neudělají.
Je charakteristické, že když se objevila první pole, byly navrženy datové varianty ve formě struktur - neohrabaný pokus vytvořit něco z různých datových typů. První přežil a získal novou efektivní syntaxi, druhý vešel do historie.
Jednoduchá a asociativní pole
Položka dvourozměrného pole je další dvojice hranatých závorek "[" a "]", například: $aSrcData odkazuje na prvek pole obsažený v poli $aSrcData. V PHP není potřeba deklarovat data předem. Jakékoli deklarované informace lze vždy zkontrolovat.
Je velmi efektivní vytvořit něco, jen když je to potřeba, v podobě, v jaké je to potřeba, a zničit to, když už to není potřeba. Pomocí smysluplných názvů jako klíčů (indexů) můžete získat čitelné konstrukce, které dávají smysl v kontextu aktuálního místa v algoritmu:
$aAnketa["name"] = "Ivanov";
$aAnketa["věk"] = 42;
$aAnketa["work"] = "Ředitel";
$aAnketa["aktivní"] = true;
$aTable = $aAnketa;
$aAnketa["name"] = "Petrov";
$aAnketa["věk"] = 34;
$aAnketa["work"] = "Manažer";
$aAnketa["aktivní"] = true;
$aTable = $aAnketa;
$aAnketa["name"] = "Afanasiev";
$aAnketa["věk"] = 28;
$aAnketa["work"] = "Pracovník";
$aAnketa["aktivní"] = false;
$aTable = $aAnketa;
$sOne .= implode ("; ", $aTable) . "
"; // druhé pole PHP do řetězce
$sOne .= $aTable["práce"]; // přístup k jednomu prvku druhého pole
Výsledek tohoto příkladu (první pole je normální, klíče v něm začínají od 0, druhé pole je asociativní, má čtyři klíče: „jméno“, „věk“, „práce“, „aktivní“):
$sOne = "Petrov; 34; Manažer; 1
Manažer";
Na tomto jednoduchém příkladu můžete vidět, jak lze vytvořený dotazník aplikovat na všechny zaměstnance. Můžete vytvořit pole zaměstnanců s indexy podle osobních čísel a v případě potřeby konkrétního zaměstnance ho vybrat podle osobního čísla.
Pokud má organizace další divize nebo jsou zde sezónní pracovníci nebo potřebujete oddělit pracující důchodce, ... konstrukce „PHP-array-in-array“ je velmi pohodlná, ale nikdy byste se neměli nechat unést dimenzí. Dva nebo tři rozměry jsou limitem pro efektivní řešení.
Klíče pro práci s poli
Jestliže dříve záleželo na tom, jak vše funguje, pak v posledních letech binární éry, kdy chtěl programátor přesně vědět, jak jsou prvky pole uloženy a chtěl k nim mít přímý přístup, se na ně úplně zapomnělo. Objevilo se mnoho kódování znaků, které zabírají mnohem více než jeden bajt v paměti. Slovo „bit“ lze nyní nalézt pouze v operacích vyhledávání bitů, ale hledání v poli PHP je samostatný problém. Přístup k prvkům může být jednoduchý a asociativní. V prvním případě jsou prvky pole (které mají některý z typů dostupných v PHP) očíslovány 0, 1, 2, ... Ve druhém případě programátor specifikuje svůj vlastní index, často nazývaný "klíč" pro přístup k požadovanou hodnotu.
$aLine["ovoce"] = "pomeranč"; // zde klíč pole PHP = "ovoce"
nebo (aby bylo vše v pořádku, respektujte kódování stránky a kódu):
$aLine = iconv("UTF-8", "CP1251", "oranžová");
Při přidávání nové hodnoty do pole $aLine:
$aLine = iconv("UTF-8", "CP1251", "broskev");
$aLine = iconv("UTF-8", "CP1251", "okurka");
$aLine = iconv("UTF-8", "CP1251", "lilek");
jako výsledek smyčky:
foreach ($aLine jako $ck => $cv) (
$cOne .= $ck . "=" . $ cv . "
";
}
obdrží:
ovoce=pomeranč
0=broskev
zelenina=okurka
1 = lilek
PHP-klíč pole se při přidávání prvků „peach“ a „lilek“ tvoří postupně od 0, a když zadáte jeho hodnotu, bude se rovnat této hodnotě.
Odebrání prvků z pole
Nejjednodušší je to při jeho zpracování. V tomto případě se například v důsledku provedení smyčky naskenuje původní pole a vytvoří se nové, do kterého se prostě nezapisují nepotřebné prvky.
Můžete to udělat jednodušeji. Pokud se použije na poslední příklad:
unset($line); // odstranění prvku z pole PHP
pak výsledek bude:
ovoce=pomeranč
zelenina=okurka
1 = lilek
Existuje mnoho možností pro manipulaci s prvky pole. Například pomocí funkcí: implode() a explode() můžete zapsat pole PHP do řetězce s jedním oddělovačem a analyzovat jej zpět do jiného pole pomocí jiného oddělovače.
Chcete-li jednoduše smazat celé pole v PHP, stačí napsat: unset($aLine);
Je to dost.
Hledání pole
PHP poskytuje speciální funkce vyhledávání a in_array(), ale než se je rozhodnete použít, měli byste zvážit vlastní vyhledávání pole PHP.
Jakýkoli projekt je specifické vytvořené pole, zvláště když je část sémantiky přenesena do syntaxe a je reprezentována sadou zcela specifických smysluplných klíčů. To vám umožňuje provádět vlastní vyhledávací funkce, které lze také smysluplně označit.
V PHP můžete volat funkce, jejichž název je určen během provádění programu. Velmi praktická ukázka z knihovny PHPWord, která umožňuje číst a vytvářet dokumenty MS Word:
$elements = array("Text", "Inline", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Tabulka", "Obrázek", "Objekt", "Poznámka pod čarou",
"Koncová poznámka", "Zaškrtávací políčko", "Textové pole", "Pole", "Řádek");
$funkce = pole();
pro ($i = 0; $i< count($elements); $i++) {
$functions[$i] = "přidat" . $elements[$i];
}
V důsledku toho pole $functions obdrží hodnoty pole $elements, tedy názvy skutečných funkcí, které pracují se skutečnými prvky dokumentu.
Voláním funkce $functions na $elements můžete získat perfektní vyhledávání a rychlý výsledek.
Řazení prvků
Důležitá je úloha třídění dat a PHP k tomu poskytuje několik funkcí: sort(), rsort(), asort(), ksort(), ... Vzestupné a sestupné prvky, druhé dvě funkce ukládají vztah mezi klíči a hodnoty. Někdy má smysl náhodně zamíchat hodnoty pole - shuffle().
Při používání funkcí PHP pro řazení by se nemělo zapomínat, že prvky mohou mít nejen jiný typ, ale také ne zcela přirozený obsah. Nejprve musíte být velmi opatrní při řazení řetězců obsahujících ruská písmena, řazení dat a čísel, která jsou napsána v různých formátech.
Nejlepší způsob, jak napsat vlastní dokonalé řešení, alespoň ve fázi testování skriptu, je ruční řazení. Pomůže předvídat nepředvídatelné situace.
Pole řetězců
Díky funkcím implode() a explode() lze pole snadno přeměnit na řetězec a získat zpět. To vám umožní ukládat data v kompaktním zobrazení a podle potřeby je rozšířit do vhodného stavu.
Pole převedené na řetězec otevírá nové možnosti. Například úloha hledání klíčových slov v textu vyžaduje, aby se nalezené znovu nepřidávalo.
$cSrcLine = "Text Text ListItemSpustit TextBox ListItem TextBox Zaškrtávací políčko Zaškrtávací políčko TextBox Poznámka pod čarou";
$aSrc = explode(" ", $cSrcLine);
$cDstLine = "";
pro ($i=0; $i< count($aSrc); $i++) {
$cFind = "[" . $aSrc[$i] . "]";
if (! is_integer(strpos($cDstLine, $cFind))) (
$cDstLine .= $cFind;
}
}
$aDst = explode("][", $cDstLine);
$cOne = implode("; ", $aDst);
Výsledkem je, že proměnná $cOne obdrží pouze ty hodnoty ze zdrojového řetězce, které se tam vyskytují jednou: "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Poznámka pod čarou".
Ruský jazyk v klíčích a hodnotách
V syntaktických konstruktech se nedoporučuje používat nic, co souvisí s národním kódováním. Ruský jazyk, stejně jako všechny ostatní jazyky, jejichž znaky přesahují a-z, nezpůsobí problémy v oblasti dat, ale ne v syntaxi kódu. Někdy dokonce i jednoduchá úloha PHP „vytisknout pole na tiskárnu nebo obrazovku“ povede k „zhroucení“ a častěji jednoduše zastaví skript.
PHP je loajální jazyk a je tolerantní k národním kódování, ale existuje mnoho situací, kdy se množství vykonané práce musí udělat znovu jen proto, že se na správném místě a ve správný čas objeví klíčová hodnota, kterou nelze rozpoznat.
PHP syntaxe a jazykové prostředí
Je třeba připomenout, že syntaxe PHP je jedna věc, ale konstrukce této syntaxe se „zabývají“ jinými aplikacemi, operačním systémem, hardwarovými možnostmi. Možností je mnoho, nikdy nelze předvídat vše.
Pravidlo „v kódu je pouze kód a na vstupu, uvnitř a na výstupu jsou jakékoli informace“ pomůže předejít nepředvídaným překvapením. Hodnota PHP v poli může být „ruská“, ale klíč k ní musí být syntakticky správný nejen z hlediska daného jazyka, ale i z hlediska jeho prostředí.
Jednou ze základních operací při práci s poli je nalezení konkrétní hodnoty. K tomu slouží funkce PHP array_search(). Je schopen pracovat s jednorozměrnými i asociativními kolekcemi a vrací klíč vyhledávací hodnoty, pokud je v poli nalezen.
Syntax
Formalizovaný popis funkce array_search() v PHP je následující:
smíšené pole_search (smíšená hodnota, pole $collection [, bool strict])
Vstupní parametry:
- $collection - pole, které se má prohledávat;
- hodnota - požadovaná hodnota libovolného typu;
- strict je volitelný booleovský příznak, který nastavuje přísný mechanismus porovnávání podle typu.
Pracovní mechanismus
Funkce PHP array_search() postupně porovnává hodnotu se všemi hodnotami v poli kolekce. Standardně se porovnání provádí bez zohlednění typů operandů. Toto nastavení lze změnit nastavením příznaku strict na hodnotu TRUE. Porovnání řetězců rozlišuje malá a velká písmena.
Pokud je nalezena shoda, je vrácen klíč odpovídající nalezenému prvku a funkce je ukončena. Nelze jej tedy použít k detekci více výskytů požadované hodnoty v poli.
Pokud není nalezena žádná shoda, funkce vrátí booleovskou hodnotu FALSE.
Měli byste zkontrolovat vrácený výsledek pomocí operátoru přísné rovnosti (===). To je důležité, protože funkce může vrátit hodnotu, která se vyhodnotí jako FALSE, například 0 nebo prázdný řetězec.
Příklady použití
Příklad 1. Při předávání vícerozměrného pole funkci PHP array_search() bude výsledkem práce klíč hledaného prvku.
"zima", "sezóna2" => "jaro", "sezóna 3" => "léto", "sezóna4" => "podzim"); $result1 = array_search("zima", $pole); $result2 = array_search("léto", $pole); $result3 = array_search("duben", $array); ?>
V tomto příkladu bude $result1 nastaven na "sezóna1", $result2 bude nastaven na "sezóna3" a $result3 bude nastaven na booleovskou hodnotu FALSE, protože řetězec "duben" se v původním poli nevyskytuje.
Příklad 2 Funkce PHP array_search() může také zpracovat jednorozměrné pole, přičemž jeho klíče považuje za další číselné indexy v pořadí.
Proměnná $result bude nastavena na 1, podle indexu prvku "hunter" v poli $array.
Příklad 3. Možná chyba v analýze výsledku.
"Washington", 1 => "Adams", 2 => "Jefferson", 3 => "Madison", 4 => "Monroe"); $result = array_search("Washington", $presidents); if (!$result) ( echo "G. Washington nebyl prvním prezidentem USA"; ) ?>
Takže bez kontroly výsledku s přísnou rovností můžete dostat nečekanou zprávu, že George Washington nebyl prvním prezidentem Spojených států.
Příklad 4: Je vrácen pouze klíč první nalezené shody.
I když se hledaná hodnota vyskytuje v poli třikrát, funkce vrátí pouze první nalezený výsledek - 0. Pro hledání více shod se doporučuje použít funkci PHP array_keys().