A PHP-tömbben lévő érték jelenlétének ellenőrzése. PHP: Array_Search - Gyorskeresés a PHP tömb által az érték szerint

A tömbben lévő értékek keresése szinte minden PHP alkalmazásban szükséges, az adatokkal dolgozó adatok szkriptje, amelyre számos módon és speciális funkciók létezik. A feladatot és a keresés típusától függően bizonyos eszközöket kell használni, tekintettel a funkciókra, a végrehajtás sebességére és a használatra. Ezután megismerkedünk a PHP funkciókkal a tömbelemek, a lehetséges tervek és módszerek kereséséhez, valamint kiderítve, hogy milyen módszer a leggyorsabb.

A keresési funkciók a tömbben:
array_Search. - az értékek keresésére használják a tömbben. Ha jó, akkor visszaadja a kívánt érték kulcsát, ha semmi sem található - hamis. A PHP 4.2.0 verziója előtt, Array_Search (), a hiba, null visszatért, nem hamis.

Vegyes Array_Search szolgáltatás Szintaxis (vegyes tű, tömb szénakazal [, bool szigorú]).

foreach (Array_Expression mint $ érték)
Nyilatkozat
Foreach (Array_Expression, mint $ key \u003d\u003e $ érték)
Nyilatkozat

Példa a FAACH funkció használatára egy tömbelem kereséséhez, akkor igaz, ha sikeres

Építési szintaxis
Míg (expr)
Nyilatkozat

Visszaadja a tömbelem esetét, ha sikeres

A fenti mérési táblázatból látható, hogy a funkció array_Search., a legjobb eredményt mutatja, mint a kis és nagy tömbök keresése során. Ugyanakkor a ciklusok sorozatának keresési ideje jelentősen növekszik a tömb méretétől függően.

(PHP 4\u003e \u003d 4.0.5, PHP 5)

array_Search - Keresése ezt az értéket a tömbben, és ha jó szerencsét ad meg a megfelelő kulcsot

Leírás

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

Keresi a Haystackban a tű értékét, és visszaadja a kulcsot, ha így van jelen a tömbben, Hamis másképp.

Megjegyzés: Ha a tű egy karakterlánc, egy regiszterfüggő összehasonlítás történik.

Megjegyzés: A PHP 4.2.0-re, array_Search () Ha lehetséges, visszatért NULLA helyette Hamis .

Ha átadja az értéket Igaz. opcionális harmadik szigorú paraméterként, funkcióként array_Search () Ellenőrizze a Típus tűt a Haystack Array-ben.

Ha a tű a szénakazalban van jelen, többször is, az első kulcsot vissza fogják adni. Annak érdekében, hogy visszaadja a kulcsokat az összes talált értékhez, használja a funkciót array_keys () Opcionális Search_Value paraméterrel.

1. példa Példa a használatra array_Search () $ Array \u003d Array (0 \u003d\u003e "kék", 1 \u003d\u003e "piros", 2 \u003d\u003e 0x000000, 3 \u003d\u003e "zöld", 4 \u003d\u003e "piros"); $ Key \u003d Array_Search ("piros", $ tömb ); // $ billentyű \u003d 1; $ Key \u003d Array_Search ("zöld", $ tömb); // $ billentyű \u003d 2; (0x000000 \u003d\u003d 0 \u003d\u003d zöld ") $ Key \u003d Array_Search ("zöld", $ tömb, igaz); // $ billentyű \u003d 3; ?>

Figyelem

Ez a funkció logikai értékként visszatérhet. Hamis és nem kapcsolódik a megadott logikai típushoz Hamis , például 0 vagy "". További információért olvassa el a Boulev típusú részt. Használja a \u003d\u003d\u003d nyilatkozatot, hogy ellenőrizze az e funkció által visszaküldött értéket.

Az egyik fő művelet, amikor a tömbökkel dolgozik, egy adott érték keresése. Ebből a célból a PHP Array_Search () funkció. Képes feldolgozni az egydimenziós és asszociatív gyűjteményeket, visszaadja a kívánt érték kulcsát, ha a tömbben megtalálható.

Szintaxis

Az Array_Search () funkció a PHP-ben történő formalizált leírása a következő:

Vegyes Array_Search (vegyes érték, Array $ Collection [, Bool szigorú])

Bemeneti paraméterek:

• $ Gyűjtemény - olyan tömb, amelyben a keresés megtörténik;
• az érték bármely típusú kívánt érték;
• a szigorú egy opcionális logikai zászló, amely a típusokon alapuló szigorú összehasonlító mechanizmust hoz létre.

Munkamódszer

A PHP Array_Search () függvény felváltva összehasonlítja az értéket az összes értékkel a gyűjtemény tömbben. Alapértelmezés szerint az összehasonlítás az operandusok típusát figyelembe véve. Ez a beállítás módosítható az igazság értékének beállításával. A karakterláncok összehasonlítása a nyilvántartás tekintetében történik.

Amikor a véletlenséget észleli, a megtalált elemnek megfelelő kulcsot visszaküldik, és a funkció működése megáll. Ezért lehetetlen észlelni a kívánt érték többszörös bejutását egy tömbbe.

Ha nincs találat, akkor a funkció visszaadja a logikai értéket.

Ellenőrizze, hogy a visszaküldött eredménynek szigorú egyenlőségi szolgáltatót kell használnia (\u003d\u003d\u003d). Ez fontos, mivel a funkció visszaadhat egy értéket, amelyet hamis, például 0 vagy üres karakterlánc kap.

Példák a használatra

1. példa Multidimenzionális tömb továbbítása a PHP Array_Search () funkcióhoz, a munka eredménye a kívánt elem kulcsa.

"Tél", "Season2" \u003d\u003e "tavasz", "szezon" \u003d\u003e "nyári", "szezon" \u003d\u003e "ősz"); $ Eredmény \u003d Array_Search ("Tél", $ tömb); $ Eredmény \u003d Array_Search ("Nyári", $ tömb); $ eredmény \u003d Array_Search ("április", $ tömb); ?\u003e.

Ebben a példában az $ eredmény1 változó megkapja a "szezon1", a $ eredménye "szezon3" lesz, és $ eredményt kapnak a logikai értéket, mivel az "április" karakterlánc nem fordul elő a forrás tömbje.

2. példa A PHP Array_Search () funkció egydimenziós tömböt is feldolgozhat, amely számítja a kulcsokat a numerikus indexek sorrendjében.

A $ eredményváltozót 1-re hozzárendeljük, a Hunter elem indexe szerint a $ tömb tömbben.

3. példa Lehetséges hiba az eredmény elemzésénél.

"Washington", 1 \u003d\u003e "Adams", 2 \u003d\u003e "Jefferson", 3 \u003d\u003e "Madison", 4 \u003d\u003e "MONROE"); $ Eredmény \u003d Array_Search ("Washington", $ elnökök); Ha (! $ Eredmény) (Echo "G. Washington nem az USA első elnöke";)?\u003e

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

4. példa. Csak az első észlelt egybeesés kulcsa visszatért.

Annak ellenére, hogy a kívánt érték háromszor a tömbben található, a funkció csak az első eredményt adja vissza - 0. Több mérkőzés kereséséhez javasoljuk a PHP Array_keys () funkciót.

A programozás szintaxis és szemantika. Az elsőt a nyelv, a második - a fejlesztő tapasztalata határozza meg. A tömbök tekintetében a fejlesztő kifoghatja a szemantika szintaxisát. Ez nem egy tárgy, de már nem egy tömb egy hagyományos megértésben. A PHP lehetővé teszi tömbök létrehozását a változó különböző típusokból, beleértve magukat is. A tömb eleme lehet egy funkció, vagyis a tömb betöltése valódi algoritmussal, valódi jelentőséggel.

A szintaxis stabil, de a változatból a verzióra változik, és az alulról felfelé sem lehet kompatibilis. A programok hordozhatósága jól elfelejtette a múlt század elérését. A szemantika fejlődik, és mindig alkalmazható semmilyen nyelv bármely változatában; Hagyomány volt a szintaxis struktúrák használatára, hogy kifejezzék, hogy a nyelv szabályai még nem is rendelkeznek. A tömbök példáján könnyen érthető.

Fegyverek építése

A PHP-ben lévő tömb kényelmes szintaxissal és funkcionalitással rendelkezik. Ezt előzetesen le lehet írni, de gyakran kényelmes, hogy tömböket hozzanak létre a repülés szükség szerint.

