Updated some articles

Author: Alexandre887

1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

@@ -12,20 +12,10 @@ null === +"\n0\n" → false
 
 Kai kurios priežastys:
 
-<<<<<<< HEAD:1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
-1. Akivaizdžiai tiesa.
-2. Žodynėlio palyginimas, tad netiesa.
-3. Vėlgi, žodynėlio palyginimas, tad pirmasis ženklas eilutėje `"2"` yra didenis nei pirmasis ženklas eilutėje `"1"`.
+1. Akivaizdu, kad tai yra true.
+2. Žodyno palyginimas, todėl false. `"a"` yra mažesnis už `"p"`.
+3. Vėlgi, žodyno palyginimas, pirmasis simbolis `"2"` yra didesnis už pirmąjį simbolį `"1"`.
 4. Vertės `null` ir `undefined` yra lygios viena kitai.
-5. Griežta lygybė yra griežta. Skirtingi tipai abiejose pusėse atveda prie netiesos.
+5. Griežta lygybė yra griežta. Skirtingi abiejų pusių tipai lemia false.
 6. Panašiai į `(4)`, `null` yra lygus tik `undefined`.
 7. Griežta skirtingų tipų lygybė.
-=======
-1. Obviously, true.
-2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
-3. Again, dictionary comparison, first char `"2"` is greater than the first char `"1"`.
-4. Values `null` and `undefined` equal each other only.
-5. Strict equality is strict. Different types from both sides lead to false.
-6. Similar to `(4)`, `null` only equals `undefined`.
-7. Strict equality of different types.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834:1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

1-js/02-first-steps/09-comparison/article.md

@@ -1,37 +1,24 @@
 # Palyginimai
 
-<<<<<<< HEAD:1-js/02-first-steps/08-comparison/article.md
-Iš matematikos mes žinome daug palyginimo operatorių:
+Mes žinome daugybę palyginimo operatorių iš matematikos.
+
+JavaScript kalboje jie užrašomi taip:
 
 - Daugiau/mažiau negu: <code>a &gt; b</code>, <code>a &lt; b</code>.
 - Daugiau/mažiau arba lygu negu: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- Lygu: `a == b` (atkreipkite dėmesį į dvigubos lygybės ženklą `=`. Vienas ženklas `a = b` reikštų priskyrimą).
-- Nelygus. Matematikoje toks ženklas yra <code>&ne;</code>, bet JavaScript jis rašomas kaip asigmentas su šauktuku prieš jį: <code>a != b</code>.
-=======
-We know many comparison operators from maths.
-
-In JavaScript they are written like this:
-
-- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
-- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- Equals: `a == b`, please note the double equality sign `==` means the equality test, while a single one `a = b` means an assignment.
-- Not equals: In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
+- Lygu: `a == b`, atkreipkite dėmesį, kad dvigubas lygybės ženklas `==` reiškia lygybės patikrinimą, o viengubas `a = b` reiškia priskyrimą.
+- Nelygus: Matematikoje toks ženklas yra <code>&ne;</code>, bet JavaScript jis rašomas kaip priskyrimas su šauktuku prieš jį <code>a != b</code>.
 
-In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities.
+Šiame straipsnyje daugiau sužinosime apie įvairių tipų palyginimus, kaip JavaScript juos atlieka, įskaitant svarbius ypatumus.
 
-At the end you'll find a good recipe to avoid "JavaScript quirks"-related issues.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834:1-js/02-first-steps/09-comparison/article.md
+Pabaigoje jūs rasite gerą patarimą, kaip išvengti JavaScript palyginimo “keistenybių”.
 
-## Loginė vertė yra rezultatas
+## Boolean yra rezultatas
 
-<<<<<<< HEAD:1-js/02-first-steps/08-comparison/article.md
-Kaip ir visi kiti operatoriai, palyginimas grąžina vertę. Šiuo atveju ta vertė yra loginė.
-=======
-All comparison operators return a boolean value:
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834:1-js/02-first-steps/09-comparison/article.md
+Visi palyginimo operatoriai grąžina loginę (Boolean) vertę:
 
