Viser loop-elementer efter en vis tid javascript. JavaScripts position i koderummet
For-løkken er den mest brugte loop i JavaScript.
Dens design ser således ud:
For (start; betingelse; trin) ( /* loop body */ )
Det er virkelig simpelt. Lad os se på et eksempel:
Var i; for (i = 1; i
I dette eksempel:
- Start af sløjfe: i = 1 (startende fra værdi i = 1)
- Cyklus tilstand: i
- Løkketrin: i++ (ved hvert løkketrin øges med 1)
- Loop body: document.write("
Cyklustrinnummeret udføres: " + "
"); (vis en besked på skærmen)
Trin-for-trin algoritme til at udføre denne for loop, mere detaljeret:
Hvis løkkens krop består af én instruktion, så seler(...) det er ikke nødvendigt at sige det.
Variablen i forsvinder ikke efter løkken slutter. Det fortsætter med at eksistere, og dets værdi efter afslutningen af cyklussen vil være lig med 6.
Lad os opsummere disse data i et nyt eksempel:
Var i; for (i = 1; i
Her blev der ikke brugt krøllede seler til at skabe løkkekroppen.
Krøllede seler (...) danner en blok i JavaScript - dette er en af sprogets konstruktioner. Det vil sige, at hvis der er krøllede klammeparenteser efter for loop-sætningen, betyder det, at JavaScript-handleren skal udføre hele JavaScript-blokken.
I lighed med en blok kan du angive en funktion i en for-løkke. Her er et eksempel:
For (var i = 1; i
Men når en funktion erklæres, kræves der krøllede klammeparenteser (...). Deres fravær vil resultere i en fejl.
Bemærk venligst, at i denne løkke er variablen i erklæret i begyndelsen af løkken: for ( var i = 1; jeg
Springer efter deleGenerelt behøver begyndelsen af cyklussen ikke skrives:
Vari = 1; for (;i
Du kan se, i begyndelsen af løkken er der bare et semikolon, og løkken fungerer fint.
Du kan også fjerne trinnet:
Vari = 1; for (;i
Det her for sløjfe omdannet til en analog af while-løkken (dvs
Du kan sætte et udtryk i en tilstand, der ændrer en variabel.
For (i = 10; i--;) ( document.write("
Løkketrinnet udføres: " + i + ".
"); }Da JavaScript-fortolkeren forventer at modtage en boolsk værdi, resulterer enhver værdi i en boolsk type, så når variablen i bliver 0 (falsk) som et resultat af den næste dekrement, stopper løkken.
Uendelig for loopJa, ja, jeg ved godt, at det er korrekt at skrive uendelig :)
Så løkken vil være uendelig, hvis betingelsen altid er sand. Her er et eksempel:
For (var i = 1; i
I dette eksempel vil variablen i falde og aldrig blive større end fem. Løkken vil køre for evigt. Prøv at køre dette script. For mig var Chrome "tabt i tanker" og viste ikke noget på skærmen, men fortsatte med at tænke og tænke.
Vær forsigtig med at undgå ved et uheld at skabe endeløse sløjfer.
Afbrydelse af for-løkkenFor at bryde en for-løkke, ligesom at bryde enhver anden løkke, skal du bruge kommandoen break. Når JavaScript-motoren støder på en break-kommando i en løkkes brødtekst, stopper den med at udføre løkken og begynder at udføre scriptinstruktionerne, der følger løkken. hvis der er nogen.
I det følgende eksempel vil vi stoppe løkken ved den tredje iteration (tredje trin).
For (var i = 1; i
Lad os komplicere eksemplet lidtLad os kun udføre 100 iterationer af den uendelige løkke.
Var $tæller = 1; for (var i = 1; i
Næste iteration: fortsætFortsæt-kommandoen afslutter den aktuelle iteration og begynder den næste.
Fortsæt-direktivet er pausedirektivets "yngre søster"; det stopper kun iterationen og ikke hele løkken.
For (var i = 1; i
Sløjfen nedenfor bruger fortsætter med at udlæse ulige værdier:
For (var i = 0; i
Selvfølgelig kan ulige værdier udlæses ved hjælp af en sløjfe som denne uden et fortsæt-direktiv:
For (var i = 0; i
Pause/fortsæt-direktiverne i "?"Lad os kort beskrive operatøren spørgsmålstegn"?". Det ligner en if-konstruktion.
Logisk design:
Hvis (betingelse) ( a(); ) andet (b(); )
Virker på samme måde som kode med "?"-operatoren.
Tilstand? a(): b(); var i = 2; document.write("
Del 1.
"); if (i == 2) document.write("Tilstanden virkede.
"); andet document.write("Betingelsen virkede ikke.
"); document.write("Del 2.
"); i == 2 ? document.write("Tilstanden virkede.
"): document.write("Betingelsen virkede ikke.
");Så det er vigtigt, at du ikke kan bruge pause/fortsæt til højre for "?"-operatøren
I JavaScript er syntaktiske konstruktioner, der ikke returnerer værdier, forbudt at blive brugt i "?"-operatoren.
Nedenstående eksempel virker ikke, det indeholder en fejl:
For (var i = 0; i
Etiketter til pause/fortsætNogle gange bliver det nødvendigt at oprette indlejrede løkker. I et sådant tilfælde, mens den indlejrede løkke kører, kan det være nødvendigt at stoppe den overordnede løkke eller stoppe iterationen af den overordnede løkke. Tags bruges til dette.
Du kan bruge etiketter til at angive sløjfer, derefter bruge pause eller fortsætte med at forlade løkken eller fortsætte løkken med en ny iteration.
Markører er den eneste måde for pause- og fortsættelseskommandoer at påvirke udførelsen af den ydre sløjfe.
Etiketinstruktionen bruges kun i forbindelse med pause eller fortsætte med at give en alternativ udgang fra en sløjfe.
Etiketten har syntaksen "navn:", etiketnavnet skal være unikt. Mærket placeres før cyklussen, i samme linje eller med et linjeskift.
På samme måde kan du bruge pausedirektivet her. Men hvis du bruger det, som du forstår, vil udførelsen af cyklusser stoppe.
Var i, j; metka1: for (i = 0; i
I JavaScript Der er ingen goto-sætning som i PHP, det er kun muligt at bruge mærker med break eller continue .
Tags bruges sjældent i JavaScript-programmering, fordi de menes at gøre koden sværere at læse og forstå. Det anbefales at bruge funktioner ved kodning.
Denne indrykning kan betragtes som en indikator for kodekompleksitet (omend en ret grov sådan). Indrykninger i sig selv er neutrale, da de kun er et middel til at formatere tekst, men hele pointen er, at de bruges til at fremhæve specielle blokke af programmer, for eksempel kontrolstrukturer. Når man læser kode og støder på en indrykning, er programmøren tvunget til at tage hensyn til, hvad indrykningen indikerer, for at huske den kontekst, hvori den valgte blok eksisterer. Dette gentages naturligvis, hvis et andet specielt fragment vises i den indrykkede sektion af koden.
Hvis du ikke er opmærksom på indholdet af teksterne, ser det normalt sådan ud: kompleks kode, hvis sektioner ligner bogstaverne "V", der ligger på deres side, og den simple kode, hvis blok, hvis du ikke tager højde for linjernes forskellige længder, ligner et rektangel.
Jo flere fordybninger, jo mere kompleks er koden normalt.
Konstruktioner, der skal indrykkes, vil altid være i koden, der er ikke tale om at slippe helt af med dem. Men vi har magten til at reducere kompleksiteten af de programmer, vi skriver, ved rationelt at vælge abstraktioner for at løse de problemer, vi står over for.
Lad os tage arrays for eksempel. Traditionelt bruges forskellige typer cyklusser til at behandle dem. Begreberne "array" og "loop" er uløseligt forbundet i mange programmørers hoveder. Imidlertid er cyklussen en meget tvetydig konstruktion. Dette er, hvad Louis Atentzio skriver om loops i bogen “Functional Programming in JavaScript”: “A loop is a rigid kontrolstruktur, som ikke er let at genbruge og vanskeligt at integrere med andre operationer. Brug af loops betyder også at skabe kode, der ændres med hver iteration."
Er det muligt at slippe af med cyklusser?
Cyklussen er en af de vigtigste strukturelle kontrolstrukturer, og faktisk vil vi ikke sige, at cyklusser er et onde, der skal slippes af med. Vores hovedformålet er at reducere kompleksiteten egen kode på grund af minimal brug af loops ved behandling af arrays. Er det muligt? Vi inviterer jer til at finde ud af det sammen.
Loops Vi har allerede talt om, hvordan kontrolkonstruktioner som loops tilføjer kompleksitet til din kode. Men hvorfor er det sådan? Lad os tage et kig på, hvordan loops fungerer i JavaScript.Der er flere måder at organisere loops på i JS. Især en af de grundlæggende typer sløjfer er mens . Før vi dykker ned i detaljerne, lad os forberede os lidt. Vi vil nemlig lave en funktion og et array, som vi vil arbejde med.
// oodlify:: String -> String funktion oodlify(s) ( return s.replace(//g, "oodle"); ) const input = [ "John", "Paul", "George", "Ringo", ];
Så vi har et array, hvor hvert element vi skal behandle ved hjælp af odlify-funktionen. Hvis du bruger en while-løkke til at løse dette problem, får du følgende:
Lad i = 0; const len = input.length; lad output = ; mens jeg< len) {
let item = input[i];
let newItem = oodlify(item);
output.push(newItem);
i = i + 1;
}
Bemærk, at vi bruger i-tælleren til at holde styr på det aktuelt behandlede array-element. Den skal initialiseres til nul og øges med én i hver iteration af sløjfen. Derudover skal du sammenligne det med længden af arrayet, med len, for at vide, hvornår du skal stoppe med at arbejde.
Dette mønster er så almindeligt, at JavaScript har en nemmere måde at gøre dette på: en for loop. En sådan sløjfe vil løse det samme problem som følger:
Const len = input.length; lad output = ; for (lad i = 0; i< len; i = i + 1) {
let item = input[i];
let newItem = oodlify(item);
output.push(newItem);
}
For-løkken er en nyttig konstruktion, fordi den sætter alle standard hjælpetælleroperationer ind i øverste del blok. Ved at bruge while , er det let at glemme behovet for at øge tæller i , hvilket vil forårsage endeløs sløjfe. For-løkken er bestemt meget mere praktisk end while-løkken. Men lad os sætte farten ned og tage et kig på, hvad vores kode forsøger at opnå. Vi ønsker at behandle hvert element i arrayet ved hjælp af oodlify()-funktionen og sætte resultatet ind i et nyt array. Selve tælleren, der bruges til at få adgang til array-elementer, er ikke interessant for os.
Dette mønster for at arbejde med arrays, som involverer at udføre visse handlinger på hvert element, er meget almindeligt. Som et resultat introducerede ES2015 et nyt loop-design, der giver dig mulighed for at glemme alt om tælleren. Dette er en for ... af loop. Hver iteration af denne sløjfe giver det næste element i arrayet. Det ser sådan ud:
Lad output = ; for (lad et element af input) ( lad newItem = oodlify(item); output.push(newItem); )
Koden ser meget renere ud. Bemærk venligst, at der ikke er nogen tæller- eller sammenligningsoperation. Med denne tilgang behøver du ikke engang at kontakte specifikt element array efter indeks. For...of-løkken tager sig af alle hjælpeoperationer.
Hvis vi afslutter vores undersøgelse af måder at arbejde med arrays og brug for ... af loops overalt i stedet for for loops, vil dette allerede være et godt skridt fremad ved at forenkle koden. Men... vi kan gå længere.
Transformering af arrays For…of-løkken ser meget renere ud end for-løkken, men den har også en masse hjælpeelementer i koden. Så du skal initialisere output-arrayet og kalde push()-metoden i hver iteration af løkken. Koden kan gøres endnu mere kompakt og udtryksfuld, men før vi gør det, lad os udvide demoproblemet lidt. Hvad hvis du skal behandle to arrays ved hjælp af odlify()-funktionen?Const fellowship = [ "frodo", "sam", "gandalf", "aragorn", "boromir", "legolas", "gimli", ]; const band = [ "John", "Paul", "George", "Ringo", ];
En helt oplagt løsning er at bruge to loops og behandle arrays i dem:
Lad bandoodle = ; for (lad båndet) ( lad newItem = oodlify(item); bandoodle.push(newItem); ) lad floodleship = ; for (lad et element af fællesskab) ( lad newItem = oodlify(item); floodleship.push(newItem); )
Sikke en fungerende mulighed. Og kode, der virker, er meget bedre end kode, der ikke løser det problem, der er tildelt den. Men to meget lignende stykker kode passer ikke særlig godt til DRY-softwaredesignprincippet. Koden kan refaktoriseres for at reducere gentagelser.
Efter denne idé opretter vi følgende funktion:
Funktion oodlifyArray(input) ( lad output = ; for (lad inputelement) ( lad newItem = oodlify(item); output.push(newItem); ) returner output; ) lad bandoodle = oodlifyArray(band); lad floodleship = oodlifyArray(fellowship);
Dette ser meget bedre ud, men hvad hvis der er en anden funktion, som vi også vil behandle array-elementer med?
Funktion izzlify(s) (retur s.replace(/+/g, "izzle"); )
Nu vil odlifyArray()-funktionen ikke hjælpe. Men hvis vi opretter en anden lignende funktion, denne gang izzlufyArray() , vil vi gentage os selv igen. Lad os stadig oprette sådan en funktion og sammenligne den med oodlifyArray():
Funktion oodlifyArray(input) ( lad output = ; for (lad inputelement) ( lad newItem = oodlify(item); output.push(newItem); ) returner output; ) funktion izzlifyArray(input) ( lad output = ; for ( lad inputelement) ( lad newItem = izzlify(item); output.push(newItem); ) returnere output; )
De to funktioner er utroligt ens. Måske kan vi opsummere det mønster, de følger? Vores mål er dette: "Vi har et array og en funktion. Vi skal have et nyt array, hvor resultaterne af behandlingen af hvert element i det originale array ved hjælp af funktionen vil blive skrevet." Denne metode til at behandle arrays kaldes "mapping" eller "transformation" (mapping i engelsk terminologi). Funktioner, der udfører sådanne operationer, kaldes normalt "kort". Sådan ser vores version af sådan en funktion ud:
Funktionskort(f, a) ( lad output = ; for (lad element af a) ( output.push(f(item)); ) returner output; )
Selvom løkken nu er en separat funktion, var det ikke muligt helt at slippe af med den. Hvis du går hele vejen og prøver at undvære cykliske konstruktioner helt, kan du skrive en rekursiv version af det samme:
Funktionskort(f, a) ( if (a.længde === 0) ( return ; ) return .concat(map(f, a.slice(1))); )
Den rekursive løsning ser meget elegant ud. Bare et par linjer kode og et minimum af indrykning. Men rekursive implementeringer af algoritmer bruges normalt med stor forsigtighed, og de lider også af dårlig ydeevne i ældre browsere. Og faktisk behøver vi egentlig ikke skrive en funktion for at implementere kortlægningen selv, medmindre der er en god grund til at gøre det. Hvad vores kortfunktion gør, er så almindelig en opgave, at JavaScript har en indbygget map()-metode. Hvis du bruger denne metode, vil koden se sådan ud:
Lad bandoodle = band.map(oodlify); lad floodleship = fellowship.map(oodlify); lad bandizzle = band.map(izzlify); lad fellowship = fellowship.map(izzlify);
Bemærk, at der ikke er nogen fordybning eller sløjfe overhovedet. Selvfølgelig kan der bruges loops ved behandling af data, et sted i dybet af JavaScript, men det er ikke længere vores bekymring. Nu er koden både kortfattet og udtryksfuld. Desuden er det enklere.
Hvorfor er denne kode enklere? Det kan virke som et dumt spørgsmål, men tænk over det. Er det nemmere, fordi det er kortere? Ingen. Kompakt kode er ikke et tegn på enkelhed. Det er enklere, fordi vi med denne tilgang har delt problemet op i dele. Der er nemlig to funktioner, der fungerer med strenge: oodlify og izzlify. Disse funktioner behøver ikke at vide noget om arrays eller loops. Der er en anden funktion - map, som fungerer med arrays. Samtidig er det fuldstændig ligegyldigt, hvilken type data der er i arrayet, eller hvad vi helt præcist vil med disse data. Det udfører simpelthen enhver funktion, der er sendt til det, og sender det elementerne i arrayet. I stedet for at blande alt sammen, adskilte vi strengbehandling og array-behandling. Derfor viste den endelige kode sig at være enklere.
Konvolution af arrays Så kortfunktionen er meget nyttig, men den dækker ikke alle muligheder for at behandle arrays, der bruger loops. Det er godt i tilfælde, hvor du ud fra et bestemt array skal oprette en ny med samme længde. Men hvad nu hvis vi for eksempel skal lægge alle elementerne i en numerisk matrix sammen? Eller hvad hvis du skal finde den korteste streng på listen? Nogle gange har du brug for at behandle et array og i virkeligheden generere en enkelt værdi baseret på det.Lad os se på et eksempel. Lad os sige, at vi har en liste over objekter, som hver repræsenterer en superhelt:
Const heroes = [ (navn: "Hulk", styrke: 90000), (navn: "Spider-Man", styrke: 25000), (navn: "Hawk Eye", styrke: 136), (navn: "Thor", styrke: 100000), (navn: "Black Widow", styrke: 136), (navn: "Vision", styrke: 5000), (navn: "Scarlet Witch", styrke: 60), (navn: "Mystique", styrke: 120), (navn: "Namora", styrke: 75000), ];
Vi skal finde den stærkeste helt. For at gøre dette kan du bruge for...of-løkken:
Lad stærkest = (styrke: 0); for (lad hero of heroes) ( if (helte.styrke > stærkeste.styrke) ( stærkest = helt; ) )
Alt taget i betragtning er denne kode ikke så slem. Vi går gennem arrayet og gemmer objektet for den stærkeste helt, vi så på, i den stærkeste variabel. For at se mønsteret for at arbejde med et array mere klart, lad os forestille os, at vi også skal finde ud af den samlede styrke af alle heltene.
Lad kombineret Styrke = 0; for (lad helte af helte) ( kombineretStyrke += helte.styrke; )
I hvert af disse to eksempler er der en arbejdsvariabel, der initialiseres, før løkken starter. Derefter behandles et element i arrayet i hver iteration, og variablen opdateres. For at fremhæve arbejdsskemaet endnu bedre, vil vi flytte de operationer, der udføres inde i sløjferne, til funktioner og omdøbe variablerne for at understrege ligheden mellem de udførte handlinger.
Funktion greaterStrength(champion, contender) ( return (contender.strength > champion.strength) ? contender: champion; ) function addStrength(tally, hero) (retur tally + hero.strength; ) const initialStrongest = (styrke: 0); lad arbejde = initialStærkest; for (hero of heroes) ( working = greaterStrength(working, hero); ) const strongest = working; const initialCombinedStrength = 0; working = initialCombinedStrength; for (hero of heroes) ( working = addStrength(working, hero); ) const combinedStrength = working;
Hvis alt omskrives som vist ovenfor, ender de to sløjfer med at blive meget ens. Det eneste, der adskiller dem, er de funktioner, der er kaldt i dem, og de indledende værdier af variablerne. I begge sløjfer er arrayet sammenklappet til en enkelt værdi. I engelsk terminologi kaldes en sådan operation "reducing". Derfor vil vi lave en reduktionsfunktion, der implementerer det opdagede mønster.
Funktion reducer(f, initialVal, a) ( lad arbejde = initialVal; for (lad element af a) ( arbejder = f(virker, emne); ) returnerer til arbejde; )
Det skal bemærkes, at som med kortfunktionsmønsteret, er reducere-funktionsmønsteret så udbredt, at JavaScript giver det som en indbygget array-metode. Medmindre der er en særlig grund til det, er der derfor ingen grund til at skrive din egen metode. Ved at bruge standardmetoden vil koden se sådan ud:
Const strongestHero = heroes.reduce(greaterStrength, (styrke: 0)); const combinedStrength = heroes.reduce(addStrength, 0);
Hvis du ser nærmere på det endelige resultat, vil du opdage, at den resulterende kode ikke er meget kortere, end hvad der var før, besparelsen er meget lille. Hvis vi havde brugt reducere-funktionen, skrevet selv, så ville koden generelt have været større. Vores mål er dog ikke at skrive kort kode, men for at reducere dens kompleksitet. Så har vi reduceret kompleksiteten af programmet? Jeg kan sige, at de har reduceret det. Vi har adskilt looping-koden fra koden, der behandler array-elementer. Som resultat separate områder programmer er blevet mere uafhængige. Koden viste sig enklere.
Ved første øjekast kan reduktionsfunktionen virke ret primitiv. De fleste eksempler på denne funktion viser simple ting som at tilføje alle elementerne i numeriske arrays. Der står dog ingen steder, at den værdi, der reducerer afkast, skal være en primitiv type. Det kan være et objekt eller endda et andet array. Da jeg først indså dette, overraskede det mig. Du kan for eksempel skrive en implementering af en matrix-mapping eller filtreringsoperation ved hjælp af reduce . Jeg foreslår, at du selv prøver det.
Filtrering af arrays Så der er en kortfunktion til at udføre operationer på hvert element i arrayet. Der er en reduktionsfunktion, der giver dig mulighed for at komprimere et array til en enkelt værdi. Men hvad nu hvis du kun skal udtrække nogle af elementerne fra arrayet? For at udforske denne idé, lad os udvide listen over superhelte og tilføje nogle yderligere data der:Const heroes = [ (navn: "Hulk", styrke: 90000, køn: "m"), (navn: "Spider-Man", styrke: 25000, køn: "m"), (navn: "Hawk Eye", styrke: 136, køn: "m"), (navn: "Thor", styrke: 100.000, køn: "m"), (navn: "Black Widow", styrke: 136, køn: "f"), (navn : "Vision", styrke: 5000, køn: "m"), (navn: "Scarlet Witch", styrke: 60, køn: "f"), (navn: "Mystique", styrke: 120, køn: "f "), (navn: "Namora", styrke: 75000, køn: "f"), ]);
Antag nu, at der er to problemer:
Lad kvindeligeHeroes = ; for (lad hero of heroes) ( if (hero.sex === "f") ( femaleHeroes.push(hero); ) ) lad superhumans = ; for (lad hero of heroes) ( if (helte.styrke >= 500) ( superhumans.push(helt); ) )
Generelt ser det ganske anstændigt ud. Men her er et gentaget mønster synligt med det blotte øje. Faktisk er løkkerne nøjagtig de samme, de adskiller sig kun i if-blokkene. Hvad hvis vi sætter disse blokke i funktioner?
Funktionen erFemaleHero(helt) ( return (helte.køn === "f"); ) funktion erOvermenneske(helt) ( return (helte.styrke >= 500); ) lad kvindeligeHelte = ; for (lad hero of heroes) ( if (erFemaleHero(hero)) ( femaleHeroes.push(hero); ) ) lad superhumans = ; for (lad heltenes helt) (hvis (er Overmenneske(helt)) ( supermennesker.push(helt); ) )
Funktioner, der kun returnerer sandt eller falsk, kaldes nogle gange prædikater. Vi bruger et prædikat til at beslutte, om vi vil gemme den næste værdi fra heroes-arrayet i et nyt array.
Den måde, vi omskrev koden på, gjorde den længere. Men efter at have fremhævet prædikatfunktionerne blev de gentagne sektioner af programmet bedre synlige. Lad os oprette en funktion, der giver os mulighed for at slippe af med disse gentagelser:
Funktion filter(prædikat, arr) ( lad arbejde = ; for (lad arr) ( if (prædikat(element)) ( working = working.concat(item); ) ) return working; ) const femaleHeroes = filter(erFemaleHero, helte); const superhumans = filter(er Overmenneske, helte);
Her, som med de indbyggede kort- og reducerefunktioner, har JavaScript det samme, som vi skrev her i form af en standard filtermetode på Array-objektet. Skriv derfor egen funktion, medmindre det er klart nødvendigt, ikke nødvendigt. Ved brug af standard midler koden vil se sådan ud:
Const femaleHeroes = heroes.filter(erFemaleHero); const superhumans = helte.filter(er Overmenneske);
Hvorfor er denne tilgang så meget bedre end at bruge en for ... of loop? Tænk over, hvordan du kan bruge dette i praksis. Vi har en opgave som: “Find alle de helte, der...”. Når du har fundet ud af, at du kan løse problemet ved hjælp af standardfilterfunktionen, bliver jobbet lettere. Det eneste, vi skal gøre, er at fortælle denne funktion, hvilke elementer vi er interesserede i. Dette gøres ved at skrive én kompakt funktion. Der er ingen grund til at bekymre sig om at behandle arrays eller yderligere variabler. I stedet skriver vi en lillebitte prædikatfunktion, og problemet er løst.
Og som med andre funktioner, der fungerer på arrays, giver brug af filter dig mulighed for at udtrykke mere information i mindre kode. Det er ikke nødvendigt at læse det hele standard kode loop for at forstå, hvad vi præcist filtrerer. I stedet beskrives alt, hvad du skal forstå, lige når metoden kaldes.
Søgning i arrays Filtrering er en meget nyttig operation. Men hvad nu hvis du kun skal finde én superhelt fra listen? Lad os sige, at vi er interesserede i Black Widow. Filterfunktionen kan bruges til at løse dette problem:Funktion isBlackWidow(hero) (retur (hero.name === "Black Widow"); ) const blackWidow = heroes.filter(isBlackWidow);
Hovedproblemet her er, at en sådan løsning ikke er effektiv. Filtermetoden går gennem hvert element i arrayet. Det er dog kendt, at i arrayet kun én helt kaldes Black Widow, hvilket betyder, at du kan stoppe, efter at denne helt er fundet. Samtidig er prædikatfunktioner praktiske at bruge. Lad os derfor skrive en find-funktion, der finder og returnerer det første matchende element:
Funktion find(prædikat, arr) ( for (lad emne af arr) ( if (prædikat(element)) ( returner emne; ) ) ) const blackWidow = find(erSortEnke, helte);
Her skal det igen siges, at JavaScript har en indbygget funktion, der gør præcis det, der skal til:
Const blackWidow = heroes.find(isBlackWidow);
Som et resultat var vi som før i stand til at udtrykke vores idé mere kortfattet. Bruger indbygget finde funktioner, kommer opgaven med at søge efter et specifikt element ned til et spørgsmål: "Med hvilke kriterier kan vi fastslå, at det ønskede element er fundet?" Du behøver ikke bekymre dig om detaljerne.
Funktion procesStyrke((stærkestHelt, kombineretStyrke), helt) ( return ( stærkesteHelt: størreStyrke(stærkesteHelt, helt), kombineretStyrke: tilføjeStyrke(kombineretStyrke, helt), ); ) const (stærkesteHelt, kombineretStyrke) = helte.reducere(procesStyrke, : (styrke: 0), kombineret Styrke: 0));
Jeg kan ikke undgå at bemærke, at denne version vil være lidt mere kompliceret end den, hvor arrayet blev krydset to gange, men hvis arrayet er enormt, kan det være meget nyttigt at reducere antallet af passage over det. Under alle omstændigheder forbliver rækkefølgen af kompleksitet af algoritmen O(n).
Faktisk, hvis du tænker over alt dette, kan du komme til en konklusion, der umiddelbart virker overraskende. Det viser sig, at hvis du kun bruger de fire array-behandlingsmønstre beskrevet ovenfor, kan du fjerne næsten alle loops fra din JS-kode. Når alt kommer til alt, hvad gøres der i næsten hver løkke skrevet i JavaScript? Det enten behandler eller konstruerer et bestemt array eller gør begge dele. Derudover har JS andre standardfunktioner til at arbejde med arrays, du kan nemt selv lære dem. At slippe af med loops reducerer næsten altid programmernes kompleksitet og skriver kode, der er lettere at læse og vedligeholde.
Kære JavaScript-udviklere, har du noget i tankerne? standard funktioner, som giver dig mulighed for at forbedre koden ved at slippe af med nogle almindelige "hjemmelavede" konstruktioner?
Tags: Tilføj tags
Loops er en enkel måde at gøre noget på flere gange. Dette kapitel i JavaScript-guiden vil introducere dig til forskellige operatører tilgængelig i JavaScript.
Du kan tænke på loopet som en computeriseret version af et spil, hvor du fortæller nogen om at tage X skridt i den ene retning, og derefter Y trin i den anden; For eksempel kan ideen om spillet "Gå 5 trin øst" udtrykkes som en løkke:
Var trin; for (trin = 0; trin< 5; step++) { // Запускается 5 раз, с шагом от 0 до 4. console.log("Идём 1 шаг на восток"); }
Der er mange forskellige typer sløjfer, men de gør alle i det væsentlige det samme: de gentager en handling flere gange (glem ikke nul-gentagelsestiden, optællingen i arrayet starter fra 0). Cyklusser af forskellige strukturer tilbyder forskellige veje at bestemme begyndelsen og slutningen af en cyklus. Til forskellige opgaver programmering har sine egne loop-operatorer, ved hjælp af hvilke de kan løses meget lettere.
Operatører designet til at organisere loops i JavaScript:
for sløjfeFor-løkken gentager handlinger, indtil der indtræffer en særlig hændelse for sløjfeterminering. For-sætningen i JavaScript ligner for-sætningen i Java og C. Erklæringen for for-sætningen er som følger:
For ([start]; [betingelse]; [trin]) udtryk
Når det udføres, sker følgende:
Følgende funktion har en for-løkke, der tæller antallet af valgte genrer i rullelisten (det element, der giver dig mulighed for at vælge flere elementer). For-løkken erklærer en variabel i og sætter dens værdi til 0. Den kontrollerer også, at i er mindre end antallet af elementer i elementet, udfører if-sætningen og øger i med én efter hver passage gennem løkken.
Vælg nogle musikgenrer, og klik derefter på knappen nedenfor: R&B Jazz Blues New Age Classical Opera
function howMany(selectObject) ( var numberSelected = 0; for (var i = 0; i< selectObject.options.length; i++) { if (selectObject.options[i].selected) { numberSelected++; } } return numberSelected; } var btn = document.getElementById("btn"); btn.addEventListener("click", function(){ alert("Выбрано элементов: " + howMany(document.selectForm.musicTypes)) }); gør ... mens loopDo...while loop gentages mens givet tilstand rigtigt. Do...while-udsagnet ser sådan ud:
Gør udtryk mens (betingelse);
udtryk udføres, så længe betingelsen er sand. Hvis du vil bruge flere udtryk, skal du bruge et blokudtryk ( ... ) til at gruppere dem. Hvis betingelsen er sand, vil udtrykkene blive udført igen. Ved slutningen af hvert gennemløb kontrolleres tilstanden. Hvis betingelsen er falsk, suspenderes eksekveringen, og kontrollen overføres til udtrykket efter do...while .
EksempelI det følgende eksempel vil do-løkken blive udført mindst 1 gang og køre igen, så længe i er mindre end 5.
Gør ( i += 1; console.log(i); ) mens (i< 5);
mens loopWhile-løkken udfører udtryk, så længe betingelsen er sand. Det ser sådan ud:
Mens (betingelse) udtryk
Hvis betingelsen bliver falsk, stopper udtrykkene i løkken med at udføre, og kontrol overføres til udtrykket efter løkken.
Betingelsen kontrolleres for at være sand, før udtrykkene i løkken udføres. Hvis betingelsen er sand, udføres udtrykkene, og derefter testes betingelsen igen. Hvis betingelsen er falsk, suspenderes eksekveringen, og kontrol flyttes til udtrykket efter et stykke tid.
Hvis du vil bruge flere udtryk, skal du bruge en udtryksblok ( ... ) til at gruppere dem.
Eksempel 1Følgende mens-løkke kører, så længe n er mindre end tre:
Varn = 0; var x = 0; mens (n< 3) { n++; x += n; }
Med hver iteration øges løkken n og tilføjer denne værdi til x. Derfor får x og n følgende værdier:
- Efter det første gennemløb: n = 1 og x = 1
- Efter den anden: n = 2 og x = 3
- Efter tredje gennemløb: n = 3 og x = 6
Efter tredje gennemløb, betingelse n< 3 становится ложным, поэтому цикл прерывается.
Eksempel 2Undgå endeløse sløjfer. Sørg for, at sløjfetilstanden til sidst bliver falsk; ellers vil cyklussen aldrig blive afbrudt. Udtrykkene i den næste mens-løkke vil køre for evigt, fordi betingelsen bliver aldrig falsk:
Mens (sand) ( console.log("Hej, verden"); )
EtiketEn etiket er en erklæring med en identifikator, der giver dig mulighed for at henvise til et sted i dit program. For eksempel kan du bruge en etiket til at angive en løkke og derefter bruge break- eller continue-sætninger til at angive, om programmet skal bryde løkken eller fortsætte med at udføre den.
Etiketsyntaksen er som følger:
Tag: operatør
Betyder tags kan være et hvilket som helst gyldigt JavaScript-id, der ikke er et reserveret ord. Operatør , den, du angiver efter etiketten, kan være et hvilket som helst udtryk.
EksempelI dette eksempel repræsenterer markLoop en while-løkke.
MarkLoop: while (theMark == true) (doSomething(); )
pauseBrug break-sætningen til at bryde en løkke, ændre kontrol eller i kombination med label-sætningen.
- Når du bruger break uden en etiket, bryder den while , do-while og for loops eller skifter straks kontrol til det næste udtryk.
- Når du bruger break med et mærke, bryder det det særligt markerede udtryk.
Operatorsyntaksen kunne være:
Den første form for syntaks bryder løkken helt eller skifter kontrol; den anden afbryder et særligt udpeget udtryk.
Eksempel 1Følgende eksempel itererer gennem elementerne i et array, indtil det finder et element, hvis værdi er theValue:
For (i = 0; i< a.length; i++) { if (a[i] == theValue) { break; } }
Eksempel 2: Etiketafbrydelse var x = 0; var z = 0 labelCancelLoops: while (sand) ( console.log("Ydre sløjfe: " + x); x += 1; z = 1; while (sand) (console.log("Indre sløjfe: " + z); z += 1; if (z === 10 && x === 10) ( break labelCancelLoops; ) else if (z === 10) ( break; ) ) ) fortsætFortsæt-sætningen bruges til at gå et skridt frem i while , do-while , for loops eller til at hoppe til en etiket.
- Når du bruger fortsæt uden en etiket, bryder den den aktuelle iteration af while , do-while og for loops og fortsætter loopen fra næste iteration. I modsætning til break afbryder fortsæt ikke udførelsen af løkken fuldstændigt. I while-løkken hopper den til tilstanden. Og ind for det øger skridtet.
- Når du bruger fortsæt med en etiket, anvendes den på løkken med den pågældende etiket.
Fortsæt-syntaksen kan se sådan ud:
Følgende eksempel viser en while-løkke med en continue-sætning, der udløses, når værdien af i er 3. Således får n værdierne 1, 3, 7 og 12.
Vari = 0; var n = 0; mens jeg< 5) { i++; if (i == 3) { continue; } n += i; }
Eksempel 2Udtryk markeret checkiandj indeholder udtrykket markeret checkj. Når du støder på fortsæt, afbryder programmet den aktuelle iteration checkj og starter næste iteration. Hver gang du støder på, fortsæt, checkj fortsætter til næste iteration, så længe betingelsen returnerer falsk. Når falsk returneres efter beregning af resten af en division checkiandj, checkiandj fortsætter til næste iteration, så længe dens tilstand returnerer falsk. Når false returneres, fortsætter programmet eksekveringen med udtrykket efter checkiandj.
Hvis Fortsæt er markeret checkiandj, kan programmet fortsætte fra begyndelsen af mærket checkiandj.
Checkiandj: mens (dvs< 4) { console.log(i); i += 1; checkj: while (j >4) ( console.log(j); j -= 1; if ((j % 2) != 0) ( fortsæt checkj; ) console.log(j + "even."); ) console.log("i = " + i); console.log("j = " + j); )
for ... iFor...in-sætningen itererer gennem alle utallige egenskaber for et objekt. JavaScript vil udføre de angivne udtryk for hver enkelt egenskab. For...in-løkken ser sådan ud:
For (variabel i objekt) (udtryk)
EksempelDen følgende funktion tager et objekt og dets navn som dets argument. Det itererer derefter gennem alle objektets egenskaber og returnerer en streng, der indeholder egenskabsnavnene og deres værdier.
Funktion dump_props(obj, obj_name) ( var result = ""; for (var i i obj) ( resultat += obj_name + "." + i + " = " + obj[i] + "
"; ) resultat += ""; returner resultat; )
For et bilobjekt med mærke- og modelegenskaber, resultat vil:
Bil.mærke = Ford bil.model = Mustang
Eksempel nr. 2Du kan også få vist værdien med tast:
Lad obj = (model: "AUDI A8", årgang: "2019", farve: "brun") for (tast obj) ( console.log(`$(key) = $(obj)`); ) // model = AUDI A8 // årgang = 2019 // farve = brun
ArraysSelvom det er fristende at bruge for ... som en måde at iterere gennem alle elementerne i et array, returnerer denne operator navnet på brugerdefinerede egenskaber ud over de numeriske indekser. Det er således bedre at bruge standarden for for numeriske indekser, når man interagerer med arrays, da for...in-sætningen går igennem specifik bruger egenskaber ud over array-elementerne, hvis du ændrer arrayet, såsom tilføjelse af egenskaber og metoder.
Til( variabel af objekt) { udtryk}
Det følgende eksempel viser forskellen mellem for...of og for...in loops. Mens for...in iterates over ejendomsnavne, for...of iterates over ejendomsværdier:
Lad arr = ; arr.foo = "hej"; for (lad i arr) ( console.log(i); // udskriver "0", "1", "2", "foo" ) for (lad i af arr) ( console.log(i); / / udsender "3", "5", "7")
Hovedformålet med JavaScripts mens er at gentagne gange køre et bestemt stykke kode, igen og igen. Det ligner meget en for-løkke med en vigtig forskel. Lad mig tage lidt af din tid til at forklare forskellen mellem disse to typer cyklusser.
Hvad er forskellen mellem while og for loops?Forskellen mellem disse loops er, hvordan de stopper med at udføre et stykke kode.
For-løkken udfører et bestemt antal iterationer. Vi ved præcis, hvor mange gange løkken vil udføre kodefragmentet, der er indeholdt i dens krop.
Imens sker alting anderledes. En JavaScript while-løkke kører, så længe en bestemt betingelse er sand. Når betingelsen evalueres til falsk, afsluttes while-løkken.
Grunden til, at disse loops er forskellige, er, at vi ikke nødvendigvis på forhånd kan vide, hvornår en given betingelse ikke længere vil være sand. Derfor kan vi ikke forudsige, hvor mange iterationer af while-løkken vil fuldføre, før den går i stykker.
Fordele og ulemper ved while-løkkenLad mig starte med at se på den eneste store ulempe ved while-løkken. Det kan fungere for evigt!
Hvis du befinder dig i en situation, hvor while-løkken fortsætter med at køre på ubestemt tid, vil dit program sidde fast (eller fryse). Derefter skal du lukke browseren for at afbryde udførelsen af JavaScript-koden.
Jeg bør bemærke, at JavaScripts uadministrerede while-løkke normalt ikke kører for evigt. For som programmører har vi altid et ansvar for at sikre, at tilstanden af vores while-løkke på et tidspunkt bliver falsk.
Nu med hensyn til "fordelene" - de er meget indlysende. Mens vil køre kontinuerligt, så længe betingelsen er opfyldt. Et eksempel på at bruge en while-løkke er at bede brugeren om at indtaste data. Sløjfen vil bede dig om at indtaste data igen og igen, indtil brugeren indtaster de korrekte data.
Mens loop syntaksSyntaksen for for og while-løkker er meget ens.
Du skal bruge nøgleordet while og også definere en betingelse, hvorunder løkken vil blive udført. Som andre kontrolstrukturer definerer while-løkken dens omfang.
Sådan skal koden se ud:
while () ( // indsæt kode her, der skal udføres i en loop)
Den sværeste del er at bestemme, hvilken tilstand eller hvilke forhold der skal placeres i løkken, for at det fungerer korrekt.
Husk, at så længe betingelsen er sand, vil løkken fortsætte med at køre. Lad os se på et eksempel på brug af mens i JavaScript.
Eksempel mens loopLad os sige, at vi vil bede brugeren om at indtaste et tal mellem 1 og 10. Men hvad sker der, hvis han indtaster det forkerte tal?
I dette tilfælde skal vi bede ham om at indtaste værdien igen, og tjekke om betingelsen er opfyldt (om et tal mellem 1 og 10 er indtastet).
Dette er et tilfælde, hvor en for-løkke ville mislykkes dybt. For vi kan ikke på forhånd vide, hvor mange gange vi skal bede brugeren om at indtaste det rigtige nummer. I dette tilfælde kommer while-løkken os til hjælp.
Sådan kan vores kode se ud:
var theNumber = prompt("Indtast venligst et tal mellem 1 og 10."); mens (nummeret< 1 || theNumber >10 || isNaN(theNumber)) ( theNumber = prompt("Ugyldig værdi indtastet, indtast venligst et tal mellem 1 og 10!"); ) alert("Fremragende! Du indtastede et tal: " + theNumber);
Det er værd at bemærke, at i ovenstående eksempel har vi tre separate betingelser i en JavaScript while-løkke.
Disse tre betingelser er: theNumber 10 || er NaN(tallet) . De angiver følgende:
- HVIS tallet er mindre end 1, ELLER;
- HVIS Tallet er større end 10, ELLER;
- HVIS theNumber IKKE er et tal, så fortsæt løkken.
Da vi bruger OR-operatoren (||) mellem alle betingelserne, betyder det, at hvis nogen af betingelserne er sande, så almen tilstand while-løkken vil evalueres til sand, og løkken vil fortsætte med at udføre.
Kun hvis alle tre betingelser evalueres til falsk, vil while-løkkens overordnede tilstand evalueres til falsk, og den stopper.
KonklusionJavaScript while loop er den eneste rigtige loop i programmeringssprog. for er blot en speciel variation af while-løkken.
Dette er et tilfælde, hvor du selv kan genskabe en for-løkke ved hjælp af while-løkke-syntaksen, se og lære:
var tæller = 0; mens (tæller< 10) { counter = counter + 1; console.log("The counter is currently at: " + counter); }
Koden vil blive gentaget præcis 10 gange, hverken mere eller mindre. Det er præcis sådan for-løkken fungerer.
Der er ingen grund til at være bange for at bruge JavaScript, mens . For uden det ville mange applikationer simpelthen ikke fungere ordentligt!
Jeg håber, du nød denne artikel.
Oversættelsen af artiklen "While Loop in JavaScript" blev udarbejdet af det venlige projektteam.
God dårlig
JavaScript-løkker giver dig mulighed for at udføre gentagne beregninger igen og igen. De optimerer kodningsprocessen ved at udføre den samme sætning eller blok af sætninger, som udgør kroppen af en sløjfe et bestemt antal gange (ved at bruge en tællervariabel), eller mens en specificeret betingelse er sand. Sløjfer itererer over en sekvens af værdier. At udføre en loop én gang kaldes iteration.
Ydeevnen af en loop påvirkes af antallet af iterationer og antallet af operationer, der udføres i loop-kroppen af hver iteration.
Følgende loop-operatorer findes i JavaScript:
1) for bruges, når du på forhånd ved, hvor mange gange du skal gøre noget;
2) for...in bruges til at krydse objekters egenskaber;
3) mens bruges, når du ikke ved, hvor mange gange du skal gøre noget;
4) gør...mens fungerer på samme måde med operatør mens. Den adskiller sig ved at gøre...mens den altid udfører udtrykket i krøllede seler, men i det mindsteén gang, selvom tilstandstesten returnerer falsk .
For-løkken bruges til at iterere gennem elementerne i arrays eller array-lignende objekter såsom argumenter og HTMLCollection. Betingelsen kontrolleres før hver iteration af løkken. Hvis kontrollen lykkes, udføres koden inde i løkken, ellers udføres koden inde i løkken ikke, og programmet fortsætter fra første linje umiddelbart efter løkken.
Den næste løkke vil udskrive linjen Hej, JavaScript! Fem gange.
For (var i = 0; i< 5; i++) {
console.log(i + ": Hello, JavaScript!");
}
Ris. 1. Resultat af at udføre en for-løkke på konsollen
For-løkken består af tre forskellige operationer:
Trin 1. initialisering var i = 0; — erklæring af en tællervariabel, der vil blive kontrolleret under udførelse af sløjfe. Denne variabel initialiseres med værdien 0. Oftest fungerer variabler kaldet i, j og k som loop-tællere.
Trin 2. kontrol af tilstand i< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В i dette eksempel Betingelsen kontrolleres, så længe tællerværdien er mindre end 5.
Trin 3. Den sidste i++-operation er tællerinkrementoperationen, som øger værdien af variablen var i med én. I stedet for stigningsoperationen kan sænkningsoperationen også bruges.
I slutningen af løkken gemmes variablen var i ved 1. Den næste iteration af løkken udføres for (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .
1.2. Udskrivning af matrixværdierFor at udskrive matrixværdier ved hjælp af en for-løkke skal du bruge egenskaben array længde. Dette vil hjælpe dig med at bestemme antallet af elementer i arrayet og sløjfe det samme antal gange.
Scriptet nedenfor viser fem beskeder med navnene på farverne:
Var blomster = ["Rose", "Lily", "Tulipan", "Jasmin", "Orchid"]; for (var i = 0; i< flowers.length; i++){ alert(flowers[i] + " - это цветок."); }
Hvis værdien af egenskaben length ikke ændres under løkken, kan du gemme den i en lokal variabel og derefter bruge denne variabel i et betinget udtryk. På denne måde kan du øge hastigheden af løkken, da værdien af egenskaben længde kun vil blive hentet én gang i løbet af hele løkkens varighed.
Var blomster = ["Rose", "Lilje", "Tulipan", "Jasmin", "Orkidé"], len = blomster.længde; for (var i = 0; i
2. Loop for...inFor...in loops bruges til at krydse egenskaberne for ikke-array-objekter. Denne form for krydsning kaldes også opregning. Når du krydser, anbefales det at bruge metoden hasOwnProperty() til at bortfiltrere egenskaber, der blev nedarvet fra prototypen.
Lad os f.eks. oprette et objekt ved hjælp af et objekt bogstaveligt.
Var bruger = (navn: "Alice", alder: 25, land: "Rusland" ); for (var prop i bruger) ( console.log(prop + ": " + bruger); ) 
Ris. 2. Resultat af udførelse af for...in-løkken på konsollen
Lad os antage, at prototypen i et scenarie før eller efter oprettelse af et brugerobjekt Objekt blev udvidet yderligere metode clone() .
If (typeof Object.prototype.clone === "udefineret") ( Object.prototype.clone = funktion () (); )
Da prototypens arvekæde konstant kontrolleres af tolken, får alle objekter automatisk adgang til den nye metode.
Ris. 3. Resultat af gentagelse af for...in-løkken på konsollen For at undgå detektering af denne metode, mens egenskaberne for brugerobjektet opregnes, bruges metoden hasOwnProperty(), som vil bortfiltrere egenskaberne for prototypen.
Var bruger = (navn: "Alice", alder: 25, land: "Rusland" ); if (typeof Object.prototype.clone === "udefineret") ( Object.prototype.clone = funktion () (); ) for (var prop i bruger) ( if (user.hasOwnProperty(prop)) ( console.log (prop + ": " + bruger); ) ) 
Ris. 4. Resultatet af at angive egenskaberne for et objekt ved hjælp af hasOwnProperty()-metoden
Mens loop - loop med forhåndstjek betinget udtryk. Sætningen inde i løkken (blok med kode i krøllede parenteser) vil blive udført, hvis det betingede udtryk evalueres til sand . Hvis den første kontrol returnerer falsk, vil blokken af instruktioner ikke blive udført én gang.
Når loop-iterationen er fuldført, testes det betingede udtryk igen for sandhed, og processen gentages, indtil udtrykket evalueres til falsk . I dette tilfælde fortsætter programmet fra første linje umiddelbart efter løkken (hvis der er en).
Denne løkke viser multiplikationstabellen for tallet 3:
Vari = 1; var msg = ""; mens jeg< 10) {
msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg); 
Ris. 5. Resultat af udførelse af while-løkken
Løkke gør...mens; kontrollerer fortsættelsestilstanden efter løkken er udført. I modsætning til while-løkken, i do...while; Brødteksten af løkken udføres mindst én gang, da betingelsen kontrolleres i slutningen af løkken og ikke i begyndelsen. Denne sløjfe bruges sjældnere end mens , da det i praksis er sjældent, at en situation, hvor der kræves mindst én loop-udførelse.
Var resultat = ""; var i = 0; gør (i += 1; resultat += i + " "; ) mens (i< 5);
document.write(result);
Ris. 6. Resultat af udførelse af do...while loop
I det følgende eksempel udføres sætningerne i en loop én gang, selvom betingelsen ikke er sand.
Vari = 10; do ( document.write(i + " "); i++; ) while (i< 10);
5. Uendelige sløjferNår du opretter en løkke, kan du oprette en uendelig løkke, der aldrig vil ende. En sådan sløjfe kan potentielt fortsætte med at køre, så længe brugerens computer kører. Flertal moderne browsere kan registrere dette og bede brugeren om at stoppe med at køre scriptet. For at undgå at skabe en uendelig løkke, skal du være sikker på, at den givne betingelse vil returnere falsk på et tidspunkt. For eksempel angiver følgende loop en betingelse, der aldrig returnerer falsk, fordi i aldrig vil være mindre end 10:
For (var i = 25; i > 10; i++) ( document.write("Denne sætning vil køre for evigt...
");
}
En løkke inde i en anden løkke kaldes en indlejret løkke. Med hver iteration af løkken udføres den indlejrede løkke fuldstændigt. Indlejrede løkker kan oprettes ved hjælp af en for-løkke og en while-løkke.
For (var count = 1; count< 3; count++) {
document.write(count + ". Строка цикла
"); for (var nestcount = 1; nestcount< 3; nestcount++) {
document.write("Строка вложенного цикла
");
}
}
Ris. 7. Resultat af udførelse af en indlejret for-løkke
Sløjfen kan styres ved hjælp af break-sætninger; og fortsæt; .
7.1. Operatør pause;Operatør pause; afslutter eksekveringen af den aktuelle sløjfe. Det bruges i undtagelsestilfælde, når løkken af en eller anden grund ikke kan udføres, såsom hvis applikationen støder på en fejl. Oftest pauseoperatøren; er en del af if-konstruktionen.
Når udsagnet går i stykker; bruges uden en etiket, giver den dig mulighed for at forlade en loop eller switch-sætning. Følgende eksempel opretter en tæller, hvis værdier skal variere fra 1 til 99, men break-sætningen bryder løkken efter 14 iterationer.
For (var i = 1; i< 100; i++) {
if (i == 15) {
break;
}
document.write(i);
document.write("
");
}
Ris. 8. Resultatet af pauseoperatoren i for-løkken
For indlejrede sløjfer, break-sætningen; bruges med en etiket, der afslutter den navngivne instruktion. En etiket giver dig mulighed for at forlade enhver kodeblok. Et navngivet udsagn kan være ethvert udsagn, der er eksternt i forhold til et break-udsagn; . Etiketten kan være navnet på et if-udsagn eller navnet på en blok af udsagn omsluttet af krøllede klammeparenteser bare for at tildele en etiket til den pågældende blok. Mellem søgeord pause; og etiketnavnet tillader ikke en ny linje.
Outerloop: for(var i = 0; i< 10; i++) {
innerloop:
for(var j = 0; j < 10; j++) {
if (j >3) bryde; // Forlad den inderste løkke, hvis (i == 2) bryde indre løkke; // Samme thing if (i == 4) break outerloop; // Afslut ydre sløjfe document.write("i = " + i + " j = " + j + "
"); ) ) document.write("FINAL i = " + i + " j = " + j + "
");
Operatør fortsætte; stopper den aktuelle loop-iteration og starter en ny iteration. I dette tilfælde vender while-løkken direkte tilbage til sin tilstand, og for-løkken evaluerer først stigningsudtrykket og vender derefter tilbage til betingelsen.
Dette eksempel viser alle lige tal:
Var i; for(i = 1; i