nyilvános $ anne \u003d tömb (); // a tömb leírása, és nem tartalmaz semmit

nyilvános $ afact \u003d tömb ("avokádó", "őszibarack", "cseresznye"); // Ebben a tömbben három elem

A tömb létrehozása az állapot ellenőrzésének folyamatában:

$ cstrcline \u003d "elemzett adatok sora";

mert ($ i \u003d 0; $ i<13; $i++) {

ha (checkfunc ($ cstrclin, $ cuserline) (

$ Aresult \u003d "igen"; // Add hozzá a PHP tömbhöz

$ Aresult \u003d "nem";

Ennek a példának a végrehajtásának eredményeképpen létrejött egy sor 13 elem, amelynek értékei csak az "igen" vagy "nem" karakterláncok lesznek. Az elemek 0 és 12 közötti indexeket kapnak. Ugyanez a hatás érhető el, miután a "jövő" php-tömb írása után:

$ cfuturearray \u003d "";

mert ($ i \u003d 0; $ i<13; $i++) {

$ cuserline \u003d inputUserline (); // tegyen valamit

ha ($ i\u003e 0) ($ cfuturearray. \u003d "|";)

ha (checkfunc ($ cstrclin, $ cuserline) ($ cfuturearray. \u003d "Igen";

) Egyébként ($ cfuturearray. \u003d "Nem";)

$ Aresult \u003d felrobban ("|", $ cfuturearray);

Többdimenziós tömbök

Sok webhelykezelő rendszer (SMS) Használja a "hatókör" tömböket. Egyrészt ez egy jó gyakorlat, másrészt, nehéz felhasználni. Még akkor is, ha a szerző világossá válik a "PHP-tömb egy tömb" tanításáról, akkor nem szabad visszaélni: nem csak a fejlesztőnek meg kell adnia a komplex jelzést. Gyakran az idő múlva maga a Teremtő sokáig emlékszik arra, hogy először írta:

"View_Manager" \u003d\u003e tömb (41, "template_path_stack" \u003d\u003e tömb (__ DIR__. "/../view",),

"Router" \u003d\u003e tömb ("útvonalak" \u003d\u003e tömb ("Sayhello" \u003d\u003e tömb (

"Típus" \u003d\u003e "Zend \\ MVC \\ router \\ http \\ literal",

"Opciók" \u003d\u003e Array ("Route" \u003d\u003e "/ Sayhello", "Alapértelmezett értékek" \u003d\u003e tömb (

"Vezérlő" \u003d\u003e "HelloWorld \\ Controller \\ Index", "Akció" \u003d\u003e "Index",))))))))))

"Vezérlők" \u003d\u003e tömb ("Invokables" \u003d\u003e Array (

"HelloWorld \\ Controller \\ Index" \u003d\u003e "HelloWorld \\ Controller \\ IndexController")))))

Ez a PHP-tömb-gyakorlat mintája a tömbben "a ZF 2. Nem túl inspirálja először, de működik, és talán ez a keret sikeres (példa a zendskeletonapplication / modul / hellogorld / config / module.config .php modul).

A tömb fontos adattervezés a tervezés és a fejlesztés során. Multidimenziós opciója egyszer népszerű volt, de idővel a legfeljebb két vagy három dimenzió tömbjeinek szükségessége maradt. Könnyebb és világosabb, és a szakmaiság szempontjából, amikor valami megkezdődik, ez azt jelenti, hogy valamit a feladat megfogalmazásában vagy a kódban nem igaz.

Egyszerű, hozzáférhető és érthető

A tömb létrehozása a PHP-ben a legjobb, ha a két-három szintet korlátozza. A PHP stabilitása és megbízhatósága ellenére hibákat tesz lehetővé a szintaktikai struktúrák feldolgozásában. Ezzel hozzátartozhatod, hogy jó szerkesztő kódja van, és megszokja, hogy pontosan fontolja meg a zárójeleket és a vesszőket. Azonban a PHP nem irányítja az adattípusokat (ez a modern programozás karma), és lehetővé teszi a fejlesztő számára a szemantikai hibákat.