-- `true` -- reiškia "taip", "teisingai" arba "tiesa".
-- `false` -- reiškia "ne", "neteisingai" arba "netiesa".
+- `true` -- reiškia “taip”, “teisingai” arba “tiesa”.
+- `false` -- reiškia “ne”, “neteisingai” arba “netiesa”.
 
 Pavyzdžiui:
 
@@ -50,7 +37,7 @@ alert( result ); // true
 
 ## Eilutės palyginimas
 
-Kad patikrintų ar viena eilutė yra didesnė už kitą, JavaScript naudoja taip vadinamą "žodyno" arba "leksikografinį" eiliškumą
+Kad patikrintų ar viena eilutė yra didesnė už kitą, JavaScript naudoja taip vadinamą “žodyną” arba “leksikografinį” eiliškumą
 
 Kitais žodžiais, eilutės yra lyginamos paraidžiui.
 
@@ -70,13 +57,9 @@ Algoritmas eilučių palyginimui yra labai paprastas:
 4. Pakartoti iki vienos iš eilučių pabaigos.
 5. Jeigu abi eilutės baigiasi tuo pačiu metu, jos yra vienodos. Kitu atveju ilgesnė eilutė yra didesnė.
 
-<<<<<<< HEAD:1-js/02-first-steps/08-comparison/article.md
-Pavyzdyje aukščiau, palyginimas `'Z' > 'A'` gauna atsakymą pirmame žingsnyje, kai tuo tarpu `"Glow"` ir `"Glee"` yra lyginami ženklas po ženklo:
-=======
-In the first example above, the comparison `'Z' > 'A'` gets to a result at the first step.
+Pirmajame pavyzdyje palyginimas `'Z' > 'A'` duoda rezultatą pirmajame žingsnyje.
 
-The second comparison `'Glow'` and `'Glee'` needs more steps as strings are compared character-by-character:
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834:1-js/02-first-steps/09-comparison/article.md
+Antrojo palyginimo `'Glow'` ir `'Glee'` žingsnių reikia daugiau, nes eilutės lyginamos paraidžiui:
 
 1. `G` tas pats kaip `G`.
 2. `l` tas pats kaip `l`.
