diff --git a/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md index 43ee4aad3..91354ed54 100644 --- a/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md +++ b/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md @@ -1,4 +1,4 @@ -The answer: `1`. +Atsakymas: `1`. ```js run let i = 3; @@ -8,18 +8,18 @@ while (i) { } ``` -Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`. +Kiekviena ciklo iteracija sumažina `i` per `1`. Patikrinimas `while(i)` sustabdo ciklą kai `i = 0`. -Hence, the steps of the loop form the following sequence ("loop unrolled"): +Dėl to žingsniai iš paskutinio ciklo suformuoja tokią seką ("atskleistas ciklas"): ```js let i = 3; -alert(i--); // shows 3, decreases i to 2 +alert(i--); // parodo 3, sumažina i iki 2 -alert(i--) // shows 2, decreases i to 1 +alert(i--) // parodo 2, sumažina i iki 1 -alert(i--) // shows 1, decreases i to 0 +alert(i--) // parodo 1, sumažina i iki 0 -// done, while(i) check stops the loop +// viskas, while(i) patikrinimas sustabdo ciklą ``` diff --git a/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md index 3b847dfa2..4dea36314 100644 --- a/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md +++ b/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md @@ -2,9 +2,9 @@ importance: 3 --- -# Last loop value +# Paskutinė ciklo vertė -What is the last value alerted by this code? Why? +Kokia yra paskutinė šio kodo vertė parodyta per alert? Kodėl? ```js let i = 3; diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md index 495359876..861ff860d 100644 --- a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md +++ b/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md @@ -1,30 +1,30 @@ -The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons. +Užduotis parodo kaip priešdėlinė/podėlinė formos gali atvesti prie skirtingų rezultatų kai naudojamos palyginimui. -1. **From 1 to 4** +1. **Nuo 1 iki 4** ```js run let i = 0; while (++i < 5) alert( i ); ``` - The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`. + Pirmoji vertė yra `i = 1`, nes `++i` pirma padidina `i` ir tada sugrąžina naują vertę. Tad pirmasis palyginimas yra `1 < 5` ir `alert` parodo `1`. - Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable. + Tada seka `2, 3, 4…` -- vertės pasirodo viena po kitos. Palyginimui visada naudojama jau padidinta vertė, nes `++` yra prieš kintamąjį. - Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown. -2. **From 1 to 5** + Galų gale, `i = 4` yra padidinamas iki `5`, tad palyginimas `while(5 < 5)` yra netiesa ir ciklas sustoja. Tad `5` nėra parodomas. +2. **Nuo 1 iki 5** ```js run let i = 0; while (i++ < 5) alert( i ); ``` - The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`). + Pirmoji vertė vėlgi yra `i = 1`. Podėlinė `i++` forma padidina `i` ir tada sugrąžina *senąją* vertę, tad palyginimas `i++ < 5` naudos `i = 0` (priešingai nei `++i < 5`). - But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`. + Bet šaukimas `alert` yra atskiras, Tai yra kitas teiginys, kuris yra įvykdomas po padidinimo ir palyginimo. Tad jis gauna esamą `i = 1`. - Then follow `2, 3, 4…` + Toliau seka `2, 3, 4…` - Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`. + Sustokime prie `i = 4`. Priešdėlinė forma `++i` padidintų jį ir naudotų `5` palyginime. Bet čia mes turime podėlinę formą `i++`. Tad ji padidina `i` iki `5`, bet grąžina senąją vertę. Dėl to palyginimas yra iš tikrųjų `while(4 < 5)` -- tiesa, ir controlė pereina prie `alert`. - The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false. + Vertė `i = 5` yra paskutinė, nes sekančiame žingsnyje `while(5 < 5)` būtų netiesa. diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md index 298213237..000bd521a 100644 --- a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md +++ b/1-js/02-first-steps/12-while-for/2-which-value-while/task.md @@ -2,19 +2,19 @@ importance: 4 --- -# Which values does the while loop show? +# Kurias vertes parodo while ciklas? -For every loop iteration, write down which value it outputs and then compare it with the solution. +Kiekvienai ciklo iteracijai užrašykite kurią vertę ji atiduoda ir tada palygininkite tą vertę su sprendimu. -Both loops `alert` the same values, or not? +Abu ciklai `alert` tas pačias vertes ar ne? -1. The prefix form `++i`: +1. Priešdėlinė forma `++i`: ```js let i = 0; while (++i < 5) alert( i ); ``` -2. The postfix form `i++` +2. Podėlinė forma `i++` ```js let i = 0; diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md index e2e28e75b..dc62125a8 100644 --- a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md +++ b/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md @@ -1,4 +1,4 @@ -**The answer: from `0` to `4` in both cases.** +**Atsakymas: nuo `0` iki `4` abiem atvejais.** ```js run for (let i = 0; i < 5; ++i) alert( i ); @@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i ); for (let i = 0; i < 5; i++) alert( i ); ``` -That can be easily deducted from the algorithm of `for`: +Tai galima labai lengvai nustatyti iš `for` algoritmo: -1. Execute once `i = 0` before everything (begin). -2. Check the condition `i < 5` -3. If `true` -- execute the loop body `alert(i)`, and then `i++` +1. Įvykdyti vieną kartą `i = 0` prieš visa kita (pradžia). +2. Patikrinti sąlygą `i < 5` +3. Jeigu `true` -- įvykdyti ciklo korpusą `alert(i)`, o tada `i++` -The increment `i++` is separated from the condition check (2). That's just another statement. +Padidėjimas `i++` yra atskirtas nuo sąlygos patikrinimo (2). Tai tik dar vienas teiginys. -The value returned by the increment is not used here, so there's no difference between `i++` and `++i`. +Vertė grąžinta padidėjimo nėra čia naudojama, tad nėra jokio skirtumo tarp `i++` ir `++i`. diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/task.md b/1-js/02-first-steps/12-while-for/3-which-value-for/task.md index bfefa63f5..3ebdc5e79 100644 --- a/1-js/02-first-steps/12-while-for/3-which-value-for/task.md +++ b/1-js/02-first-steps/12-while-for/3-which-value-for/task.md @@ -2,18 +2,18 @@ importance: 4 --- -# Which values get shown by the "for" loop? +# Korias vertes parodo "for" ciklas? -For each loop write down which values it is going to show. Then compare with the answer. +Kiekvienam ciklui parašykite vertes, kurias jis parodys. Tada palyginkite atsakymus. -Both loops `alert` same values or not? +Abu `alert` ciklai, bet ar tos pačios vertės? -1. The postfix form: +1. Podėlio forma: ```js for (let i = 0; i < 5; i++) alert( i ); ``` -2. The prefix form: +2. Priešdėlio forma: ```js for (let i = 0; i < 5; ++i) alert( i ); diff --git a/1-js/02-first-steps/12-while-for/4-for-even/solution.md b/1-js/02-first-steps/12-while-for/4-for-even/solution.md index e8e66bb47..43171c1e7 100644 --- a/1-js/02-first-steps/12-while-for/4-for-even/solution.md +++ b/1-js/02-first-steps/12-while-for/4-for-even/solution.md @@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) { } ``` -We use the "modulo" operator `%` to get the remainder and check for the evenness here. +Mes naudojame "liekanos" operatorių `%`, kad gautume liekaną ir patikrintume lygybę. diff --git a/1-js/02-first-steps/12-while-for/4-for-even/task.md b/1-js/02-first-steps/12-while-for/4-for-even/task.md index ff34e7e40..96a7ecac2 100644 --- a/1-js/02-first-steps/12-while-for/4-for-even/task.md +++ b/1-js/02-first-steps/12-while-for/4-for-even/task.md @@ -2,8 +2,8 @@ importance: 5 --- -# Output even numbers in the loop +# Grąžinkite lyginius skaičius su ciklu -Use the `for` loop to output even numbers from `2` to `10`. +Panaudokite `for` ciklą, kad gautumėte lyginius skaičius nuo `2` iki `10`. [demo] diff --git a/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md b/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md index 612cf559c..53b721d21 100644 --- a/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md +++ b/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md @@ -3,7 +3,7 @@ ```js run let i = 0; while (i < 3) { - alert( `number ${i}!` ); + alert( `skaičius ${i}!` ); i++; } ``` diff --git a/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md index 0c69d9c2d..d0bf15523 100644 --- a/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md +++ b/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md @@ -2,13 +2,13 @@ importance: 5 --- -# Replace "for" with "while" +# Pakeiskite "for" į "while" -Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same). +Perrašykite kodą pakeisdami ciklą `for` į `while`, nepakeisdami elgesio (turėtumėte gauti tą patį atsakymą). ```js run for (let i = 0; i < 3; i++) { - alert( `number ${i}!` ); + alert( `skaičius ${i}!` ); } ``` diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md index 2e04a78c4..af771bd34 100644 --- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md +++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md @@ -3,13 +3,13 @@ let num; do { - num = prompt("Enter a number greater than 100?", 0); + num = prompt("Įveskite skaičių didesnį nei 100?", 0); } while (num <= 100 && num); ``` -The loop `do..while` repeats while both checks are truthy: +Ciklas`do..while` pakartoja kol abu patikrinimai yra truthy: -1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`. -2. The check `&& num` is false when `num` is `null` or a empty string. Then the `while` loop stops too. +1. Patikrinimas dėl `num <= 100` -- tai yra, įvesta vertė vis dar nėra didesnė už `100`. +2. Patikrinimas `&& num` yra neteisingas, jeigu `num` yra `null` arba tuščia eilutė. Tada `while` ciklas taip pat sustoja. -P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required. +P.S. Jeigu `num` yra `null` tada `num <= 100` yra `true`, tad be antro patikrinimo ciklas nesustotų, jeigu lankytojas paspaustų CANCEL. Abu patikrinimai yra reikalingi. diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md index 0788ee76e..82f275cba 100644 --- a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md +++ b/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md @@ -2,12 +2,12 @@ importance: 5 --- -# Repeat until the input is correct +# Kartoti kol įvestis bus teisinga -Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again. +Parašykite ciklą, kurios prašytų skaičių didesnio už `100`. Jeigu lankytojas įveda kitokį skaičių -- paprašykite dar kartą įvesti. -The loop must ask for a number until either the visitor enters a number greater than `100` or cancels the input/enters an empty line. +Ciklas turi prašyti skaičio tol kol lankytojas įves skaičių didesnį nei `100` arba atšauks (ang. cancels) įvestį arba paliks tuščią eilutę paspausdamas enter. -Here we can assume that the visitor only inputs numbers. There's no need to implement a special handling for a non-numeric input in this task. +Čia galime numanyti, kad lankytojas ves tik skaičius. Nėra reikalo atskirai pasirūpinti neskaitine užduoties įvestimi. [demo] diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md index b4b64b6fa..9fd05d7a0 100644 --- a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md +++ b/1-js/02-first-steps/12-while-for/7-list-primes/solution.md @@ -1,29 +1,29 @@ -There are many algorithms for this task. +Yra daug algoritmų šiai užduočiai. -Let's use a nested loop: +Panaudokime matrioškinį ciklą: ```js -For each i in the interval { - check if i has a divisor from 1..i - if yes => the value is not a prime - if no => the value is a prime, show it +Kiekvienam i intervale { + patikrinkite ar i turi daliklį iš 1..i + jeigu taip => vertė nėra pirminis skaičius + jeigu ne => vertė yra pirminis skaičius, parodykite ją } ``` -The code using a label: +Kodas naudojant etiketę: ```js run let n = 10; nextPrime: -for (let i = 2; i <= n; i++) { // for each i... +for (let i = 2; i <= n; i++) { // kiekvienam i... - for (let j = 2; j < i; j++) { // look for a divisor.. - if (i % j == 0) continue nextPrime; // not a prime, go next i + for (let j = 2; j < i; j++) { // ieškoti daliklio.. + if (i % j == 0) tęsti nextPrime; // ne pirminis skaičius, eiti prie sekančio i } - alert( i ); // a prime + alert( i ); // pirminis } ``` -There's a lot of space to optimize it. For instance, we could look for the divisors from `2` to square root of `i`. But anyway, if we want to be really efficient for large intervals, we need to change the approach and rely on advanced maths and complex algorithms like [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc. +Yra daug vietos, kur galima jį optimizuoti. Pavyzdžiui, galėtume ieškoti daliklių nuo `2` iki `i` šaknies. Bet kokiu atveju, jeigu norime būti efektyvūs dideliems intervalams, reikia pakeisti priėjimo būdus ir pasitikėti pažengusia matematika ir sudėtingais algoritmais kaip [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc. diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/task.md b/1-js/02-first-steps/12-while-for/7-list-primes/task.md index 6344b9f6f..ddb19c696 100644 --- a/1-js/02-first-steps/12-while-for/7-list-primes/task.md +++ b/1-js/02-first-steps/12-while-for/7-list-primes/task.md @@ -2,16 +2,16 @@ importance: 3 --- -# Output prime numbers +# Atiduoti pirminius numerius -An integer number greater than `1` is called a [prime](https://en.wikipedia.org/wiki/Prime_number) if it cannot be divided without a remainder by anything except `1` and itself. +Sveikieji skaičiai didesni už `1` yra vadinami [prime](https://en.wikipedia.org/wiki/Prime_number), jeigu jie gali būti padalinti be liekanos tik iš pačio savęs arba `1`. -In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`. +Kitaip sakant, `n > 1` yra pirminis, jeigu jis negali būti lygiai padalintas iš nieko kitaip kaip tik `1` ir `n`. -For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`. +Pavyzdžiui, `5` yra pirminis, nes negali būti padalintas be liekanos iš `2`, `3` ir `4`. -**Write the code which outputs prime numbers in the interval from `2` to `n`.** +**Parašykite kodą, kuris atiduotų pirminius numerius intervalu tarp `2` iki `n`.** -For `n = 10` the result will be `2,3,5,7`. +Šiuo atveju `n = 10` rezultatas būtų `2,3,5,7`. -P.S. The code should work for any `n`, not be hard-tuned for any fixed value. +P.S. Kodas turi veikti bet kuriam `n`, o ne paruoštas atitinkamoms vertėms. diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md index 382adadac..894181366 100644 --- a/1-js/02-first-steps/12-while-for/article.md +++ b/1-js/02-first-steps/12-while-for/article.md @@ -1,54 +1,54 @@ -# Loops: while and for +# Ciklai: while ir for -We often need to repeat actions. +Mes dažnai turime pakartoti veiksmus. -For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10. +Pavyzdžiui, įvairių prekių išbraukimas viena paskui kitą iš sąrašo, arba paprasčiausiai to paties kodo paleidimas kiekvienam numeriui nuo 1 iki 10. -*Loops* are a way to repeat the same code multiple times. +*Ciklai* (ang. *Loops*) yra būdas pakartoti daug kartų tą patį kodą. -## The "while" loop +## Ciklas "while" -The `while` loop has the following syntax: +Ciklas `while` turi sekančią sintaksę: ```js -while (condition) { - // code - // so-called "loop body" +while (sąlyga) { + // kodas + // taip vadinamas "ciklo korpusas" (ang. "loop body") } ``` -While the `condition` is truthy, the `code` from the loop body is executed. +Kol `sąlyga` yra truthy, `kodas` iš ciklo rinkinio yra įvykdomas. -For instance, the loop below outputs `i` while `i < 3`: +Pavyzdžiui, ciklas žemiau atiduoda `i` kol `i < 3`: ```js run let i = 0; -while (i < 3) { // shows 0, then 1, then 2 +while (i < 3) { // parodo 0, tada 1, tada 2 alert( i ); i++; } ``` -A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations. +Vienas ciklo rinkinio įvykdymas vadinamas *iteracija* (ang. *an iteration*). Ciklas pavyzdyje aukščiau padaro tris iteracijas. -If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process. +Jeigu kodo pavyzdyje viršuje nebūtų `i++`, ciklas (teoriškai) kartotųsi amžinai. Praktikoje naršyklė suteikia būdų sustabdyti tokį ciklą ir procesas gali būti užbaigtas JavaScript serverio pusėje. -Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`. +Bet kokia išraiška arba kintamasis gali būti ciklo sąlyga, ne tik palyginimas: sąlyga yra įvertinama ir `while` ciklo paverčiama į loginį sprendimą. -For instance, a shorter way to write `while (i != 0)` is `while (i)`: +Pavyzdžiui, trumpesnis būdas parašyti `while (i != 0)` yra `while (i)`: ```js run let i = 3; *!* -while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops +while (i) { // kai i pavirsta 0, sąlyga tampa falsy ir ciklas sustoja */!* alert( i ); i--; } ``` -````smart header="Curly braces are not required for a single-line body" -If the loop body has a single statement, we can omit the curly braces `{…}`: +````smart header="Riestiniai skliaustai nėra reikalingi vienos eilės korpusui" +Jeigu ciklo kopusas turi tik vieną teiginį, galime nenaudoti riestinių skliaustų `{…}`: ```js run let i = 3; @@ -58,19 +58,19 @@ while (i) alert(i--); ``` ```` -## The "do..while" loop +## Ciklas "do..while" -The condition check can be moved *below* the loop body using the `do..while` syntax: +Sąlygos patikrinimas gali būtų perkeltas *žemiau* ciklo korpuso naudojant sintaksę `do..while`: ```js do { - // loop body -} while (condition); + // ciklo korpusas +} while (sąlyga); ``` -The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again. +Ciklas visų pirma įvykdys korpusą, tada patikrins sąlygą ir kol ji yra truthy, įvykdys vėl ir vėl. -For example: +Pavyzdžiui: ```js run let i = 0; @@ -80,109 +80,109 @@ do { } while (i < 3); ``` -This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`. +Tokia sintaksė turėtų būti naudojama kai norite, kad ciklo korpusas būtų įvykdytas **bent vieną kartą** nepaisant to ar jo sąlyga yra truthy. Dažniausiai vis dėlto naudojama kita forma: `while(…) {…}`. -## The "for" loop +## Ciklas "for" -The `for` loop is more complex, but it's also the most commonly used loop. +Ciklas `for` yra kiek sudėtingesnis, bet jis tuo pačiu yra dažniausiai naudojamas ciklas. -It looks like this: +Jis atrodo taip: ```js -for (begin; condition; step) { - // ... loop body ... +for (begin; condition; step) { // pradžia; sąlyga; žingsnis + // ... ciklo korpusas ... } ``` -Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`: +Išmokime šių dalių reikšmę su pavyzdžiais. Ciklas žemiau paleidžia `alert(i)` kol `i` yra nuo `0` iki (bet neįskaitant) `3`: ```js run -for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2 +for (let i = 0; i < 3; i++) { // parodo 0, tada 1, tada 2 alert(i); } ``` -Let's examine the `for` statement part-by-part: +Ištirkime teiginį `for` dalis po dalies: -| part | | | +| dalis | | | |-------|----------|----------------------------------------------------------------------------| -| begin | `i = 0` | Executes once upon entering the loop. | -| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops. | -| body | `alert(i)`| Runs again and again while the condition is truthy. | -| step| `i++` | Executes after the body on each iteration. | +| pradžia | `i = 0` | Įvykdomas vieną kartą pradedant ciklą. | +| salyga | `i < 3`| Patikrinama prieš kiekvieną ciklo iteraciją. Jeigu netiesa, ciklas sustoja. | +| korpusas | `alert(i)`| Įvykdomas vėl ir vėl kol sąlyga yra truthy. | +| žingsnis | `i++` | Įvykdomas po korpuso per kiekvieną iteraciją. | -The general loop algorithm works like this: +Įprastinio ciklo algoritmas veikia taip: ``` -Run begin -→ (if condition → run body and run step) -→ (if condition → run body and run step) -→ (if condition → run body and run step) +Pradedamas vykdymas +→ (jeigu sąlyga → paleisti korpusą ir paleisti žingsnį) +→ (jeigu sąlyga → paleisti korpusą ir paleisti žingsnį) +→ (jeigu sąlyga → paleisti korpusą ir paleisti žingsnį) → ... ``` -That is, `begin` executes once, and then it iterates: after each `condition` test, `body` and `step` are executed. +Tai yra, `begin` įvykdomas vieną kartą ir tada jis kartojasi (ang. iterates): po kiekvieno `sąlygos` testo įvykdomi `korpusas` ir `žingsnis`. -If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper. +Jeigu ciklai jums naujiena, juos geriau suprasti padėtų , jeigu sugrįžtumėte prie pavyzdžio ir žingsnis po žingsnio atkurtumėte kaip jis veikia ant popieriaus lapo. -Here's exactly what happens in our case: +Štai kas konkrečiai vyksta mūsų atveju: ```js // for (let i = 0; i < 3; i++) alert(i) -// run begin +// pradedamas vykdymas let i = 0 -// if condition → run body and run step +// jeigu sąlyga → paleisti korpusą ir paleisti žingsnį if (i < 3) { alert(i); i++ } -// if condition → run body and run step +// jeigu sąlyga → paleisti korpusą ir paleisti žingsnį if (i < 3) { alert(i); i++ } -// if condition → run body and run step +// jeigu sąlyga → paleisti korpusą ir paleisti žingsnį if (i < 3) { alert(i); i++ } -// ...finish, because now i == 3 +// ...pabaiga, nes dabar i == 3 ``` -````smart header="Inline variable declaration" -Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop. +````smart header="Vidinio kintamojo deklaracija" +Čia "skaičiuojantis" (ang. "counter") kintamasis `i` yra deklaruotas tiesiai cikle. Tai vadinama "vidinio" (ang. "inline") kintamojo deklaracija. Toks kintamasis yra matomas tik ciklo viduje. ```js run for (*!*let*/!* i = 0; i < 3; i++) { alert(i); // 0, 1, 2 } -alert(i); // error, no such variable +alert(i); // klaida, tokio kintamojo nėra ``` -Instead of defining a variable, we could use an existing one: +Vietoje to, kad apibrėžtume kintamąjį, galime naudoti jau egzituojantį: ```js run let i = 0; -for (i = 0; i < 3; i++) { // use an existing variable +for (i = 0; i < 3; i++) { // naudojamas jau egzituojantis kintamasis alert(i); // 0, 1, 2 } -alert(i); // 3, visible, because declared outside of the loop +alert(i); // 3, matomas, nes buvo deklaruotas už ciklo ribų ``` ```` -### Skipping parts +### Dalių praleidimas -Any part of `for` can be skipped. +Bet kuri `for` dalis gali būti praleista. -For example, we can omit `begin` if we don't need to do anything at the loop start. +Pavyzdžiui, mes galime neįtraukti `begin`, jeigu mums nieko nereikia daryti ciklo pradžioje. -Like here: +Kaip šiame pavyzdyje: ```js run -let i = 0; // we have i already declared and assigned +let i = 0; // jau turime deklaravę ir priskyrę i -for (; i < 3; i++) { // no need for "begin" +for (; i < 3; i++) { // nereikia "pradžios" alert( i ); // 0, 1, 2 } ``` -We can also remove the `step` part: +Taip pat galime nenaudoti `žingsnio` dalies: ```js run let i = 0; @@ -192,32 +192,32 @@ for (; i < 3;) { } ``` -This makes the loop identical to `while (i < 3)`. +Tai padaro ciklą identišku `while (i < 3)`. -We can actually remove everything, creating an infinite loop: +Mes netgi galime viską panaikinti, sukurdami begalinį ciklą: ```js for (;;) { - // repeats without limits + // kartojasi be ribų } ``` -Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error. +Atkreipkite dėmesį, kad du `for` kabliataškiai `;` yra privalomi. Kitu atveju bus sintaksės klaida. -## Breaking the loop +## Ciklo nutraukimas -Normally, a loop exits when its condition becomes falsy. +Dažniausiai, ciklas egzituoja kol jo sąlyga tampa falsy. -But we can force the exit at any time using the special `break` directive. +Bet mes galime priverstinai išeiti naudodami ypatingają `break` direktyvą. -For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered: +Pavyzdžiui, ciklas žemiau klausia naudotojo numerių serijos, "nutraukdamas" kai nėra įvedamas skaičius: ```js run let sum = 0; while (true) { - let value = +prompt("Enter a number", ''); + let value = +prompt("Įveskite skaičių", ''); *!* if (!value) break; // (*) @@ -226,35 +226,35 @@ while (true) { sum += value; } -alert( 'Sum: ' + sum ); +alert( 'Suma: ' + sum ); ``` -The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`. +Direktyva `break` yra aktyvuojama eilutėje `(*)`, jeigu lankytojas pateikia tuščią rezultatą arba atšaukia įvedimą. Tai iš karto sustabdo ciklą, perduodant kontrolę pirmai eilei po ciklo. Šiuo atveju `alert`. -The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body. +Kombinacija "bagalinis ciklas + `break` kai reikia" yra gerai tokiose situacijose kai ciklo sąlyga turi būti patikrinama ne pačioje pradžio ar pabaigoje ciklo, bet viduryje arba netgi keliose jo korpuso vietose. -## Continue to the next iteration [#continue] +## Tęsinys kitoje iteracijoje [#continue] -The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows). +Direktyva `continue` (tęsti) yra "lengvesnė versija" direktyvos `break`. Ji nesustobado viso ciklo. Vietoje to, ji sustabdo esamą iteraciją ir priverčią ciklą pradėti naują iteraciją (jeigu sąlyga tai leidžia). -We can use it if we're done with the current iteration and would like to move on to the next one. +Galime tai naudoti kai baigiame su esama iteracija ir esame pasiruošę pereiti prie sekančios. -The loop below uses `continue` to output only odd values: +Ciklas žemiau naudoja `continue`, kad atiduotų tik nelygines vertes: ```js run no-beautify for (let i = 0; i < 10; i++) { - // if true, skip the remaining part of the body + // jeigu tiesa, praleisti likusią korpuso dalį *!*if (i % 2 == 0) continue;*/!* - alert(i); // 1, then 3, 5, 7, 9 + alert(i); // 1, tada 3, 5, 7, 9 } ``` -For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values. +Lyginėms `i` vertėms, direktyva `continue` nustoja vykdyti korpusą ir perleidžia kontrolę sekančiai `for` iteracijai (su sekančiu skaičiumi). Tad `alert` yra iškviečiamas tik nelyginėms vertėms. -````smart header="The `continue` directive helps decrease nesting" -A loop that shows odd values could look like this: +````smart header="Direktyva `continue` sumažina matrioškinį kodą (ang. nesting)" +Ciklas, kuris parodo nelygines vertes gali atrodyti ir taip: ```js for (let i = 0; i < 10; i++) { @@ -266,15 +266,15 @@ for (let i = 0; i < 10; i++) { } ``` -From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`. +Iš techninės perspektyvos tai yra visiškai identiškas kodas aukščiau esančiam pavyzdžiui. Žinoma, mes galime tiesiog apgobti `if` rinkinį vietoje to, kad naudotume `continue`. -But as a side-effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of`if` is longer than a few lines, that may decrease the overall readability. +Bet to pašalinis efektas yra papildomas matrioškinis lygis (šaukimas `alert` viduje riestinių skliaustų). O jeigu kodas `if` viduje yra ilgesnis nei kelios eilės, tai apsunkina skaitomumą. ```` -````warn header="No `break/continue` to the right side of '?'" -Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there. +````warn header="Jokių `break/continue` dešinėje '?' pusėje" +Atkreipkite dėmesį, kad sintaksiniai konstruktai, kurie nėra išraiškos, negalimi su ternariniu operatoriumi `?`. Ypatingai tokios direktyvos kaip `break/continue` yra neleidžiamos. -For example, if we take this code: +Pavyzdžiui, jeigu paimtume tokį kodą: ```js if (i > 5) { @@ -284,103 +284,103 @@ if (i > 5) { } ``` -...and rewrite it using a question mark: +...ir perrašytume jį naudodami klaustuką: ```js no-beautify -(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here +(i > 5) ? alert(i) : *!*continue*/!*; // continue nėra leidžiamas ``` -...it stops working: there's a syntax error. +...jis nustoja veikti: tai yra sintaksės klaida. -This is just another reason not to use the question mark operator `?` instead of `if`. +Tai tik dar viena priežastis nenaudoti klaustuko operatoriaus `?` vietoje`if`. ```` -## Labels for break/continue +## Etiketės break/continue -Sometimes we need to break out from multiple nested loops at once. +Kartais mums reikia ištrūkti iš daugybinių matrioškinių ciklų tuo pačiu metu. -For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(2,2)`: +Pavyzdžiui, kode žemiau mes paleidžiame ciklą per `i` ir `j`, klausdami koordinačių `(i, j)` nuo `(0,0)` iki `(2,2)`: ```js run no-beautify for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Value at coords (${i},${j})`, ''); + let input = prompt(`Vertė koordinatėse (${i},${j})`, ''); - // what if we want to exit from here to Done (below)? + // kas nutinka jeigu norime išeiti šiuo momentu iki Baigta (žemiau)? } } -alert('Done!'); +alert('Baigta!'); ``` -We need a way to stop the process if the user cancels the input. +Mums reikia tokio būdo, kuris sustabdytų procesą, jeigu lankytojas atšaukia įvedimą. -The ordinary `break` after `input` would only break the inner loop. That's not sufficient--labels, come to the rescue! +Įprastinis `break` sekantis po `input` sustabdytų tik vidinį ciklą. To neužtenka--į pagalba ateina etiketės! -A *label* is an identifier with a colon before a loop: +*Etikėtė* tai toks identifikatorius su dvitaškiu prieš ciklą: ```js -labelName: for (...) { +etiketėsPavadinimas: for (...) { ... } ``` -The `break ` statement in the loop below breaks out to the label: +Teiginys `break ` cikle žemiau nutraukia procesą iki etiketės: ```js run no-beautify -*!*outer:*/!* for (let i = 0; i < 3; i++) { +*!*išorinis:*/!* for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { - let input = prompt(`Value at coords (${i},${j})`, ''); + let input = prompt(`Vertė koordinatėse (${i},${j})`, ''); - // if an empty string or canceled, then break out of both loops - if (!input) *!*break outer*/!*; // (*) + // jeigu eilutė tuščia arba buvo atšaukta, nutraukti procesą iš abiejų ciklų + if (!input) *!*break išorinis*/!*; // (*) - // do something with the value... + // darykite kažką su verte... } } -alert('Done!'); +alert('Baigta!'); ``` -In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop. +Kodas viršuje `break išorinis` suranda viršuje etiketę su pavadinimu `išorinis` ir nutraukia tą ciklą. -So the control goes straight from `(*)` to `alert('Done!')`. +Tad kontrolė pereina tiesiai nuo `(*)` iki `alert('Baigta!')`. -We can also move the label onto a separate line: +Mes taip pat galime perkelti etiketę į atskirą eilę: ```js no-beautify -outer: +išorinis: for (let i = 0; i < 3; i++) { ... } ``` -The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop. +Direktyva `continue` taip pat gali būti naudojama su etiketėmis. Šiuo atveju kodo įvykdymas peršoka prie sekančios ciklo su etikete iteracijos. -````warn header="Labels do not allow to \"jump\" anywhere" -Labels do not allow us to jump into an arbitrary place in the code. +````warn header="Etiketės neleidžia \"peršokti\" bet kur" +Etiketės negali leisti peršokti į bet kurią arbitrišką kodo vietą. -For example, it is impossible to do this: +Pavyzdžiui tai nėra įmanoma: ```js -break label; // doesn't jumps to the label below +break etiketė; // neperšoka į etiketę žemiau -label: for (...) +etiketė: for (...) ``` -A call to `break/continue` is only possible from inside a loop and the label must be somewhere above the directive. +Šaukimas `break/continue` įmanoma tik iš ciklo vidaus ir etiketė turi būti kažkur virš direktyvos. ```` -## Summary +## Santrauka -We covered 3 types of loops: +Mes aptarėme 3 ciklų tipus: -- `while` -- The condition is checked before each iteration. -- `do..while` -- The condition is checked after each iteration. -- `for (;;)` -- The condition is checked before each iteration, additional settings available. +- `while` -- Sąlyga patikrinima prieš kiekvieną iteraciją. +- `do..while` -- Sąlyga patikrinama po kiekvienos iteracijos. +- `for (;;)` -- Sąlyga patikrinama prieš kiekvieną iteraciją, įmanomi papildomi nustatymai. -To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive. +Kad padarytume "begalinį" ciklą, naudojamas konstruktas `while(true)`. Toks ciklas, kaip ir bet kuris kitas, gali būti sustabdytas naudojant direktyvą `break`. -If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive. +Jeigu nenorime nieko daryti esamoje iteracijoje, bet norime pereiti prie sekančios, galime naudoti `continue` direktyvą. -`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one. +`break/continue` palaiko etiketes prieš ciklą. Etiketė yra vienintelis kelias tam, kad `break/continue` išeitų iš matrioškinio vidinio ciklo į išorinį. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy