A Javascript egy függvényt futtat egy for ciklusban. Hurok és iterációk. A for ciklus megszakítása
A hurkok lehetővé teszik, hogy bizonyos feltételektől függően többször hajtson végre egy műveletet. A JavaScript rendelkezik a következő típusok ciklusok:
be
míg
csinálni, miközben
hurokhoz
A for ciklus a következő formális definícióval rendelkezik:
For ([számláló inicializálása]; [feltétel]; [számláló módosítása])( // műveletek )
Például egy for ciklust használunk egy tömb elemeinek iterálásához:
Helyes ciklusok - a valóság tükröződése
Így írva a két hurok nagyon hasonlónak tűnik. Az egyetlen dolog, ami valóban változik közöttük, az a meghívott függvény és a kezdeti érték. Mindkettő egyetlen értékre csökkenti a tömböt. Tehát létrehozunk egy redukciós függvényt ennek a mintának a beágyazásához.
Tehát nem kell saját magunkat írnunk, ha nem akarjuk. A beépített metódust használva a kódunk azzá válik. Most, ha nagyon odafigyelt, talán észrevette, hogy ez a kód nem sokkal rövidebb. A beépített tömbmódszerekkel csak egy sort tárolunk. Ha a kézi rövidítés funkciót használjuk, akkor a kód hosszabb. De a célunk a bonyolultság csökkentése, nem az, hogy rövidebb kódot írjunk. Tehát csökkentettük a bonyolultságot? Elválasztottuk a ciklus kódját az egyes elemeket feldolgozó kódtól.
Var people = ["Tom", "Alice", "Bob", "Sam"]; for(i változó = 0; i
A ciklusdeklaráció első része - var i = 0 - létrehozza és inicializálja az i számlálóváltozót. És a ciklus végrehajtása előtt az értéke 0 lesz. Lényegében ez ugyanaz, mint egy változó deklarálása.
A második rész az a feltétel, amely mellett a ciklus végrehajtásra kerül. Ebben az esetben a ciklus addig fut, amíg az i értéke el nem éri az emberek tömb hosszával megegyező értéket. Egy tömb hosszát a length tulajdonság segítségével kaphatja meg: people.length .
Infinite for ciklus
A zsugorítási funkció első pillantásra meglehetősen primitívnek tűnhet. A redukciós példák többsége meglehetősen egyszerű dolgokat tesz, például számokat ad hozzá. De semmi sem állítja, hogy a csökkentés visszatérési értékének primitív típusnak kell lennie. Ez lehet egy objektum vagy akár egy másik tömb. Így például írhatunk térképet vagy szűrőt egy parancsikon segítségével. Van egy térképünk, hogy a tömb minden elemével csináljunk valamit. És csökkentettük, hogy a tömböt egyetlen értékre csökkentsük.
De mi van akkor, ha csak néhány elemet szeretnénk lekérni a tömbből? A további felfedezés érdekében kibővítjük a hős adatbázisunkat, hogy hozzáadjunk néhány további adatot. Tegyük fel, hogy két problémánk van. Találd meg az összes női hőst; és megtalálja az összes nagyobb erővel rendelkező hőst. . De határozottan van egy ismétlődő mintánk. Predikátumot használunk annak eldöntésére, hogy tároljuk-e az egyes elemeket a hősökben. Ahogy itt leírtuk, a kód hosszabb lesz. De most, hogy meghatároztuk predikátumfüggvényeinket, az ismétlés világosabbá válik.
A harmadik rész a számláló eggyel történő növelése.
És mivel a tömbben 4 elem van, a ciklusblokk 4-szer fut le, amíg az i értéke egyenlővé nem válik a people.length-vel (azaz 4). És minden alkalommal, amikor ez az érték 1-gyel nő. A ciklus minden egyes ismétlődését iterációnak nevezzük. Így ebben az esetben 4 iteráció fog működni.
A people[i] kifejezés használatával pedig egy tömbelemet kaphatunk a későbbi kimenethez a böngészőben.
Kibonthatjuk függvénybe. Tehát nem kell saját verziót írnunk. Tömbmetódusokat használva a kódunk lesz. Nos, gondoljuk át, hogyan használjuk ezt a gyakorlatban. Ha észrevesszük, hogy ezt a problémát egy szűrővel meg tudjuk oldani, a dolgunk könnyebbé válik. Csak annyit kell tennünk, hogy megadjuk a mentendő szűrőt. Ezt úgy tesszük, hogy írunk egy nagyon kis függvényt. Elfelejtjük a tömböket és a munkaváltozókat. Ehelyett írunk egy apró predikátum függvényt.
Folytassa és szakítsa meg az állításokat
Más iterátorainkhoz hasonlóan a szűrők használata több információt továbbít kevesebb helyen. Nem kell az összes gyakori hurokkódot elolvasnunk ahhoz, hogy megértsük, mit szűrünk. Ehelyett közvetlenül a metódushívásban van beírva. De mi van, ha egy hőst akarunk találni? Használhatnánk például egy szűrőt, hogy megtaláljuk.
A számlálót nem szükséges eggyel növelni, más műveleteket is végrehajthat vele, például csökkentheti eggyel:
Var people = ["Tom", "Alice", "Bob", "Sam"]; for(i változó = people.length - 1; i >= 0; i--)( document.write(people[i] + ""); }
Ebben az esetben a tömb a végétől kerül kiadásra, és a tömb i = 3-ról i = 0-ra iterálódik.
be
A for..in ciklust úgy tervezték, hogy tömbökön keresztül iteráljon. Formális definíciója a következő:
Egyszerű algoritmusok hatalmas kombinációi
A probléma az, hogy nem túl hatékony. A szűrőmódszer a tömb minden elemét megvizsgálja. De tudjuk, hogy csak egy Fekete Özvegy van, és nem tudjuk többé nyomon követni, hogyan találtuk meg. De ez a predikátumfüggvény használatának megközelítése ügyes.
Ismét több információt fejezünk ki kevesebb helyen. Keresésünkkel a feladatunk, hogy egy adott rekordot megtaláljunk, egyetlen kérdésre oszlik: honnan tudhatjuk, hogy megtaláltuk-e, amit keresünk? Nem kell aggódnunk az iteráció részletei miatt.
For (index a tömbben) ( // műveletek )
Például ismételjük át a tömbelemeket:
Var people = ["Tom", "Alice", "Bob", "Sam"]; for(var index in people)( document.write(people + ""); }
míg hurok
A while ciklus addig fut, amíg valamelyik feltétel igaz. Formális definíciója a következő:
While(feltétel)( // műveletek )
Ismét megjelenítjük a tömb elemeit, miközben:
Ezek az iterációs függvények nagyszerű példái annak, hogy az absztrakciók miért olyan hasznosak és elegánsak. Tegyük fel, hogy mindenhez a beépített tömbmódszereket használjuk. Mindegyik esetben három dolgot csináltunk. A hurokvezérlő szerkezet megszűnt, így a kód tömörebb és könnyebben olvasható; Leírja az általunk használt mintát a megfelelő metódusnévvel. Csökkentette a teljes tömb feldolgozásával járó fáradságot, és egyszerűen megadhatja, mit akarunk tenni az egyes elemekkel. Vagyis térképezze fel, kicsinyítse, szűrje vagy keressen. . Vegye figyelembe, hogy a problémát minden esetben kis, tiszta függvényeket használó megoldásokban oldották meg.
Var people = ["Tom", "Alice", "Bob", "Sam"]; var index = 0; while(index< people.length){ document.write(people + ""); index++; )
A while ciklus itt addig fut, amíg az index értéke nem egyenlő a tömb hosszával.
csinálni, miközben
A do ciklusban először a cikluskód kerül végrehajtásra, majd a while utasításban lévő feltétel ellenőrzése. És amíg ez a feltétel igaz, a ciklus megismétlődik. Például:
És amikor megszüntetjük a ciklusokat, csökkentjük a bonyolultságot, és használhatóbb kódot hozunk létre. Többen felhívták a figyelmet arra, hogy a metszés- és szűrési példákban nem hatékony a hőslistát kétszer végigfutni. Ez egy kicsit bonyolultabb, mint az a verzió, ahol kétszer ismételjük, de nagy változást hozhat, ha a tömb hatalmas.
Amikor valamit kódol, előfordulhat, hogy meg akar ismételni egy műveletet, vagy többször is le akarja futtatni. Ennek egyik módja a függvény 10-szeri meghívása a másolás és beillesztés segítségével. A duplikált kód soha nem jó ötlet.
Var x = 1; do( document.write(x * x + ""); x++; )while(x< 10)
Itt a cikluskód 9-szer fut le, amíg x 10 lesz. A do ciklus garantálja, hogy a műveletek legalább egyszer végrehajtásra kerülnek, még akkor is, ha a while utasítás feltétele nem igaz.
Folytassa és szakítsa meg az állításokat
Néha ki kell lépni egy ciklusból, mielőtt az befejeződik. Ebben az esetben használhatjuk a break utasítást:
Még ha úgy dönt is, hogy néhány kódot manuálisan többször megmásol, ez a megközelítés aligha működik a gyakorlatban. Az, hogy hányszor kell megkettőznie a kódot, bizonyos külső tényezőktől függ, például az adatkészlet elemeinek számától, a webszolgáltatás-hívás eredménye, a szóban lévő betűk száma és számos egyéb dolog, ami változni fog. Mindig fix szám volt, például 10. Nem akarsz valamit százszor vagy ezerszer átmásolni és beilleszteni, hogy megismételj valamit.
Olyan általános megoldásra van szükségünk a kódismétlésre, amely szabályozza, hogy a kód hányszor ismétlődik. Háromféle hurkot hozhat létre. A három ciklusopció mindegyike lehetővé teszi az ismételni kívánt kód megadását, valamint az ismétlés leállításának módját, ha egy feltétel teljesül. A következő részekben mindent megtudhat róluk.
< array.length; i++) { if (array[i] >10) szünet; document.write(array[i] + ""); }
Ez a ciklus a tömb összes elemén iterál, de az utolsó négy elem nem jelenik meg a böngészőben, mivel az if teszt (tömb[i] > 10) megszakítja a ciklust egy break utasítással, amikor a tömbön keresztül iterál 12. elem.
Ha csak ki kell hagynunk az iterációt, de nem kell kilépnünk a ciklusból, használhatjuk a turpināt utasítást:
Hurok utófeltétellel
Ennek valószínűleg nincs sok értelme. A meghatározás tisztázása érdekében nézzünk egy példát. Ha beírná ezt a kódot néhány szkriptbe és előnézeti címkébe a böngészőjében, ezt látná. Ez a fajta magas szint megfelel a példánkból származó tényleges értékeknek.
A JavaScript hurkok típusai, ciklusvezérlés
Ez a három be van festve különböző színek területek fontos szerepet játszanak a hurok működésében. Az első területen meghatározzuk a kiindulási pontot. Általában a kiindulópont általában egy változó deklarálása és inicializálása. Az érték, amelyre ezt a változót inicializálja, szintén hagyományos.
Var tömb = [ 1, 2, 3, 4, 5, 12, 17, 6, 7 ]; for (var i = 0; i< array.length; i++) { if (array[i] >10) folytatás; document.write(array[i] + ""); }
Ebben az esetben, ha a program 10-nél nagyobb számot talál a tömbben, akkor ez a szám nem jelenik meg a böngészőben.
Ciklusok olyan speciális kifejezések, amelyek lehetővé teszik ugyanazon kódblokk többszöri végrehajtását. A kód végrehajtása megszakad, ha egy bizonyos körülmény bekövetkezik.
Miután meghatároztuk a kiindulási pontot, a következő régióban határozzuk meg, mennyi ideig kell folytatni a ciklust. Eddig a kiindulási pontunkat néztük. Nincs olyan végterület, ahol leírnánk, hogyan juthatunk el a kiindulási ponttól a megállóhelyig. A miénk teljes példa, amelyet korábban megismételtünk, így néz ki. Ezen a ponton minden zöldre vált, és a cikluson belüli kódok végrehajtásra kerülnek. Az előző részben egy egyszerű hurkot néztünk meg, és felvázoltuk annak minden belső működését. A legjobb megoldás az, hogy nézzünk meg még néhány példahurkot, és ezt fogjuk megtenni a következő néhány részben.
A JavaScript többféle változatot kínál a programozóknak ciklusok. Nézzük meg őket közelebbről.
Hurok számlálóval
Ciklus számlálóval akkor kényelmes, ha egy kódot szigorúan meghatározott számú alkalommal kell végrehajtani. Valószínűleg ez a ciklus leggyakoribb típusa.
A számlálóval ellátott hurok így íródik:
mert (<выражение инициализации>; <условие>; <приращение>)
<тело цикла>
Néha előfordulhat, hogy meg kell szakítani egy ciklust, mielőtt az befejeződik. Bár ez a példa kissé trükkös volt, ha valódi huroklezárási esettel találkozik, most már tudja, mit kell tennie. Előfordulhatnak olyan esetek, amikor azt szeretné, hogy a ciklus kihagyja az aktuális iterációt, és továbblépjen a következőre.
Ellentétben a breakkel, ahol a ciklus csak leáll, és hazamegy, a ciklus továbbra is leáll, és továbblép a következő iterációra. Gyakran használja a folytatást a hibák kezelésekor, amikor egyszerűen azt szeretné, hogy a ciklus a következő elemre folytatódjon.
Itt a for kulcsszót használjuk. Ezért az ilyen hurkokat gyakran "hurkoknak" nevezik.
Az inicializálási kifejezés a legelső és csak egyszer kerül végrehajtásra. Valamelyik kezdeti értékhez (általában 1) hozzárendel egy speciális változót, amelyet hurokszámlálónak neveznek. A hurokszámláló megszámolja, hogy a ciklus törzse – a tényleges kód, amelyet bizonyos számú alkalommal végre kell hajtani – hányszor került végrehajtásra.
Nincs oka annak, hogy 0-ról kezdje, majd felfelé növelje. Talán hallott már arról, hogy az ehhez hasonló műveletek javítják a hurok teljesítményét. A zsűri még mindig nem dönti el, hogy a csökkentés gyorsabb lesz-e, mint a növelés, de kísérletezhet, és megláthatja, észrevesz-e a teljesítmény előnyeit.
Bármit használhatsz, amíg a ciklusod végül eljut arra a pontra, ahol véget érhet. A tömb elemek gyűjteménye. Ne feledje, hogy a ciklus hosszára vonatkozó feltételem magában foglalja a tömb hosszát, szemben valamilyen rögzített értékkel, például azzal, hogy a tömb első eleme egy számra hivatkozik.
A következő lépés az állapot ellenőrzése. Meghatározza azt a pillanatot, amikor a ciklus végrehajtása megszakad, és a következő kód elkezdődik. A feltétel általában összehasonlítja a hurokszámláló értékét a kötött értékével. Ha a feltétel igazat ad vissza, akkor a ciklus törzse végrehajtódik, ellenkező esetben a ciklus véget ér, és a ciklust követő kód megkezdi a végrehajtást.
Ettől függetlenül a teljesség kedvéért vessünk egy pillantást mindkettőre. Minden iterációnál a ciklusunk 1-gyel növeli a számlálási értéket. Jelenleg nem biztos, hogy látja, hogy sokat használ ciklusokat. Ha kérdésed van ezzel vagy más témával kapcsolatban, a legegyszerűbb, ha bedobod, ahol a legbarátságosabb emberek, akikkel valaha találkozhatsz, szívesen segítenek neked!
A JavaScript pozíciója a kódtérben
A gyűjtemény lehet tömb, halmaz, lista, egyéni gyűjteményobjektum stb. Az iterátor egy olyan konstrukció, amely lehetővé teszi számunkra, hogy meglátogassuk a gyűjtemény minden egyes elemét, vagy iteráljunk végig. Íme egy kódpélda egy tömb for ciklus használatával történő iterálására.
Miután áthaladt a testen ciklus A növekmény kifejezés végrehajtásra kerül, megváltoztatva a számláló értékét. Ez a kifejezés jellemzően növeli a számlálót (eggyel növeli az értékét). Ezután a feltételt újra ellenőrizzük, végrehajtjuk a ciklus törzsét, végrehajtjuk a növekményt stb., amíg a feltétel hamis nem lesz.
Példa egy hurokra számlálóval:
for (i = 1; i< 11; i++) {
a += 3;
b = i * 2 + 1;
}
A hurkok gyors és egyszerű módot kínálnak valami ismételt elvégzésére. Sokan vannak különböző típusok hurkok, de lényegében mindegyik ugyanazt csinálja: többször megismétlik a műveletet. Különféle ciklusmechanizmusok kínálnak különböző utak a ciklus kezdő- és végpontjának meghatározása. Vannak különféle helyzetek, amelyeket egy huroktípus könnyebben kiszolgál, mint a többi.
Nyilatkozat. Ez a kifejezés általában egy vagy több hurokszámlálót inicializál, de a szintaxis lehetővé teszi bármilyen bonyolultsági fok kifejezését. Ha a feltétel kifejezést teljesen kihagyjuk, a feltétel igaznak tekinthető. A pályázat teljesítése folyamatban van. Több utasítás végrehajtásához használja a blokk operátort az utasítások csoportosításához. Az irányítás visszatér a színpadra.
- Ez a kifejezés változókat is deklarálhat.
- A feltétel kifejezés kifejezve van.
- Ha a feltétel igaz, a ciklusutasítások végrehajtásra kerülnek.
Ez a ciklus 10-szer kerül végrehajtásra. Az i számlálóhoz 1-es kezdeti értéket rendelünk, és a ciklustörzs minden egyes végrehajtása után eggyel növeljük. A ciklus leáll, ha a számláló 11-re nő, és a hurok feltétele hamis lesz.
A ciklusszámláló beírható valamelyik ciklustörzs kifejezésbe, ahogy mi is tettük. Esetünkben az i számláló 1-től 10-ig szekvenciálisan növekvő értékeket tartalmaz, amelyeket a számításokhoz használunk.
A for ciklus megszakítása
Az utasítás egyszer végrehajtásra kerül az állapot ellenőrzése előtt. Ha a feltétel igaz, az utasítás újra végrehajtásra kerül. Minden végrehajtás végén ellenőrizzük a feltételt. Ha a feltétel hamis lesz, a ciklusban lévő utasítás végrehajtása leáll, és a vezérlés a ciklust követő utasításhoz kerül.
A feltétel ellenőrzése a ciklusban lévő utasítás végrehajtása előtt történik. Győződjön meg arról, hogy a hurok feltétele végül hamis lesz; különben a hurok soha nem fejeződik be. A címke egy utasítást biztosít egy azonosítóval, amely lehetővé teszi, hogy a programban máshol hivatkozhassunk rá.
Íme még két példa egy számlálós hurokra:
for (i = 10; i > 0; i--) (
a += 3;
b = i * 2 + 1;
}
Itt a számláló értéke csökken. Kezdeti értéke 10. A ciklus 10-szer kerül végrehajtásra, és akkor ér véget, ha az i számláló 0-t tartalmaz; ebben az esetben az utóbbi értékei egymás után 10-ről 1-re csökkennek.
for (i = 2; i< 21; i += 2) b = i * 2 + 1;
És ebben a példában a számláló kezdeti értéke 2, a végső értéke pedig 21, de a ciklus ismét 10-szer kerül végrehajtásra. És mindez azért, mert a számláló értéke 2-vel növekszik, és egymás után felveszi a 2, 4, 6... 20 értékeket.
Hurok utófeltétellel
Az utólagos feltétel hurok olyan, mint egy számláló ciklus: addig fut, amíg a ciklusfeltétel igaz marad. Ráadásul a feltételt nem a ciklustörzs végrehajtása előtt, hanem utána ellenőrizzük, ezért kapta a nevét az utófeltételes ciklus. Egy ilyen ciklus legalább egyszer végrehajtásra kerül, még akkor is, ha a feltétele kezdettől fogva hamis.
Hurokformátum utófeltétellel:
csináld
<тело цикла>
míg (<условие>);
Utófeltételes hurok meghatározásához a do és a while kulcsszavak vannak megadva, ezért az ilyen ciklusokat gyakran „do-while ciklusoknak” nevezik.
Íme egy példa egy utófeltételes hurokra:
do(
a = a * i + 2;
++i;
), míg (a< 100);
Íme egy másik példa:
var a = 0, i = 1;
do(
a = a * i + 2;
++i;
) miközben én< 20);
Bár itt kényelmesebb lenne a számunkra már megszokott és kifejezetten ilyen esetekre kialakított számlálós hurkot használni.
Hurok előfeltétellel
Ciklus előfeltétellel abban különbözik az utófeltételes ciklustól, hogy a feltételt a ciklus törzsének végrehajtása előtt ellenőrizzük. Tehát, ha ez (a feltétel) kezdetben hamis, akkor a ciklus még egyszer sem kerül végrehajtásra:
míg (<условие>)
<тело цикла>
Utófeltételes hurok létrehozásához a while kulcsszó biztosított. Ezért az ilyen ciklusokat "" míg hurkok" (nem tévesztendő össze a "do-while ciklusokkal"!).
Példa egy előfeltételes hurokra:
míg (a< 100) {
a = a * i + 2;
++i;
}
Ciklus megszakítása és újraindítása
Néha meg kell szakítani egy hurok végrehajtását. Ennek eléréséhez a JavaScript a webprogramozók számára biztosít megtörni az állításokatés folytasd.
A break operátor lehetővé teszi egy ciklus végrehajtásának megszakítását, és a következő kifejezésre való továbblépést:
míg (a< 100) {
a = a * i + 2;
ha (a > 50) szünet;
++i;
}
Ebben a példában megszakítjuk a hurkot, ha a változó értéke a meg fogja haladni az 50-et.
A folytatást újraindítás utasítás lehetővé teszi az újraindítást ciklus, azaz a ciklus törzsében szereplő összes következő kifejezést hagyjuk végrehajtatlanul, és kezdjük el a ciklus végrehajtását a legelejétől: a feltétel ellenőrzése, a növekmény és a törzs végrehajtása stb.
Példa:
míg (a< 100) {
i = ++i;
if (i > 9 && i< 11) continue;
a = a * i + 2;
}
Itt kihagyjuk a kiértékelő kifejezést a, minden értékre én 10-től 20-ig.
