PHP: array_search - rychlé vyhledávání v poli. PHP array_search: hledání hodnoty v poli Php hledá prvek pole podle názvu
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 specificky načíst syntaxi se sémantikou. Toto ještě není objekt, ale už to není pole v tradičním slova smyslu. PHP vám dává možnost vytvářet pole proměnných různých typů, včetně nich samotných. Element 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í toho, co nebylo ani stanoveno pravidly jazyka. To lze nejsnáze pochopit na příkladu polí.
Konstrukce polí
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 = "analyzovaný datový řádek";
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 obdrží indexy od 0 do 12. Stejného efektu lze dosáhnout, když 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 systémů pro správu obsahu (CMS) využívá pole ve velkém. Na jednu stranu je to dobrá praxe, na druhou stranu to znesnadňuje použití. I když autor rozumí doktríně „PHP pole v poli“, neměl by ji zneužívat: na složitý zápis si bude muset zvyknout nejen vývojář. Sám tvůrce si často po chvíli bude 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 příklad praxe „PHP pole v poli“ ze ZF 2. Zpočátku nepříliš inspirativní, ale funguje a pravděpodobně činí tento framework úspěšným (příklad z 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á verze byla kdysi populární, ale postupem času zůstala potřeba polí maximálně dvou nebo tří rozměrů. Takto je to jednodušší a přehlednější a z profesionálního hlediska, 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ě. I přes stabilitu a spolehlivost PHP dělá chyby při zpracování syntaktických struktur. 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 pro ovládání typů proměnných nebo vlastních nápadů pro přeměnu sémantiky na syntax je často nedostupný luxus. 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ž nastane nejistota, skript prostě zamrzne. Ne každý debugger si poradí s nepředvídatelnými okolnostmi 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 větší je šance na nalezení chyby nebo její úplné zabránění.
Je charakteristické, že když se objevila první pole, byly navrženy varianty dat 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, zatímco druhý se stal historií.
Jednoduchá a asociativní pole
Zápis pro dvourozměrné pole je další dvojice závorek "[" a "]", například: $aSrcData znamená přístup k prvku pole obsaženému v poli $aSrcData. V PHP není potřeba deklarovat data předem. Existenci jakékoli uvedené informace lze vždy ověřit.
Je velmi efektivní vytvořit něco, jen když je to potřeba, v podobě, v jaké to bylo požadováno, a zničit to, když to potřeba pomine. Pomocí smysluplných názvů jako klíčů (indexů) můžete získat čitelné konstrukce, které jsou smysluplné 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"] = "Afanasyev";
$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";
Tento jednoduchý příklad ukazuje, 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 pokud potřebujete konkrétního zaměstnance, tak jej vybrat podle osobního čísla.
Pokud má organizace divize nebo jsou zde sezónní pracovníci nebo potřebujete samostatně identifikovat pracující důchodce, ... design „PHP pole v poli“ 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 je vše uspořádáno, pak byly v posledních letech zcela zapomenuty tradice binární éry, kdy programátor chtěl vědět, jak přesně jsou prvky pole uloženy a chtěl k nim mít přímý přístup. Objevilo se mnoho kódování znaků, která zabírají 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í pole PHP je samostatné téma. 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. požadovanou hodnotu.
$aLine["ovoce"] = "oranžová"; // zde klíč pole PHP = "ovoce"
nebo (aby bylo vše v pořádku a respektovalo kódování stránky a kód):
$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 provedení smyčky:
foreach ($aLine jako $ck => $cv) (
$cOne .= $ck . "=" . $ cv . "
";
}
bude přijato:
ovoce=pomeranč
0=broskev
zelenina=okurka
1 = lilek
Klíč pole PHP se při přidávání prvků „peach“ a „eggplant“ tvoří postupně od 0 a při zadání jeho hodnoty se bude rovnat této hodnotě.
Odstraně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 nepotřebné prvky jednoduše nezapisují.
Mohlo by to být jednodušší. Pokud použijeme poslední příklad:
unset($aLine); // odstranění prvku 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.
Hledat v poli
PHP obsahuje speciální funkce vyhledávání a in_array(), ale než se je rozhodnete použít, měli byste zvážit, zda sami neprovedete prohledávání pole PHP.
Každý projekt má specifická vytvořená pole, zvláště když je část sémantiky přenesena do syntaxe a je reprezentována sadou velmi specifických smysluplných klíčů. To vám umožní 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 $functions na $elements můžete získat perfektní vyhledávání a rychlé výsledky.
Třídění položek
Úloha třídění dat je důležitá a PHP k tomu nabízí několik funkcí: sort(), rsort(), asort(), ksort(), ... vzestupné a sestupné prvky, druhé dvě funkce ukládají vztahy mezi klíči a hodnotami . Někdy má smysl náhodně zamíchat hodnoty pole - shuffle().
Při používání funkcí PHP pro řazení byste neměli zapomínat, že prvky mohou mít nejen různé typy, 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 si sami napsat ideální řešení, alespoň ve fázi testování skriptu, je ruční řazení. Pomůže předvídat nepředvídatelné situace.
String Arrays
Díky funkcím implode() a explode() lze pole snadno přeměnit na řetězec a vrátit jej zpět. To vám umožní uložit data v kompaktní reprezentaci a rozšířit je do vhodného stavu podle potřeby.
Pole převedené na řetězec otevírá nové možnosti. Například úkol 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 objeví jednou: "Text; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; Poznámka pod čarou".
Ruský jazyk v klíčích a významech
V syntaktických strukturách se nedoporučuje používat nic souvisejícího s národním kódováním. Ruština, stejně jako všechny ostatní jazyky, jejichž znaky přesahují a-z, nezpůsobí problémy, protože je v oblasti dat, ale ne v syntaxi kódu. Někdy i jednoduchý úkol v PHP „vytisknout pole na tiskárnu nebo na obrazovku“ povede k „šíleným chybám“ a častěji se skript jednoduše zastaví.
PHP je loajální jazyk a je tolerantní k národním kódováním, ale existuje mnoho situací, kdy je nutné provést dokončené množství práce znovu jen proto, že klíčová hodnota se objeví na správném místě a ve správný čas, což není možné. uznat.
Syntaxe PHP a jazykové prostředí
Je třeba si uvědomit, že syntaxe PHP je jedna věc, ale konstrukce této syntaxe se „zabývají“ jinými aplikacemi, operačním systémem a hardwarovými možnostmi. Možností je mnoho, nikdy není možné zajistit vše.
Pravidlo „v kódu je pouze kód, ale na vstupu, uvnitř a na výstupu jsou nejrůznější informace“ pomůže vyhnout se nepředvídatelný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 také z hlediska jeho operačního prostředí.
Jednou z hlavních operací při práci s poli je hledání konkrétní hodnoty. K tomu je určena funkce PHP array_search(). Je schopen zpracovávat jak jednorozměrné, tak asociativní kolekce, přičemž vrací klíč hledané 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, ve kterém bude vyhledávání provedeno;
- hodnota - požadovaná hodnota libovolného typu;
- strict je volitelný booleovský příznak, který nastavuje přísný mechanismus porovnávání podle typu.
Mechanismus provozu
Funkce PHP array_search() porovnává hodnotu jednu po druhé se všemi hodnotami v poli kolekce. Standardně se porovnání provádí bez ohledu na typy operandů. Toto nastavení lze změnit nastavením příznaku striktní na hodnotu TRUE. Porovnání řetězců rozlišuje malá a velká písmena.
Pokud je nalezena shoda, vrátí se klíč odpovídající nalezenému prvku a funkce se zastaví. Proto jej nelze použít k detekci více výskytů požadované hodnoty v poli.
Pokud nebudou nalezeny žádné shody, 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 přetypovanou na 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óna3" => "léto", "sezóna4" => "podzim"); $vysledek1 = pole_search("zima", $pole); $result2 = array_search("léto", $pole); $result3 = array_search("duben", $pole); ?>
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 ve zdrojovém poli neobjeví.
Příklad 2. Funkce PHP array_search() může také zpracovat jednorozměrné pole, přičemž jeho klíče považuje za následující číselné indexy.
Proměnná $result bude nastavena na 1, podle indexu prvku "hunter" v poli $array.
Příklad 3. Možná chyba při 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 nalezení více shod se doporučuje použít funkci PHP array_keys().
Hledání hodnoty v poli vyžaduje téměř každá PHP aplikace a skript pracující s daty, na což existuje mnoho metod a speciálních funkcí. V závislosti na úkolu a typu vyhledávání byste měli používat určité nástroje s ohledem na jejich vlastnosti, rychlost provádění a snadnost použití. Dále se seznámíme s PHP funkcemi pro vyhledávání prvků v poli, možnými konstrukcemi a metodami a také zjistíme, která metoda je nejrychlejší.
Funkce pro vyhledávání v poli:
pole_search- používá se k hledání hodnoty v poli. Pokud je úspěšný, vrátí klíč hledané hodnoty, pokud není nic nalezeno, vrátí FALSE. Před PHP 4.2.0 vracelo array_search() při selhání NULL místo FALSE.
Syntaxe funkce smíšené pole_search (mixed needle, pole haystack [, bool strict]).
foreach (array_expression as $value)
prohlášení
foreach (array_expression as $key => $value)
prohlášení
Příklad použití funkce s konstrukcí foreach k vyhledání prvku pole, přičemž při úspěchu vrátí hodnotu TRUE
Syntaxe konstrukce
zatímco (expr)
prohlášení
Při úspěchu vrátí klíč prvku pole
Z tabulky měření je vidět, že funkce pole_search, ukazuje nejlepší výsledky při vyhledávání v malých i velkých polích. Zároveň se výrazně prodlužuje doba vyhledávání pomocí smyček v závislosti na velikosti pole.
Funkci array_search() používám poměrně dlouho k hledání hodnot v poli, protože jsem opakovaně slyšel a četl, že funguje znatelně rychleji než prohledávání pole ve smyčce, ale neudělal jsem to. vědět, jak je to rychlejší. Konečně jsem se dostal k tomu, abych to zkontroloval a počítal sám.
Porovnal jsem rychlost prohledávání pole pomocí této funkce s obvyklým prohledáváním pole v cyklech foreach a while. Na 10-100 prvcích pole je rozdíl nepozorovatelný a čas je tak krátký, že jej lze zanedbat. Ale pro velká pole se rozdíl ukázal jako docela významný. Jak se velikost pole řádově zvětšila, výrazně se prodloužila i doba vyhledávání. Se sto tisíci prvky klesla rychlost foreach na 0,013 sekundy a zatímco – na 0,017, zatímco array_search() se také zpomalilo, ale stále zůstalo o řád rychlejší – 0,004 sekundy. U velkého skriptu pracujícího s velkými poli nebude nahrazení hledání ve smyčce hledáním pomocí array_search() vůbec „optimalizací proti blechám“.
V tomto ohledu jsem si vzpomněl na nedávnou diskuzi s jedním mým kolegou v práci o tom, zda programátor potřebuje znát všechny tyto vestavěné jazykové funkce, 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 existují a co obecně umí.
UPD: potřebujete také myšlení programátora! A pozor na paměť neuškodí (inspirováno breakem a dosahem:)
Pod hackem je kód skriptu, který byl použit k výpočtu času:
$hmotnost=100000; // počet hodnot v poli, ve kterém budeme hledat
$hledat=50000; // tuto hodnotu budeme hledat v poli
$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řte a vyplňte pole
$test_array = rozsah(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ěrných hodnot
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 počítání času
// zápis do pole hodnot
$first_result= $time_end - $time_start;
//*************** Vyhledávání v poli se smyčkou foreach *******************
// Začněte počítat čas
$time_start = microtime(1);
// samotné vyhledávání
foreach ($test_array jako $ta)
{
if ($ta==$search)
{
echo $ta;
přestávka;
}
}
$time_end = microtime(1);
// konec počítání času
// zápis do pole hodnot
$second_result= $time_end - $time_start;
//*************** Prohledávat pole pomocí smyčky while *******************
// Začněte počítat čas
$time_start = microtime(1);
// určení délky pole
$pocet=pocet($test_pole);
$j=0;
// samotné vyhledávání
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 počítání času
// zápis do pole hodnot
$third_result= $time_end - $time_start;
}
$srednee1=součet_pole($první_výsledek)/počet($první_výsledek);
$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í dokončený kód v průměru: %.7f sekund", $srednee1);
printf("druhý kód dokončen v průměru za: %.7f sekund", $srednee2);
printf("třetí kód dokončen v průměru za: %.7f sekund", $srednee3);
// výsledek:
// první kód dokončen v průměru: 0,0000295 sekund
// druhý kód dokončen v průměru: 0,0153386 sekund
// třetí kód dokončen v průměru: 0,0226001 sekund
z vícerozměrných (18)
Upravil jsem jeden z níže uvedených příkladů pro popis funkce array_search. Funkce searchItemsByKey vrací všechny hodnoty pomocí $key z vícerozměrného pole (N úrovní). Možná by se to někomu hodilo. Příklad:
$arr = array("XXX"=>array("YYY"=> array("AAA"=> array("keyN" =>"value1")), "ZZZ"=> array("BBB"=> pole ("keyN" => "value2")) //.....)); $vysledek = searchItemsByKey($arr,"keyN"); tisk "
"; print_r($výsledek); tisknout ""; // OUTPUT Array ( => hodnota1 => hodnota2)Kód funkce:
Funkce searchItemsByKey($array, $key) ( $results = array(); if (is_array($array)) ( if (isset($array[$key]) && key($array)==$key) $results = $array[$key] foreach ($array jako $sub_array) $results = array_merge($results, searchItemsByKey($sub_array, $key));
Mám pole, kde chci vyhledat uid a získat klíč pole.
Příklady
Předpokládejme, že máme následující dvourozměrné pole:
$userdb = array(array("uid" => "100", "name" => "Sandra Shush", "pic_square" => "urlof100"), array("uid" => "5465", "name" => "Stefanie Mcmohn", "pic_square" => "urlof100"), array("uid" => "40489", "name" => "Michael", "pic_square" => "urlof40489"));
Volání search_by_uid(100) (uid prvního uživatele) by mělo vrátit 0.
Volání funkce search_by_uid(40489) by mělo vrátit 2 .
Zkoušel jsem vytvářet smyčky, ale potřebuji rychlejší spustitelný kód.
Na základě Jakubovy vynikající odpovědi je zde obecnější vyhledávání, které vám umožní zadat klíč (nejen pro uid):
Funkce searcharray($value, $key, $array) ( foreach ($array jako $k => $val) ( if ($val[$key] == $value) (return $k; ) ) return null ;
Použití: $results = searcharray("searchvalue", searchkey, $array);
Funkce searchForId($id, $array) ( foreach ($array jako $key => $val) ( if ($val["uid"] === $id) ( return $key; ) ) return null; )
Bude to fungovat. Měli byste to nazvat takto:
$id = searchForId("100", $userdb);
Je důležité vědět, že pokud použijete === porovnávané typy operátorů musí být přesně stejné, v tomto příkladu musíte hledat řetězec nebo jen použít == místo === .
Na základě odpovědi angora. V novějších verzích PHP (>= 5.5.0) můžete použít jednořádkový.
$key = array_search("100", array_column($userdb, "uid"));
I když je to stará otázka a existuje přijatá odpověď, myslel jsem, že navrhnu jednu změnu přijaté odpovědi. Tak za prvé souhlasím, že zde přijatá odpověď je správná.
Funkce searchArrayKeyVal($sKey, $id, $array) ( foreach ($array jako $key => $val) ( if ($val[$sKey] == $id) ( return $key; ) ) return false; )
Místo toho nahraďte přednastavené "uid" parametrem ve funkci, takže volání níže uvedeného kódu znamená, že můžete použít jednu funkci pro více typů polí. Malá změna, ale je to trochu jinak.
// Data pole uživatelů $userdb = pole (pole ("uid" => "100","name" => "Sandra Shush","url" => "urlof100"), pole ("uid" => " 5465","name" => "Stefanie Mcmohn","url" => "urlof100"), pole ("uid" => "40489","name" => "Michael","url" => "urlof40489" "),); // Získání klíče pole $arrayKey = searchArrayKeyVal("uid", "100", $userdb); if ($arrayKey!==false) ( echo "Výsledek hledání: ", $userdb[$arrayKey]["název"]; ) else ( echo "Výsledek hledání nelze nalézt"; )
If(! function_exists("arraySearchMulti"))( function arraySearchMulti($search,$key,$array,$returnKey=false) ( foreach ($array jako $k => $val) ( if (isset($val[$ klíč])) ( if ((řetězec)$val[$klíč] == (řetězec)$hledat) ( return ($returnKey ? $k: $val); ) )else( return (is_array($val) ? arraySearchMulti ($search,$key,$val,$returnKey) : null ) ) return null ))
můžete použít tuto funkci; https://github.com/serhatozles/ArrayAdvancedSearch
="2""; $Array = array("a" => array("d" => "2"), array("a" => "Example World","b" => "2"), pole("c" => "3"), pole("d" => "4"),); $Result = ArraySearch($Array,$dotaz,1);
"; print_r($Result); echo ""; // Výstup: // Pole // (// => Pole // (// [a] => Příklad světa // [b] => 2 //) // //)Pokud je otázka, tzn.
$a = [ [ "_id" => "5a96933414d48831a41901f2", "částka_slevy" => 3,29, "id_slevy" => "5a92656a14d488570c2c44a2", ], [5a979d" => "1" discount_amount" => 4,53, "ID_slevy" => "5a9265b914d488548513b122", ], [ "_id" => "5a98083614d488191304b6c3", "částka_slevy" => 15,24, "id_slevy" => 805 d253 id" > "5a982a4914d48824721eafe3", "částka_slevy " => 45,74, "id_slevy" => "5a928ce414d488609e73b443", ], [ "_id" => "5a982a4914d48824721eafe55", "částka_slevy" => 86215a5a39,08626,049 b4 43", ], ];
Funkce searchForId($id, $array) ( $did=0; $dia=0; foreach ($array jako $klíč => $val) ( if ($val["discount_id"] === $id) ( $ dia +=$val["částka_slevy"]; $did++; ) if($dia != "") ( echo $dia; var_dump($did); ) return null); print_r(searchForId("5a928ce414d488609e73b443",$a));
Zkuste to také
Funkce search_in_array($srchvalue, $array) ( if (is_array($array) && count($array) > 0) ( $foundkey = array_search($srchvalue, $array); if ($foundkey === FALSE) ( foreach ($array jako $key => $value) ( if (is_array($value) && count($value) > 0) ( $foundkey = search_in_array($srchvalue, $value); if ($foundkey != FALSE ) return $foundkey;
$a = ["x" => ["eee", "ccc"], "b" => ["zzz"]]; $nalezeno = null; $hledat = "eee"; array_walk($a, funkce ($k, $v) use ($search, &$found) ( if (in_array($search, $k)) ( $found = $v; ) )); var_dump($nalezeno);
Tady je jedna vložka na stejnou věc,
$pic_square = $userdb["pic_square"];
Zde je můj příklad a všimněte si, že toto je moje první odpověď. Vyjmul jsem pole param, protože jsem potřeboval hledat pouze jedno konkrétní pole, ale můžete je snadno přidat. Chtěl jsem v podstatě hledat víc než jen uid.
V mé situaci také může existovat více klíčů, které se mají vrátit v důsledku hledání podle jiných polí, která nemusí být jedinečná.
/** * @param pole multidimenzionální * @param řetězcová hodnota k vyhledání, tj. konkrétní název pole, jako je jméno_first * @param řetězec asociativní klíč, ve kterém se má najít, tj. pole_name * * @return klíče pole. */ function search_revisions($dataArray, $search_value, $key_to_search) ( // Tato funkce prohledá revize pro určitou hodnotu // související s asociativním klíčem, který hledáte. $keys = array(); foreach ($dataArray jako $klíč => $cur_value) (if ($cur_value[$key_to_search] == $search_value) ($keys = $key; ) ) return $keys;
Později jsem skončil s psaním tohoto, abych mohl hledat jinou hodnotu a asociativní klíč. Můj první příklad vám tedy umožňuje vyhledat hodnotu v jakémkoli konkrétním asociativním klíči a vrátit všechny shody.
Tento druhý příklad ukazuje, kde se hodnota ("Taylor") nachází v konkrétním klíči přidružení (first_name). A jiná hodnota (true) je nalezena v jiném asociativním klíči (použito) a vrátí všechny shody (klíče, ve kterých jsou použity osoby jménem "Taylor" AND).
/** * @param pole multidimenzionální * @param string $search_value Hodnota, která se má hledat, tj. konkrétní "Taylor" * @param string $key_to_search Asociativní klíč, ve kterém se má najít, tj. jméno * @param string $other_matching_key Asociativní klíč, který se má najít ve shodách pro zaměstnané * @param string $other_matching_value Hodnota, která se má najít v tom odpovídajícím asociativním klíči, tj. true * * @return klíče pole, tj. všichni lidé s křestním jménem "Taylor", kteří jsou zaměstnáni. */ function search_revisions($dataArray, $search_value, $key_to_search, $other_matching_value = null, $other_matching_key = null) ( // Tato funkce vyhledá revize pro určitou hodnotu // související s asociativním klíčem, který hledáte. $ keys = array(); foreach ($dataArray jako $key => $cur_value) ( if ($cur_value[$key_to_search] == $search_value) ( if (isset($other_matching_key) && isset($other_matching_value) ) ( if ( $cur_value[$other_matching_key] == $other_matching_value) ( $keys = $key; ) ) else ( // Musím mít na paměti, že některá vyhledávání mohou mít více // shod a jiná ne, takže ponechte jej otevřené bez pokračování . $keys = $keys;
Pomocí funkce
$data = array(array("cust_group" => 6, "price" => 13,21, "price_qty" => 5), array("cust_group" => 8, "price" => 15,25, "price_qty" => 4), array("cust_group" => 8, "price" => 12,75, "price_qty" => 10)); $findKey = search_revisions($data,"8", "cust_group", "10", "price_qty"); print_r($findKey);
Výsledek
Pole ( => 2)
/** * prohledává jednoduché i vícerozměrné pole * @param typ $needle * @param typ $haystack * @return boolean */ veřejná statická funkce in_array_multi($needle, $haystack)( $needle = trim($needle ); if(!is_array($haystack)) return False($haystack as $key=>$value)( if(is_array($value))( if(self::in_array_multi($needle, $value))); return True; else self::in_array_multi($needle, $value) else if(trim($value) === trim($needle))(//oprava viditelnosti// error_log("$value === $ viditelnost jehly) nastavení na 1 hidden"); return True; ) ) return False; )
Pokud používáte (PHP 5>=5.5.0), nemusíte pro to psát vlastní funkci, stačí napsat tento řádek a máte hotovo.
Pokud chcete pouze jeden výsledek:
$key = array_search(40489, array_column($userdb, "uid"));
Pro více výsledků
$keys = array_keys(array_column($userdb, "uid"), 40489);
Pokud máte asociativní pole, jak je uvedeno v komentářích, můžete to udělat pomocí:
$keys = array_keys(array_combine(array_keys($userdb), array_column($userdb, "uid")),40489);
Pokud používáte PHP<5.5.0, вы можете использовать этот backport , спасибо ramsey!
Aktualizace. Dělám pár jednoduchých testů a formulář s více výsledky se zdá být nejrychlejší, dokonce rychlejší než Jakubova vlastní funkce!
V novějších verzích PHP (>=5.5.0) můžete použít tento jednořádkový:
$key = array_search("100", array_column($userdb, "uid"));
Když rozšíříme funkci vytvořenou @mayhem, tento příklad by byl spíše „fuzzy“ vyhledávání, pokud byste jen chtěli porovnat část ( velkýčást) vyhledávací řetězce:
Funkce searchArrayKeyVal($sKey, $id, $array) ( foreach ($array jako $klíč => $val) ( if (strpos(strtolower($val[$sKey]), strtolower(trim($id))) ! == false) ( return $key; ) ) return false )
Například hodnota v poli je Vítejte v New Yorku! a potřebujete pouze první kopii "New York!"
Musel jsem použít funkci un, která najde všechny prvky v poli. Upravil jsem tedy funkci vykonávanou Jakubem Trunečkem takto:
Funkce search_in_array_r($needle, $array) ( $found = array(); foreach ($array jako $key => $val) ( if ($val == $needle) ( array_push($found, $val); ) ) if (počet($nalezeno) != 0) return $nalezeno else return null;
$search1 = "demo"; $hledat2 = "bob"; $arr = array("0" => "ahoj","1" => "test","2" => "john","3" => array("0" => "martin", "1" " => "bob"),"4" => "demo"); foreach ($arr jako $value) (if (is_array($value)) ( if (in_array($search2, $value)) ( echo "úspěšně"; //proveďte svůj kód ) ) else ( if ($value == $search1) ( echo "úspěch"; ) ) )
Pokud je to možné, zadejte typy parametrů. Funguje ale pouze s jednoduchými typy jako int, bool a float.
$unsafe_variable = $_POST["id_uživatele"]; $safe_variable = (int)$unsafe_variable ; mysqli_query($conn, "INSERT INTO tabulky (sloupce) VALUES ("" . $safe_variable . "")");