Az a szabály, amely szabályozza a változók típusát vagy saját ötleteiket a szemantika szintaxisára való átalakítására - gyakran hiányos luxus. Ez a forgatókönyvek elvesztése, a kódolhatósága, ... ezért az egyszerűség a kódolásban mindig elengedhetetlen.

A PHP jelentős negatív tulajdonsággal rendelkezik: ha bizonytalanságot jelent, a szkript egyszerűen lóg. Nem minden hibavester megbirkózik előre nem látható körülményekkel, és sokan függnek a fejlesztő tapasztalatától és intuíciójától. Minél könnyebb az algoritmus, a megfizethetőbb információk strukturáltak, annál nagyobb eséllyel találhat hibát, vagy egyáltalán nem engedheti meg.

Jellemző, hogy amikor az első tömbök megjelent adatok lehetőséget javasoltak formájában struktúrák - egy ügyetlen kísérletet létrehozni valamit a különböző típusú adatok. Az első túlélte és új hatásos szintaxisát szerzett, a második a földszinten ment.

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

A kétdimenziós tömb felvétele egy másik zárójel "[" és "]", például: $ ASRCDATA azt jelenti, hogy a $ Asrcdata tömbben szereplő tömbelemre vonzódik. A PHP-ben nincs szükség az adatok előrejelzésére. Bármely információ mindig ellenőrizhető a létezéshez.

Nagyon hatékonyan létrehozni valamit csak akkor van szükség, abban a formában, amelyben tudomásul, és elpusztítani, amikor eltűnt a szükség. A kulcsok (indexek) értelmes nevek használatával olvasható formaterveket kaphat, értelmes az algoritmus jelenlegi helyének kontextusában:

$ AANKETA ["NAME"] \u003d "Ivanov";
$ anketa ["életkor"] \u003d 42;
$ AANKETA ["munka"] \u003d "igazgató";
$ AANKETA ["aktív"] \u003d igaz;
$ Ankable \u003d $ Aanketa;

$ AANKETA ["NAME"] \u003d "PETROV";
$ anketa ["életkor"] \u003d 34;
$ AANKETA ["munka"] \u003d "menedzser";
$ AANKETA ["aktív"] \u003d igaz;
$ Ankable \u003d $ Aanketa;

$ AANKETA ["NAME"] \u003d "AFANASYEV";
$ anketa ["életkor"] \u003d 28;
$ AANKETA ["munka"] \u003d "munkás";
$ AANKETA ["aktív"] \u003d hamis;
$ Ankable \u003d $ Aanketa;

$ SONE. \u003d Implode (";", $ hivathatatlan). "
"; // második php tömb a karakterláncban
$ SONE. \u003d $ ATLABLE ["MUNKA"]; // Használja a második tömb egyik elemét

A példa eredménye (az első tömb szokásos, a kulcsa a 0-mal kezdődik, a második tömb asszociatív, négy kulcs: "Név", "Kor", "Munka", "Aktív"):

$ Sone \u003d "Petrov, 34; menedzser; 1
Menedzser";

Ezen az egyszerű példában láthatja, hogy a létrehozott kérdőív alkalmazható minden alkalmazottra. Megteremtheti a tabletta számok indexeit, és ha egy adott alkalmazottra van szükség, akkor válassza ki az asztalszámot.

Ha vannak olyan részlegek a szervezetben, vagy vannak szezonális munkavállalók, vagy köteles különbüsztetni a munkadarab-nyugdíjat, ... a "PHP-tömb" design a tömbben nagyon kényelmes, de soha nem szünteti meg a dimenzió. Két vagy három dimenzió - a hatékony megoldás korlátozása.

Kulcsok a tömbökkel való munkavégzéshez

Ha azt rohantam, hogy az elmúlt években a bináris korszak hagyománya, amikor a programozó pontosan meg akarta tudni, hogy pontosan meg akarta tudni, hogy a tömb elemei tárolódnak, és szeretnének közvetlen hozzáférést biztosítani nekik, voltak teljesen elfelejtett. Számos olyan karakterlánc van, amelyek nem rendelkeznek egy bájtot a memóriában. A "bit" szó most megtalálhat semmit a batal keresési műveletekben, de a PHP-tömb keresése külön téma. Az elemekhez való hozzáférés egyszerű és asszociatív lehet. Az első esetben a tömb elemei (a PHP-ben rendelkezésre álló típusok bármelyike) 0, 1, 2, ... a második esetben a programozó meghatározza saját indexét, amelyet "kulcsnak" neveznek Hozzáférés a kívánt értékhez.

$ Aline ["gyümölcs"] \u003d "narancs"; // itt PHP-Key Array \u003d "gyümölcs"

vagy (így minden helyes az oldal és a kód kódolásával):

$ Aline \u003d Icon ("UTF-8", "CP1251", "Orange");

Ha új értéket ad hozzá a $ Aline tömbben:

$ Aline \u003d Icon ("UTF-8", "CP1251", "PIC");
$ Aline \u003d Icon ("UTF-8", "CP1251", "uborka");
$ Aline \u003d Icon ("UTF-8", "CP1251", "padlizsán");

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

foreach ($ Aline, mint $ ck \u003d\u003e $ cv) (
$ Kúp. \u003d $ Ck. "\u003d". $ CV. "
";
}

lesz beszerezve:

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

A "barack" és a "padlizsán" elemek hozzáadásával a tömb PHP-kulcsát egymás után állítják elő 0-tól, és amikor meghatározza annak értékét ezzel az értékkel.

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

A legegyszerűbb módja a feldolgozásnak. Ebben az esetben, például a ciklus végrehajtásának eredményeképpen a forrás tömb látható, és egy új képződött, amelybe szükségtelen elemeket egyszerűen nem rögzítenek.

Megkönnyítheti. Ha az utolsó példa érvényes:

($ Aline); // törölje a PHP tömb elemet

az eredmény:

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

A tömbelemek manipulálására szolgáló lehetőségek megtervezhetők. Például funkciók használatával: Implode () és felrobban (), írhat egy PHP-tömlevet egy szeparátorral, és visszaállítani egy másik tömbbe - egy másik elválasztóra.

Ha egyszerűen töröl egy tömböt a PHP-n, akkor elegendő írni: nincs ($ Aline);

Ez elég.

Keresés a tömbben

PHP tartalmaz speciális kereső és in_array () speciális funkciókat, de mielőtt úgy dönt, hogy használja őket, akkor érdemes átnézni a PHP tömb saját.

Bármely projekt specifikus tervezett tömbökkel rendelkezik, különösen akkor, ha a szemantika egy része átkerül a szintaxisba, és meglehetősen specifikus értelmes kulcsokat mutat be. Ez lehetővé teszi, hogy a saját keresési funkcióit is elvégezzék.

A PHP-ben olyan funkciókat hívhat meg, amelyeknek a nevét a program végrehajtása során határozzák meg. Egy nagyon praktikus például a PHPWORD könyvtár, ami lehetővé teszi, hogy olvassa el, és hozzon létre dokumentumokat MS Word:

$ Elements \u003d Array ("Text", "Inline", "Textrun", "Link", "PreservEextext", "Textbreak",
"Listitem", "listitemrun", "táblázat", "kép", "objektum", "lábjegyzet",
"Endnote", "Checkbox", "Textbox", "Field", "Line");

$ funkciók \u003d tömb ();

mert ($ i \u003d 0; $ i< count($elements); $i++) {
$ Funkciók [$ i] \u003d "Add". $ Elemek [$ i];
}

Ennek eredményeképpen a $ -s funkciók sorozata $ -s elemet kap, vagyis az igazi funkciók nevei, amelyek a dokumentum valódi elemeivel dolgoznak.

Hívás $ Elements funkció $ funkciók, megkaphatja a tökéletes keresést és gyors eredményt.

Rendezési elemek

Az adatrendezési feladat fontos, és a PHP számos funkciót kínál erre: Rendezés (), RSORT (), ASORT (), KSORT (), ... Növekvő és csökkenő elemek A második két funkció megtartja a kapcsolatot a kulcsok és értékek között. Néha értelme van véletlenszerűen összekeverni a tömb értékét - Shuffle ().

A PHP funkciók használata A válogatáshoz ne felejtse el, hogy az elemek nem rendelkeznek különböző típusúakkal, de nem teljesen természetes tartalmakkal. Először is, nagyon óvatosan kell alkalmazni az orosz betűket tartalmazó vonalak válogatását, a dátumot, valamint a különböző formátumokban rögzített számokat.

