diff --git a/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/solution.md b/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/solution.md
index d3e397434..00e18cd3f 100644
--- a/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/solution.md
+++ b/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/solution.md
@@ -1,20 +1,20 @@
-To precisely match the functionality of `switch`, the `if` must use a strict comparison `'==='`.
+Tam, kad būtų palaikomas `switch` funkcionalumas `if` turi naudoti griežtą lygybę `'==='`.
-For given strings though, a simple `'=='` works too.
+Bet duotoms eilutėms, paprasta lygybė `'=='` taip pat veikia.
```js no-beautify
if(browser == 'Edge') {
- alert("You've got the Edge!");
+ alert("Jūs turite Edge!");
} else if (browser == 'Chrome'
|| browser == 'Firefox'
|| browser == 'Safari'
|| browser == 'Opera') {
- alert( 'Okay we support these browsers too' );
+ alert( 'Gerai, palaikome ir tokias naršykles' );
} else {
- alert( 'We hope that this page looks ok!' );
+ alert( 'Mes tikimės, kad šis puslapis veikia gerai!' );
}
```
-Please note: the construct `browser == 'Chrome' || browser == 'Firefox' …` is split into multiple lines for better readability.
+Atkreipkite dėmesį: konstruktas `browser == 'Chrome' || browser == 'Firefox' …` yra atskirtas į naujas eiles dėl geresnio skaitomumo.
-But the `switch` construct is still cleaner and more descriptive.
+Tačiau `switch` vis tiek yra švaresnis ir labiau apibūdinantis konstruktas.
diff --git a/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/task.md b/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/task.md
index f4dc0e5f1..e8ecb1241 100644
--- a/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/task.md
+++ b/1-js/02-first-steps/13-switch/1-rewrite-switch-if-else/task.md
@@ -2,25 +2,25 @@ importance: 5
---
-# Rewrite the "switch" into an "if"
+# Perrašykite "switch" į "if"
-Write the code using `if..else` which would correspond to the following `switch`:
+Perrašykite kodą naudodami `if..else`, kuris atitiktų sekantį `switch`:
```js
switch (browser) {
case 'Edge':
- alert( "You've got the Edge!" );
+ alert( "Jūs turite Edge!" );
break;
case 'Chrome':
case 'Firefox':
case 'Safari':
case 'Opera':
- alert( 'Okay we support these browsers too' );
+ alert( 'Puiku, mes palaikome ir šias naršykles' );
break;
default:
- alert( 'We hope that this page looks ok!' );
+ alert( 'Mes tikimės, kad šis puslapis veikia gerai!' );
}
```
diff --git a/1-js/02-first-steps/13-switch/2-rewrite-if-switch/solution.md b/1-js/02-first-steps/13-switch/2-rewrite-if-switch/solution.md
index ed87dd94b..4a88348ea 100644
--- a/1-js/02-first-steps/13-switch/2-rewrite-if-switch/solution.md
+++ b/1-js/02-first-steps/13-switch/2-rewrite-if-switch/solution.md
@@ -1,4 +1,4 @@
-The first two checks turn into two `case`. The third check is split into two cases:
+Pirmi du patikrinimai pavirsta į dvi atskiras bylas `case`. Trečias patikrinimas išskiriamas į dvi bylas:
```js run
let a = +prompt('a?', '');
@@ -21,6 +21,6 @@ switch (a) {
}
```
-Please note: the `break` at the bottom is not required. But we put it to make the code future-proof.
+Atkreipkite dėmesį: pabaigoje esantis `break` nėra reikalingas. Bet mes jį pridedame tam, kad kodas būtų paruoštas ateities pakeitimams.
-In the future, there is a chance that we'd want to add one more `case`, for example `case 4`. And if we forget to add a break before it, at the end of `case 3`, there will be an error. So that's a kind of self-insurance.
+Yra galimybė, kad ateityje norėsime pridėti dar vieną bylą `case`, pavyzdžiui `case 4`. Jeigu prieš tai būsime pamiršę pridėti `break`, tokiu atveju `case 3` pabaigoje bus klaida. Tad tai yra mūsų pačių apsidraudimas.
diff --git a/1-js/02-first-steps/13-switch/2-rewrite-if-switch/task.md b/1-js/02-first-steps/13-switch/2-rewrite-if-switch/task.md
index ec99d098d..ee91c9035 100644
--- a/1-js/02-first-steps/13-switch/2-rewrite-if-switch/task.md
+++ b/1-js/02-first-steps/13-switch/2-rewrite-if-switch/task.md
@@ -2,9 +2,9 @@ importance: 4
---
-# Rewrite "if" into "switch"
+# Perrašykite "if" į "switch"
-Rewrite the code below using a single `switch` statement:
+Perrašykite kodą esantį žemiau naudodami vieną `switch` teiginį:
```js run
let a = +prompt('a?', '');
diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md
index dec40a537..6391c365e 100644
--- a/1-js/02-first-steps/13-switch/article.md
+++ b/1-js/02-first-steps/13-switch/article.md
@@ -1,22 +1,22 @@
-# The "switch" statement
+# Teiginys "switch"
-A `switch` statement can replace multiple `if` checks.
+Teiginys `switch` gali pakeisti daugybinius `if` patikrinimus.
-It gives a more descriptive way to compare a value with multiple variants.
+Jis suteikia lengviau apibūdinamą kelią palyginti vertes su įvairiais variantais.
-## The syntax
+## Sintaksė
-The `switch` has one or more `case` blocks and an optional default.
+Teiginys `switch` turi vieną ir daugiau `case` (bylos) blokų ir numatytąjį pasirinkimą.
-It looks like this:
+Tai atrodo taip:
```js no-beautify
switch(x) {
- case 'value1': // if (x === 'value1')
+ case 'vertė1': // if (x === 'vertė1')
...
[break]
- case 'value2': // if (x === 'value2')
+ case 'vertė2': // if (x === 'vertė2')
...
[break]
@@ -26,71 +26,71 @@ switch(x) {
}
```
-- The value of `x` is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on.
-- If the equality is found, `switch` starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of `switch`).
-- If no case is matched then the `default` code is executed (if it exists).
+- Vertė `x` yra patikrinama griežta lygybe su verte iš pirmos bylos `case` (tai yra `vertė1`) tada su antra (`vertė2`) ir taip toliau.
+- Jeigu lygybė randama, `switch` pradeda vykdyti kodą nuo atitinkančios bylos `case`, iki artimiausio `break` (arba kol pasibaigs `switch`).
+- Jeigu nei viena byla nesurado atitikimo, tokiu atveju yra įvykdomas `default` kodas (jeigu toks egzistuoja).
-## An example
+## Pavyzdys
-An example of `switch` (the executed code is highlighted):
+Pavyzdys `switch` (įvykdytas kodas yra paryškintas):
```js run
let a = 2 + 2;
switch (a) {
case 3:
- alert( 'Too small' );
+ alert( 'Per mažas' );
break;
*!*
case 4:
- alert( 'Exactly!' );
+ alert( 'Kaip tik!' );
break;
*/!*
case 5:
- alert( 'Too large' );
+ alert( 'Per didelis' );
break;
default:
- alert( "I don't know such values" );
+ alert( "Tokios vertės nežinau" );
}
```
-Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails.
+Šiuo atveju `switch` pradeda lyginti `a` iš pirmos bylos `case` variantą, kuris yra `3`. Atitikmuo nėra randamas.
-Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`.
+Tada `4`. Atitikmuo randamas, tad pradedamas vykdymas nuo `case 4` iki artimiausio `break`.
-**If there is no `break` then the execution continues with the next `case` without any checks.**
+**Jeigu nėra `break` tokiu atveju vykdymas tęsiasi su sekančia `case` be jokių patikrinimų.**
-An example without `break`:
+Pavyzdys be `break`:
```js run
let a = 2 + 2;
switch (a) {
case 3:
- alert( 'Too small' );
+ alert( 'Per mažas' );
*!*
case 4:
- alert( 'Exactly!' );
+ alert( 'Kaip tik!' );
case 5:
- alert( 'Too big' );
+ alert( 'Per didelis' );
default:
- alert( "I don't know such values" );
+ alert( "Tokios vertės nežinau" );
*/!*
}
```
-In the example above we'll see sequential execution of three `alert`s:
+Pavyzdyje aukščiau iš eilės matome kaip įvykdomi trys `alert`:
```js
-alert( 'Exactly!' );
-alert( 'Too big' );
-alert( "I don't know such values" );
+alert( 'Kaip tik!' );
+alert( 'Per didelis' );
+alert( "Tokios vertės nežinau" );
```
-````smart header="Any expression can be a `switch/case` argument"
-Both `switch` and `case` allow arbitrary expressions.
+````smart header="Bet kokia išraiška gali būti `switch/case` argumentu"
+Abu `switch` ir `case` leidžia sutartines išraiškas.
-For example:
+Pavyzdžiui:
```js run
let a = "1";
@@ -99,74 +99,74 @@ let b = 0;
switch (+a) {
*!*
case b + 1:
- alert("this runs, because +a is 1, exactly equals b+1");
+ alert("šitas preina, nes +a yra 1, tiksliai lygu b+1");
break;
*/!*
default:
- alert("this doesn't run");
+ alert("tai nepasileidžia");
}
```
-Here `+a` gives `1`, that's compared with `b + 1` in `case`, and the corresponding code is executed.
+Čia `+a` atiduoda `1`, tai yra palyginama su `b + 1` byloje `case`, įvykdomas atitinkamas kodas.
````
-## Grouping of "case"
+## Grupavimas su "case"
-Several variants of `case` which share the same code can be grouped.
+Keli `case` variantai, kurie dalinasi tuo pačiu kodu gali būti sugrupuoti.
-For example, if we want the same code to run for `case 3` and `case 5`:
+Pavyzdžiui, jeigu mes norime, kad tas pats kodas pasileistų byloms `case 3` ir `case 5`:
```js run no-beautify
let a = 2 + 2;
switch (a) {
case 4:
- alert('Right!');
+ alert('Teisingai!');
break;
*!*
- case 3: // (*) grouped two cases
+ case 3: // (*) dvi bylos sugrupuotos
case 5:
- alert('Wrong!');
- alert("Why don't you take a math class?");
+ alert('Neteisingai!');
+ alert('Būtų neblogai apsilankyti matematikos pamokoje.');
break;
*/!*
default:
- alert('The result is strange. Really.');
+ alert('Rezultatas yra iš tikrųjų keistas.');
}
```
-Now both `3` and `5` show the same message.
+Dabar abu `3` ir `5` parodo tą pačią žinutę.
-The ability to "group" cases is a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
+Gebėjimas "sugrupuoti" bylas yra šalutinis efektas to kaip `switch/case` veikia be `break`. Čia `case 3` vykdymas prasideda nuo eilės su `(*)` ir eina per bylą `case 5`, nes nėra `break`.
-## Type matters
+## Tipas yra svarbu
-Let's emphasize that the equality check is always strict. The values must be of the same type to match.
+Pabrėžkime tai, kad lygybės patikrinimas yra visada griežtas. Vertės turi būti vienodo tipo, kad atitiktų viena kitą.
-For example, let's consider the code:
+Pavyzdžiui, apsvarstykime tokį kodą:
```js run
-let arg = prompt("Enter a value?");
+let arg = prompt("Įveskite vertę?");
switch (arg) {
case '0':
case '1':
- alert( 'One or zero' );
+ alert( 'Vienas arba nulis' );
break;
case '2':
- alert( 'Two' );
+ alert( 'Du' );
break;
case 3:
- alert( 'Never executes!' );
+ alert( 'Niekada nėra įvykdomas!' );
break;
default:
- alert( 'An unknown value' );
+ alert( 'Nežinoma vertė' );
}
```
-1. For `0`, `1`, the first `alert` runs.
-2. For `2` the second `alert` runs.
-3. But for `3`, the result of the `prompt` is a string `"3"`, which is not strictly equal `===` to the number `3`. So we've got a dead code in `case 3`! The `default` variant will execute.
+1. Kai įvedamas `0`, `1`, paleidžiamas pirmas `alert`.
+2. Kai įvedamas `2` paleidžiamas antras `alert`.
+3. Bet `3` neįvykdomas, kadangi `prompt` rezultatas yra eilutė `"3"`, o tai nėra griežtai lygu `===` skaičiui `3`. Tad mes turime neveikiantį kodą byloje `case 3`! Įvykdomas `default` variantas.