@@ -157,7 +140,7 @@ Pabandykime:
 alert( 0 === false ); // false, nes tipai yra skirtingi
 ```
 
-Taip pat yra ir "griežtos nelygybės" operatorius `!==` analogiškas `!=`.
+Taip pat yra ir “griežtos nelygybės” operatorius `!==` analogiškas `!=`.
 
 Griežtos lygybės operatorius yra ilgesnis, bet jis padeda kodui atrodyti aiškesniu ir palieka mažiau vietos klaidoms. 
 
@@ -217,22 +200,12 @@ Gauname tokius rezultatas, nes:
 - Palyginimai `(1)` ir `(2)` grąžina `false`, nes `undefined` paverčiamas į `NaN`, o `NaN` yra ypatinga skaitinė vertė, kuri visoms vertėms grąžina `false`.
 - Lygybės patikrinimas `(3)` grąžina `false`, nes `undefined` yra lygus tik `null`, `undefined` ir jokiai kitai vertei.
 
-<<<<<<< HEAD:1-js/02-first-steps/08-comparison/article.md
 ### Išvenkite problemų
 
-Kodėl mes peržiūrėjome tokius pavyzdžius? Ar turėtume tokias keistenybes visada prisiminti? Nebūtinai. Tiesą sakant tokie triukai taps pažįstamais su laiku, bet yra būdas kaip išvengti su jais susijusių problemų:
-
-Kiekvieną palyginimą susijusį su `undefined/null` vertinkite atsargiai, išskyrus su griežta lygybe `===`.
-
-Nenaudokite palyginimų `>= > < <=` su kintamuoju, kuris gali būti `null/undefined`, nebent tikrai žinote ką darote. Jeigu kintamasis gali turėti tokias vertybes, patikrinkite jas atskirai.
-=======
-### Avoid problems
-
-Why did we go over these examples? Should we remember these peculiarities all the time? Well, not really. Actually, these tricky things will gradually become familiar over time, but there's a solid way to avoid problems with them:
+Kodėl aptarėme šiuos pavyzdžius? Ar turėtume nuolat prisiminti šiuos ypatumus? Na, ne visai. Tiesą sakant, laikui bėgant šie subtilūs dalykai palaipsniui taps įprasti, tačiau yra patikimas būdas išvengti su jais susijusių problemų:
 
-- Treat any comparison with `undefined/null` except the strict equality `===` with exceptional care.
-- Don't use comparisons `>= > < <=` with a variable which may be `null/undefined`, unless you're really sure of what you're doing. If a variable can have these values, check for them separately.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834:1-js/02-first-steps/09-comparison/article.md
+- Bet kokį palyginimą su `undefined/null`, išskyrus griežtos lygybės `===`, atlikite itin atsargiai.
+- Nenaudokite palyginimų `>= > > < <=` su kintamuoju, kuris gali būti `null/undefined`, nebent tikrai žinote, ką darote. Jei kintamasis gali turėti šias vertes, tikrinkite jas atskirai.
 
 ## Santrauka
 

1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html

@@ -5,12 +5,12 @@
   <script>
     'use strict';
 
-    let value = prompt('Koks yra "oficialus JavaScript pavadinimas?', '');
+    let value = prompt('Koks yra "oficialus" JavaScript pavadinimas?', '');
 
     if (value == 'ECMAScript') {
       alert('Teisingai!');
     } else {
-      alert("Nežinote? ECMAScript!");
+      alert("Jūs nežinote? ECMAScript!");
     }
   </script>
 

1-js/02-first-steps/10-ifelse/2-check-standard/task.md

@@ -4,13 +4,9 @@ importance: 2
 
 # JavaScript pavadinimas
 
-Naudodami konstruktą `if..else`, parašykite kodą, kuris klausia: 'Koks yra "oficialus JavaScript pavadinimas?' 
+Naudodami konstruktą `if..else`, parašykite kodą, kuris klausia: 'Koks yra “oficialus” JavaScript pavadinimas?'
 
-<<<<<<< HEAD
-Jeigu lankytojas įveda "ECMAScript", tada gaunamas "Teisingai!", kitu atveju -- gaunamas: "Nežinojote? ECMAScript!"
-=======
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "You don't know? ECMAScript!"
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834
+Jeigu lankytojas įveda “ECMAScript”, tada gaunamas “Teisingai!”, kitu atveju -- gaunamas: “Jūs nežinote? ECMAScript!”
 
 ![](ifelse_task2.svg)
 

1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md

@@ -6,7 +6,7 @@ importance: 5
 
 Perrašykite `if..else` naudodami daugybinius ternarinius operatorius `'?'`.
 
-Dėl skaitomo rekomenduoja išskirti kodą į kelias eiles.
+Kad būtų lengviau skaityti, rekomenduojama kodą padalyti į kelias eilutes.
 
 ```js
 let message;

1-js/02-first-steps/10-ifelse/article.md

@@ -1,14 +1,10 @@
-<<<<<<< HEAD
-# Sąlyginiai operatoriai: if, '?'
-=======
-# Conditional branching: if, '?'
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834
+# Sąlyginis šakojimasis: if, '?'
 
 Kartais mums tenka atlikti skirtingus veiksmus atitinkančius skirtingas sąlygas.
 
-Kad tai padarytume mes naudojame teiginį `if` ir sąlyginį operatorių `?`, arba dar kitaip vadinamą "klaustuko" operatorių.
+Kad tai padarytume mes naudojame teiginį `if` ir sąlyginį operatorių `?`, arba dar kitaip vadinamą “klaustuko” operatorių.
 
-## Teiginys "if"
+## Teiginys “if”
 
 Teiginys `if(...)` įvertina sąlygas esančias tarp skliaustelių ir jeigu rezultatas yra `true` tada įvykdo kodų rinkinį.
 
@@ -41,8 +37,8 @@ Teiginys `if (…)` įvertina išraišką esančią skliaustuose ir paverčia re
 
 Prisiminkime konversijos taisykles iš skyriaus <info:type-conversions>:
 
-- Skaičius `0`, tuščia eilutė `""`, `null`, `undefined` ir `NaN` visi tampa `false`. Nes jos yra vadinamosios "falsy" (neteisingosio) vertės.
-- Kitos vertės tampa `true`, tad jos vadinamos "truthy" (teisingosios).
+- Skaičius `0`, tuščia eilutė `""`, `null`, `undefined` ir `NaN` visi tampa `false`. Nes jos yra vadinamosios “falsy” (neteisingosio) vertės.
+- Kitos vertės tampa `true`, tad jos vadinamos “truthy” (teisingosios).
 
 Taigi kodas tokiu atveju niekada nebūtų įvykdytas:
 
@@ -72,11 +68,7 @@ if (cond) {
 
 ## Išlyga "else"
 
-<<<<<<< HEAD
-Teiginys `if` gali turėti išlygos "else" rinkinį. Jis įvykdomas kai sąlyga yra false.
-=======
-The `if` statement may contain an optional "else" block. It executes when the condition is falsy.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834
+Į `if` teiginį gali būti įterptas neprivalomas “else” blokas. Jis vykdomas, kai sąlyga yra “falsy”.
 
 Pavyzdžiui:
 ```js run
@@ -132,9 +124,9 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-Taip vadinamas "sąlyginis" arba "klaustuko" operatorius mums leidžia tai padaryti daug trumpesniu ir paprastesniu būdu.
+Taip vadinamas “sąlyginis” arba “klaustuko” operatorius mums leidžia tai padaryti daug trumpesniu ir paprastesniu būdu.
 
-Operatorių atstovauja klaustukas `?`. Kartais jis vadinamas "ternariniu", nes operatorius turi tris operandus. Iš tikrųjų jis vienas ir vienintelis, kuris JavaScript turi tiek operandų.
+Operatorių atstovauja klaustukas `?`. Kartais jis vadinamas “ternariniu”, nes operatorius turi tris operandus. Iš tikrųjų jis vienas ir vienintelis, kuris JavaScript turi tiek operandų.
 
 Sintaksė yra tokia:
 ```js

1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Koks bus ARBA rezultatas?
 
-Ką atiduos žemiau esantis kodas?
+Ką išves žemiau esantis kodas?
 
 ```js
 alert( null || 2 || undefined );

1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md

@@ -6,14 +6,8 @@ alert( alert(1) || 2 || alert(3) );
 
 Šaukimas `alert` negrąžina jokios vertės. Arba kitaip sakant, jis grąžina `undefined`.
 
-<<<<<<< HEAD
 1. Pirmasis ARBA `||` įvertina kairėje esantį operandą `alert(1)`. Jis parodo žinutę su `1`.
 2. `alert` grąžina `undefined`, tad ARBA eina prie sekančio operando ieškodamas truthy vertės.
 3. Antrasis operandas `2` yra truthy, tad operacija sustabdoma, grąžinamas `2` ir parodomas per išorinį alert.
-=======
-1. The first OR `||` evaluates its left operand `alert(1)`. That shows the first message with `1`.
-2. The `alert` returns `undefined`, so OR goes on to the second operand searching for a truthy value.
-3. The second operand `2` is truthy, so the execution is halted, `2` is returned and then shown by the outer alert.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834
 
 Nebebus `3`, nes įvertinimas nepasiekia `alert(3)`.

1-js/02-first-steps/11-logical-operators/2-alert-or/task.md

@@ -4,7 +4,7 @@ importance: 3
 
 # Koks bus ARBA alert rezultatas?
 
-Ką atiduos žemiau esantis kodas?
+Ką išves žemiau esantis kodas?
 
 ```js
 alert( alert(1) || 2 || alert(3) );

1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Koks yra IR rezultatas?
 
-Ką parodys žemiau esantis kodas?
+Ką išves žemiau esantis kodas?
 
 ```js
 alert( 1 && null && 2 );