A legjobb módja annak, hogy egy független döntést írjon, mindenesetre a szkript tesztelésének szakaszában kézi válogatás. Ez segít előre nem látható helyzeteket nyújtani.

Vonalas tömbök

Az implode () és felrobbanó () függvényeknek köszönhetően egy tömb könnyen átalakítható a karakterláncba, és visszatérhet. Ez lehetővé teszi, hogy adatokat tároljon egy kompakt ábrázolásban, és szükség esetén kényelmes állapotba helyezze őket.

A karakterláncra néző tömb új funkciókat nyit meg. Például a szövegben szereplő kulcsszavak keresése megköveteli, hogy a talált nem kerül hozzáadásra.

$ Cstrcline \u003d "Szöveges szöveg ListITemrun Textbox Listem Textbox jelölőnégyzet jelölőnégyzet Textbox Lábjegyzet";

$ ASRC \u003d felrobban (", $ cstrclin);
$ CDSTLine \u003d "";

mert ($ i \u003d 0; $ i< count($aSrc); $i++) {
$ cfind \u003d "[". $ ASRC [$ i]. "]";
Ha (! IS_INTEGER (STRPPT ($ CDSTLINE, $ CFIND))) (
$ CDSTLine. \u003d $ cfind;
}
}
$ ADST \u003d felrobban ("] [", $ cdstline);

$ Cone \u003d implode (", $ ADST);

Ennek eredményeképpen a $ kúpos változó csak akkor kapja meg az értékeket a forrásvonalból, amelyek egyszerre találhatók: "Szöveg, ListEmrun; Textbox; Listbox; Ellenőrzés; Box; jelölőnégyzet; Lábjegyzet.

Orosz nyelv a kulcsokban és értékekben

Nem ajánlott a nemzeti kódolásokhoz kapcsolódóan a szintaktikai struktúrákban. Orosz, mint minden más nyelv, amelynek szimbóluma túlmutat az A-Z korlátaiban, nem okoz problémákat az adatterületen, de nem a kódszintaxisban. Néha még egy egyszerű feladat a php "kimeneten egy tömb a nyomtatóhoz vagy a képernyőn" a "Krakoyarm" -hoz vezet, és gyakrabban fogja megállítani a forgatókönyvet.

A PHP - hű nyelv és toleráns a nemzeti kódolásokra utal, de sok helyzet van, amikor az elvégzett munkát csak azért kell elvégezni, mert a megfelelő helyen és a megfelelő időben felbukkan a kulcsértéket, hogy felismerje lehetséges.

PHP szintaxis és nyelvi környezet

Emlékeztetni kell arra, hogy a PHP szintaxis egy, de a "Deal" szintaxisának tervezése más alkalmazásokkal, az operációs rendszerrel, hardver opciókkal. Sok lehetőség van, soha nem lehet előre látni.

A szabály csak a kód, és a bejáratnál belül, belül, és a kimeneten van minden információ "segít elkerülni az előre nem látható meglepetéseket. A PHP-érték a tömbben lehet "orosz", de a kulcsnak szintaktikailag helyesnek kell lennie ahhoz, hogy nem csak a nyelv pozícióiból, hanem a munkájának szempontjából is.

Már használtam az Array_Search () funkciót az értékek megtalálásához a tömbben, mivel ismételten hallották és elolvastam, hogy jelentősen gyorsabban működik, mint a ciklusban lévő tömb keresése, de mennyire gyorsabban nem tudta. Végül kezeket kellett ellenőrizni és kiszámítani.

Hasonlítsa össze a keresési sebességet a tömbben ezzel a funkcióval a törlés szokásos felszínére a foreach-ben és a ciklusokon. A tömb 10-100 elemén a láthatatlan és az idő különbsége olyan kevés, hogy azok, hogy adjanak. De nagy tömbök esetén a különbség nagyon jelentős volt. A sorrend méretének növekedésével jelentősen megnőtt a keresési idő. Százezer tétel esetén a foreach sebesség 0,013 másodpercig esett, és míg - míg - 0,017, annak ellenére, hogy az Array_Search () lassult, de még mindig nagyságrenddel gyorsabb - 0,004 másodpercig maradt. A nagy tömbökkel futó nagy script esetében a keresés a ciklusban történő keresésére történő cseréje az Array_Search () nem lesz a "bolha optimalizálás".

Ebben a tekintetben emlékszem egy újabb megbeszélésre a munkatársak egyikével - arról, hogy a programozónak ismernie kell-e ezeket a beépített nyelvi funkciót, vagy a "programozó programozó programozója" és általános ismereteit. Anélkül, hogy elindulnánk az elmeállapotból való érveléssel, úgy gondolom, hogy még mindig szükséges ismerni a funkciókat, talán nem az egész szintaxist a részletekben, de bár milyen funkciók vannak, és hogy általánosságban.

Upd frissítés: szükség van egy programozó raktár az elme, szintén szükséges! És a memória gondozása nem fogja megakadályozni (inspirált szünet és tartomány :)

A Habracine script kód alatt, amely kiszámította az időt:

$ Mass \u003d 100000; // az értékek száma a tömbben, amelyben keresünk
$ keresés \u003d 50 000; // a tömbben keresjük ezt az értéket
$ first_result \u003d Array (); // eredmények tömbje, az első lehetőség átlagos értékének kiszámításához
$ Second_result \u003d tömb (); // eredmények tömbje, a második lehetőség átlagos értékének kiszámításához
$ Harmadik_result \u003d Array (); // az eredmények tömbje, a harmadik lehetőség átlagos értékének kiszámításához

// létrehozása és kitöltése egy tömb
$ test_array \u003d tartomány (0, $ mass-1); // köszönöm SELENIT))

/*
$ test_array \u003d tömb ();
mert ($ i \u003d 0; $ i<$mass; $i++)
{
$ test_array \u003d $ i;
}
*/

// ciklus a közepes értékek számlálásához
mert ($ d \u003d 0; $ d<30; $d++) {

// ***************** KERESÉS ARRAY_SEARCH *********************

// futtatási időszámítás
$ TIME_START \u003d Microtime (1);
// Keresés
$ Key \u003d Array_Search ($ keresés, $ Test_Array, igaz);
// Ha megtalálható
Ha ($ billentyű! \u003d\u003d hamis) // szüksége van! \u003d\u003d és nem! \u003d, mert az első elem száma 0
{
Echo $ test_array [$ billentyű];
}
$ TIME_END \u003d Microtime (1);
// Vége számlálás

// Írj egy sor értékben
$ first_result \u003d $ time_end - $ time_start;

// ***************** Keresés a Cycle Forach ***********************

// futtatási időszámítás
$ TIME_START \u003d Microtime (1);
// Keressen magának
foreach ($ test_array as $ TA)
{
Ha ($ ta \u003d\u003d $ keresés)
{
Echo $ ta;
Szünet;
}
}
$ TIME_END \u003d Microtime (1);
// Vége számlálás

// Írj egy sor értékben
$ Second_result \u003d $ time_end - $ time_start;

// ***************** Keresés a tömbön egy ciklus közben ***********************

// futtatási időszámítás
$ TIME_START \u003d Microtime (1);

// meghatározza a tömb hosszát
$ Count \u003d count ($ test_array);
$ j \u003d 0;
// Keressen magának
Míg ($ j<$count)
{
Ha ($ test_array [$ j] \u003d\u003d $ keresés) // Ha megtalálható
{
Echo $ test_array [$ j];
Szünet;
}
$ J ++;
}
$ TIME_END \u003d Microtime (1);
// Vége számlálás

// Írj egy sor értékben
$ Harmadik_result \u003d $ Time_END - $ TIME_START;
}

$ srednee1 \u003d array_sum ($ first_result) / count ($ first_result);
$ srednee2 \u003d array_sum ($ second_result) / count ($ second_result);
$ srednee3 \u003d Array_sum ($ Harmadik_rezult) / szám ($ harmadik_rezult);

Printf ("Az első kódot átlagosan:% .7F másodpercek", $ srednee1);
Printf ("A második kód átlagosan:% .7f másodpercek", $ srednee2);
Printf ("A harmadik kód átlagosan:% .7F másodpercek", $ srednee3);

// eredmény:
// az első kódot átlagosan: 0,0000295 másodperc
// második kódot átlagosan: 0,0153386 másodperc
// A harmadik kód átlagosan: 0,0226001 másodperc