Jul 24, 2021 · Jul 24, 2021 · Jul 24, 2021 · Jul 24, 2021 · Jul 24, 2021
diff --git a/1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md b/1-js/02-first-steps/08-comparison/1-comparison-questions/solution.md
 null === +"\n0\n" → false
 ```

 Some of the reasons:
 Kai kurios priežastys:

 1.Obviously, true.
 2.Dictionary comparison, hence false.
 3.Again, dictionary comparison, first char of`"2"`is greater than the first char of `"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.
 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"`.
 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.
 6.Panašiai į `(4)`, `null`yra lygus tik `undefined`.
 7.Griežta skirtingų tipų lygybė.
diff --git a/1-js/02-first-steps/08-comparison/1-comparison-questions/task.md b/1-js/02-first-steps/08-comparison/1-comparison-questions/task.md

 ---

 #Comparisons
 #Palyginimai

 What will be the result for these expressions?
 Kokie bus šių išraiškų rezultatai?

 ```js no-beautify
 5 > 4
diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md
 #Comparisons
 #Palyginimai

 We know many comparison operators from maths:
 Iš matematikos mes žinome daug palyginimo operatorių:

 -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 equals sign `=`.A single symbol`a = b`would mean an assignment).
 -Not equals. In maths the notation is<code>&ne;</code>,but inJavaScriptit's written as an assignment with an exclamation sign before it: <code>a != b</code>.
 -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>,betJavaScriptjis rašomas kaip asigmentas su šauktuku prieš jį: <code>a != b</code>.

 ##Boolean is the result
 ##Loginė vertė yra rezultatas

 Like all other operators, a comparison returns a value. In this case, the value is a boolean.
 Kaip ir visi kiti operatoriai, palyginimas grąžina vertę. Šiuo atveju ta vertė yra loginė.

 - `true` --means "yes", "correct" or "the truth".
 - `false` --means "no", "wrong" or "not the truth".
 - `true` --reiškia "taip", "teisingai" arba "tiesa".
 - `false` --reiškia "ne", "neteisingai" arba "netiesa".

 For example:
 Pavyzdžiui:

 ```js run
 alert( 2 > 1 );  // true (correct)
 alert( 2 == 1 ); // false (wrong)
 alert( 2 != 1 ); // true (correct)
 alert( 2 > 1 );  // true (teisingai)
 alert( 2 == 1 ); // false (neteisingai)
 alert( 2 != 1 ); // true (teisingai)
 ```

 A comparison result can be assigned to a variable, just like any value:
 Palyginimo rezultatas gali būti priskirtas kintamajam, kaip ir bet kuri kita vertė:

 ```js run
 let result = 5 > 4; //assign the result of the comparison
 let result = 5 > 4; //priskirti palyginimo rezultato vertę
 alert( result ); // true
 ```

 ##String comparison
 ##Eilutės palyginimas

 To see whether a string is greater than another, JavaScriptuses the so-called "dictionary" or "lexicographical" order.
 Kad patikrintų ar viena eilutė yra didesnė už kitą, JavaScriptnaudoja taip vadinamą "žodyno" arba "leksikografinį" eiliškumą

 In other words, strings are compared letter-by-letter.
 Kitais žodžiais, eilutės yra lyginamos paraidžiui.

 For example:
 Pavyzdžiui:

 ```js run
 alert( 'Z' > 'A' ); // true
 alert( 'Glow' > 'Glee' ); // true
 alert( 'Bee' > 'Be' ); // true
 ```

 The algorithm to compare two strings is simple:
 Algoritmas eilučių palyginimui yra labai paprastas:

 1.Compare the first character of both strings.
 2.If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done.
 3.Otherwise, if both strings' first characters are the same, compare the second characters the same way.
 4.Repeat until the end of either string.
 5.If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
 1.Palyginti abiejų eilučių pirmus ženklus.
 2.Jeigu pirmas ženklas iš pirmos eilutės yra didesnis (ar mažesnis) negu kitos eilutės, tada pirma eilutė yra didesnė (ar mažesnė) už antrąją. Pabaiga.
 3.Kitu atveju, jeigu abiejų eilučių pirmi ženklai yra vienodi, tada lyginami antri ženklai tuo pačiu principu.
 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ė.

 In the examples above, the comparison`'Z' > 'A'`gets to a result at the first step while the strings`"Glow"`and `"Glee"`are compared character-by-character:
 Pavyzdyje aukščiau, palyginimas`'Z' > 'A'`gauna atsakymą pirmame žingsnyje, kai tuo tarpu`"Glow"`ir `"Glee"`yra lyginami ženklas po ženklo:

 1. `G`is the same as `G`.
 2. `l`is the same as `l`.
 3. `o`is greater than `e`.Stop here. The first string is greater.
 1. `G`tas pats kaip `G`.
 2. `l`tas pats kaip `l`.
 3. `o`yra didesnis nei `e`.Čia sustojame. Pirma eilutė yra didesnė.

 ```smart header="Not a real dictionary, but Unicodeorder"
 The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same.
 ```smart header="Ne tikras žodynas, bet Unicodeeiliškumas"
 Palyginimo algoritmas esantis aukščiau yra maždaug panašus į tokį koks naudojamas žodynuose ir telefonų knygoje, tačiau jis nėra visiškai toks pats.

 For instance, case matters. A capital letter`"A"`is not equal to the lowercase`"a"`.Which one is greater? The lowercase`"a"`.Why? Because the lowercase character has a greater index in the internal encoding tableJavaScriptuses(Unicode).We'll get back to specific details and consequences of this in the chapter <info:string>.
 Pavyzdžiui svarbu ar raidės yra mažosios ar didžiosios. Didžioji raidė`"A"`nėra lygi mažajai raidei`"a"`.Kuri yra didesnė? Mažoji`"a"`.Kodėl? Nes mažosios raidės turi aukštesnį indeksą vidinėjeJavaScriptkodavimo lentelėje(Unicode).Mes sugrįšime prie specifinių detalių ir pasekmių skyriuje <info:string>.
 ```

 ##Comparison of different types
 ##Skirtingų tipų palyginimai

 When comparing values of different types, JavaScript converts the values to numbers.
 JavaScript lygindama skirtingų tipų vertes, jas paverčia į skaičius.

 For example:
 Pavyzdžiui:

 ```js run
 alert( '2' > 1 ); // true,string '2'becomes a number 2
 alert( '01' == 1 ); // true,string '01'becomes a number 1
 alert( '2' > 1 ); // true,eilutė '2'tampa skaičiumi 2
 alert( '01' == 1 ); // true,eilutė '01'tampa skaičiumi 1
 ```

 For boolean values, `true`becomes `1` and `false`becomes `0`.
 Loginėse vertėse, `true`tampa `1`, o `false`tampa `0`.

 For example:
 Pavyzdžiui:

 ```js run
 alert( true == 1 ); // true
 alert( false == 0 ); // true
 ```

 ````smart header="A funny consequence"
 It is possible that at the same time:
 ````smart header="Linksmas sutapimas"
 Ar įmanoma, kad tuo pačiu metu:

 -Two values are equal.
 -One of them is`true` as a boolean and the other one is`false` as a boolean.
 -Dvi vertės yra vienodos.
 -Kaip loginė vertė viena iš jų yra`true`, o kita yra`false`.

 For example:
 Pavyzdžiui:

 ```js run
 let a = 0;
 alert(a == b); // true!
 ```

 From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"`becomes `0`),while the explicit`Boolean`conversion uses another set of rules.
 Iš JavaScript pozicijos, toks rezultatas yra visiškai normalus. Palyginimas paverčia vertes naudodamas skaičių konversijas (tad `"0"`tampa `0`),o tuo tarpu išskirtinė loginė`Boolean`konversija naudoja kitokias taisykles.
 ````

 ##Strict equality
 ##Griežta lygybė

 A regular equality check`==`has a problem. It cannot differentiate `0`from `false`:
 Įprastinės lygybės patikrinimas`==`turi problemą. Ji negali atskirti `0`nuo `false`:

 ```js run
 alert( 0 == false ); // true
 ```

 The same thing happens with an empty string:
 Tas pats nutinka su tuščia eilutė:

 ```js run
 alert( '' == false ); // true
 ```

 This happens because operands of different types are converted to numbers by the equality operator`==`. An empty string, just like`false`,becomes a zero.
 Taip nutinka dėl to, kad skirtingų tipų operandai naudojant lygybės operatorių`==` yra paverčiami į skaičius. Tuščia eilutė, taip pat kaip ir`false`,tampa nuliu.

 What to do if we'd like to differentiate`0`from `false`?
 Ką daryti jeigu mes norime, kad`0`skirtųsi nuo `false`?

 **A strict equality operator`===`checks the equality without type conversion.**
 **Griežtos lygybės operatorius`===`patikrina lygybę nedarydamas tipo konversijos.**

 In other words, if `a`and `b`are of different types, then `a === b`immediately returns`false`without an attempt to convert them.
 Kitaip sakant, jeigu `a`ir `b`yra skirtingų tipų, tada `a === b`iš karto grąžina`false`net nebandydama jų konvertuoti.

 Let's try it:
 Pabandykime:

 ```js run
 alert( 0 === false ); // false,because the types are different
 alert( 0 === false ); // false,nes tipai yra skirtingi
 ```

 There is also a "strict non-equality" operator `!==`analogous to `!=`.
 Taip pat yra ir "griežtos nelygybės" operatorius `!==`analogiškas `!=`.

 The strict equality operator is a bit longer to write, but makes it obvious what's going on and leaves less room for errors.
 Griežtos lygybės operatorius yra ilgesnis, bet jis padeda kodui atrodyti aiškesniu ir palieka mažiau vietos klaidoms.

 ##Comparison with nulland undefined
 ##Palyginimai su nullir undefined

 There's a non-intuitive behavior when`null`or `undefined` are compared to other values.
 Kai lyginami`null`ar `undefined`su kitomis vertėmis elgesys nėra intuityvus.

 For a strict equality check `===`
 :These values are different, because each of them is a different type.
 Griežtos lygybės patikrinime `===`
 :Šios vertės yra skirtingos, nes kiekviena jų yra skirtingo tipo.

    ```js run
    alert( null === undefined ); // false
    ```

 For a non-strict check `==`
 :There's a special rule. These two are a "sweet couple":they equal each other (in the sense of`==`),but not any other value.
 Negriežtos lygybės patikrai `==`
 :Yra speciali taisyklė. Šie du yra "saldi porelė":jie yra lygūs vienas kitam (kai yra`==`),bet jokioms kitoms vertėms.

    ```js run
    alert( null == undefined ); // true
    ```

 For maths and other comparisons `< > <= >=`
 : `null/undefined`are converted to numbers: `null`becomes `0`,while`undefined`becomes `NaN`.
 Matematiniuose ir kitokiuose palyginimuose `< > <= >=`
 : `null/undefined`yra paverčiami skaičiais: `null`tampa `0`,tuo tarpu`undefined`tampa `NaN`.

 Now let's see some funny things that happen when we apply these rules. And, what's more important, how to not fall into a trap with them.
 Dabar pasižiūrėkime į juokingus atvejus kai šios taisyklės būna pritaikomos. Ir visų svarbiausia kaip dėl jų nepakliūti į spąstus.

 ###Strange result: null vs 0
 ###Keistas rezultatas: null vs 0

 Let's compare`null`with a zero:
 Palyginkime`null`su nuliu:

 ```js run
 alert( null > 0 );  // (1) false
 alert( null == 0 ); // (2) false
 alert( null >= 0 ); // (3) *!*true*/!*
 ```

 Mathematically, that's strange. The last result states that"`null`is greater than or equal to zero",so in one of the comparisons above it must be `true`,but they are both false.
 Tai labai keista matematiškai. Rezultatas sako, kad"`null`yra didesnis arba lygus nuliu",vadinasi viename iš aukščiau esančių palyginimų turėtų būti taip pat `true`,bet jie abu yra neteisingi.

 The reason is that an equality check `==`and comparisons `> < >= <=`work differently. Comparisons convert `null`to a number, treating it as `0`.That's why(3) `null >= 0`is true and (1)`null > 0`is false.
 To priežastis yra tai, kad lygybės patikrinimas `==`ir palyginimai `> < >= <=`veikia kitaip. Palyginimai paverčia `null`į skaičių ir laiko jį nuliu `0`.Štai dėl ko(3) `null >= 0`yra tiesa, o`null > 0`yra netiesa.

 On the other hand, the equality check`==`for`undefined`and `null`is defined such that, without any conversions, they equal each other and don't equal anything else. That's why (2) `null == 0`is false.
 Iš kitos pusės, lygybės patikrinimas`==`kaip jau yra apibūdinta,`undefined`ir `null`kai jie nėra konvertuojami, jie yra vienas kitam lygūs, bet nelygūs niekam kitam. Štai kodėl (2) `null == 0`yra netiesa.

 ###An incomparable undefined
 ###Nepalyginimasis undefined

 The value`undefined`shouldn't be compared to other values:
 Vertė`undefined`neturėtų būti lyginima su kitomis vertėmis:

 ```js run
 alert( undefined > 0 ); // false (1)
 alert( undefined < 0 ); // false (2)
 alert( undefined == 0 ); // false (3)
 ```

 Why does it dislike zero so much? Always false!
 Kodėl jis taip nemėgsta nulio? Visada netiesa!

 We get these results because:
 Gauname tokius rezultatas, nes:

 -Comparisons `(1)`and `(2)`return `false` because `undefined`gets converted to`NaN` and `NaN`is a special numeric value which returns`false` for all comparisons.
 -The equality check`(3)`returns `false` because `undefined`only equals`null`, `undefined`, and no other value.
 -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.

 ###Evade problems
 ###Išvenkite problemų

 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 evade problems with them:
 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ų:

 Just treat any comparison with`undefined/null`except the strict equality`===` with exceptional care.
 Kiekvieną palyginimą susijusį su`undefined/null`vertinkite atsargiai, išskyrus su griežta lygybe`===`.

 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.
 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.

 ##Summary
 ##Santrauka

 -Comparison operators return a boolean value.
 -Strings are compared letter-by-letter in the "dictionary" order.
 -When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
 -The values`null`and `undefined`equal`==`each other and do not equal any other value.
 -Be careful when using comparisons like`>`or `<`with variables that can occasionally be`null/undefined`.Checking for`null/undefined`separately is a good idea.
 -Palyginimų operatoriai grąžina loginę vertę.
 -Eilutės yra tikrinamos paraidžiui "žodynėlio" eiliškumo principu.
 -Kai lyginamos skirtingų tipų vertės, jos yra paverčiamos į skaičius (išskyrus tik griežtą lygybės patikrinimą).
 -Vertės`null`ir `undefined`yra lygios`==`viena kitai, bet nelygios jokiai kitai vertei.
 -Būkite atsargūs kai naudojate tokius palyginimus kaip`>`arba `<`su kintamaisiai, kurie laikas nuo laiko gali būti`null/undefined`.Gera mintis yra patikrinti`null/undefined`atskirai.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -10,12 +10,12 @@ null == "\n0\n" → false
		null === +"\n0\n" → false
		```

		Some of the reasons:
		Kai kurios priežastys:

		1.Obviously, true.
		2.Dictionary comparison, hence false.
		3.Again, dictionary comparison, first char of`"2"`is greater than the first char of `"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.
		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"`.
		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.
		6.Panašiai į `(4)`, `null`yra lygus tik `undefined`.
		7.Griežta skirtingų tipų lygybė.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,9 +2,9 @@ importance: 5

		---

		#Comparisons
		#Palyginimai

		What will be the result for these expressions?
		Kokie bus šių išraiškų rezultatai?

		```js no-beautify
		5 > 4
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,95 +1,95 @@
		#Comparisons
		#Palyginimai

		We know many comparison operators from maths:
		Iš matematikos mes žinome daug palyginimo operatorių:

		-Greater/less than: <code>a > b</code>, <code>a < b</code>.
		-Greater/less than or equals: <code>a >= b</code>, <code>a <= b</code>.
		-Equals: `a == b` (please note the double equals sign `=`.A single symbol`a = b`would mean an assignment).
		-Not equals. In maths the notation is<code>≠</code>,but inJavaScriptit's written as an assignment with an exclamation sign before it: <code>a != b</code>.
		-Daugiau/mažiau negu: <code>a > b</code>, <code>a < b</code>.
		-Daugiau/mažiau arba lygu negu: <code>a >= b</code>, <code>a <= 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>≠</code>,betJavaScriptjis rašomas kaip asigmentas su šauktuku prieš jį: <code>a != b</code>.

		##Boolean is the result
		##Loginė vertė yra rezultatas

		Like all other operators, a comparison returns a value. In this case, the value is a boolean.
		Kaip ir visi kiti operatoriai, palyginimas grąžina vertę. Šiuo atveju ta vertė yra loginė.

		- `true` --means "yes", "correct" or "the truth".
		- `false` --means "no", "wrong" or "not the truth".
		- `true` --reiškia "taip", "teisingai" arba "tiesa".
		- `false` --reiškia "ne", "neteisingai" arba "netiesa".

		For example:
		Pavyzdžiui:

		```js run
		alert( 2 > 1 ); // true (correct)
		alert( 2 == 1 ); // false (wrong)
		alert( 2 != 1 ); // true (correct)
		alert( 2 > 1 ); // true (teisingai)
		alert( 2 == 1 ); // false (neteisingai)
		alert( 2 != 1 ); // true (teisingai)
		```

		A comparison result can be assigned to a variable, just like any value:
		Palyginimo rezultatas gali būti priskirtas kintamajam, kaip ir bet kuri kita vertė:

		```js run
		let result = 5 > 4; //assign the result of the comparison
		let result = 5 > 4; //priskirti palyginimo rezultato vertę
		alert( result ); // true
		```

		##String comparison
		##Eilutės palyginimas

		To see whether a string is greater than another, JavaScriptuses the so-called "dictionary" or "lexicographical" order.
		Kad patikrintų ar viena eilutė yra didesnė už kitą, JavaScriptnaudoja taip vadinamą "žodyno" arba "leksikografinį" eiliškumą

		In other words, strings are compared letter-by-letter.
		Kitais žodžiais, eilutės yra lyginamos paraidžiui.

		For example:
		Pavyzdžiui:

		```js run
		alert( 'Z' > 'A' ); // true
		alert( 'Glow' > 'Glee' ); // true
		alert( 'Bee' > 'Be' ); // true
		```

		The algorithm to compare two strings is simple:
		Algoritmas eilučių palyginimui yra labai paprastas:

		1.Compare the first character of both strings.
		2.If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done.
		3.Otherwise, if both strings' first characters are the same, compare the second characters the same way.
		4.Repeat until the end of either string.
		5.If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
		1.Palyginti abiejų eilučių pirmus ženklus.
		2.Jeigu pirmas ženklas iš pirmos eilutės yra didesnis (ar mažesnis) negu kitos eilutės, tada pirma eilutė yra didesnė (ar mažesnė) už antrąją. Pabaiga.
		3.Kitu atveju, jeigu abiejų eilučių pirmi ženklai yra vienodi, tada lyginami antri ženklai tuo pačiu principu.
		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ė.

		In the examples above, the comparison`'Z' > 'A'`gets to a result at the first step while the strings`"Glow"`and `"Glee"`are compared character-by-character:
		Pavyzdyje aukščiau, palyginimas`'Z' > 'A'`gauna atsakymą pirmame žingsnyje, kai tuo tarpu`"Glow"`ir `"Glee"`yra lyginami ženklas po ženklo:

		1. `G`is the same as `G`.
		2. `l`is the same as `l`.
		3. `o`is greater than `e`.Stop here. The first string is greater.
		1. `G`tas pats kaip `G`.
		2. `l`tas pats kaip `l`.
		3. `o`yra didesnis nei `e`.Čia sustojame. Pirma eilutė yra didesnė.

		```smart header="Not a real dictionary, but Unicodeorder"
		The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same.
		```smart header="Ne tikras žodynas, bet Unicodeeiliškumas"
		Palyginimo algoritmas esantis aukščiau yra maždaug panašus į tokį koks naudojamas žodynuose ir telefonų knygoje, tačiau jis nėra visiškai toks pats.

		For instance, case matters. A capital letter`"A"`is not equal to the lowercase`"a"`.Which one is greater? The lowercase`"a"`.Why? Because the lowercase character has a greater index in the internal encoding tableJavaScriptuses(Unicode).We'll get back to specific details and consequences of this in the chapter <info:string>.
		Pavyzdžiui svarbu ar raidės yra mažosios ar didžiosios. Didžioji raidė`"A"`nėra lygi mažajai raidei`"a"`.Kuri yra didesnė? Mažoji`"a"`.Kodėl? Nes mažosios raidės turi aukštesnį indeksą vidinėjeJavaScriptkodavimo lentelėje(Unicode).Mes sugrįšime prie specifinių detalių ir pasekmių skyriuje <info:string>.
		```

		##Comparison of different types
		##Skirtingų tipų palyginimai

		When comparing values of different types, JavaScript converts the values to numbers.
		JavaScript lygindama skirtingų tipų vertes, jas paverčia į skaičius.

		For example:
		Pavyzdžiui:

		```js run
		alert( '2' > 1 ); // true,string '2'becomes a number 2
		alert( '01' == 1 ); // true,string '01'becomes a number 1
		alert( '2' > 1 ); // true,eilutė '2'tampa skaičiumi 2
		alert( '01' == 1 ); // true,eilutė '01'tampa skaičiumi 1
		```

		For boolean values, `true`becomes `1` and `false`becomes `0`.
		Loginėse vertėse, `true`tampa `1`, o `false`tampa `0`.

		For example:
		Pavyzdžiui:

		```js run
		alert( true == 1 ); // true
		alert( false == 0 ); // true
		```

		````smart header="A funny consequence"
		It is possible that at the same time:
		````smart header="Linksmas sutapimas"
		Ar įmanoma, kad tuo pačiu metu:

		-Two values are equal.
		-One of them is`true` as a boolean and the other one is`false` as a boolean.
		-Dvi vertės yra vienodos.
		-Kaip loginė vertė viena iš jų yra`true`, o kita yra`false`.

		For example:
		Pavyzdžiui:

		```js run
		let a = 0;
Expand All		@@ -101,109 +101,109 @@ alert( Boolean(b) ); // true
		alert(a == b); // true!
		```

		From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"`becomes `0`),while the explicit`Boolean`conversion uses another set of rules.
		Iš JavaScript pozicijos, toks rezultatas yra visiškai normalus. Palyginimas paverčia vertes naudodamas skaičių konversijas (tad `"0"`tampa `0`),o tuo tarpu išskirtinė loginė`Boolean`konversija naudoja kitokias taisykles.
		````

		##Strict equality
		##Griežta lygybė

		A regular equality check`==`has a problem. It cannot differentiate `0`from `false`:
		Įprastinės lygybės patikrinimas`==`turi problemą. Ji negali atskirti `0`nuo `false`:

		```js run
		alert( 0 == false ); // true
		```

		The same thing happens with an empty string:
		Tas pats nutinka su tuščia eilutė:

		```js run
		alert( '' == false ); // true
		```

		This happens because operands of different types are converted to numbers by the equality operator`==`. An empty string, just like`false`,becomes a zero.
		Taip nutinka dėl to, kad skirtingų tipų operandai naudojant lygybės operatorių`==` yra paverčiami į skaičius. Tuščia eilutė, taip pat kaip ir`false`,tampa nuliu.

		What to do if we'd like to differentiate`0`from `false`?
		Ką daryti jeigu mes norime, kad`0`skirtųsi nuo `false`?

		A strict equality operator`===`checks the equality without type conversion.
		Griežtos lygybės operatorius`===`patikrina lygybę nedarydamas tipo konversijos.

		In other words, if `a`and `b`are of different types, then `a === b`immediately returns`false`without an attempt to convert them.
		Kitaip sakant, jeigu `a`ir `b`yra skirtingų tipų, tada `a === b`iš karto grąžina`false`net nebandydama jų konvertuoti.

		Let's try it:
		Pabandykime:

		```js run
		alert( 0 === false ); // false,because the types are different
		alert( 0 === false ); // false,nes tipai yra skirtingi
		```

		There is also a "strict non-equality" operator `!==`analogous to `!=`.
		Taip pat yra ir "griežtos nelygybės" operatorius `!==`analogiškas `!=`.

		The strict equality operator is a bit longer to write, but makes it obvious what's going on and leaves less room for errors.
		Griežtos lygybės operatorius yra ilgesnis, bet jis padeda kodui atrodyti aiškesniu ir palieka mažiau vietos klaidoms.

		##Comparison with nulland undefined
		##Palyginimai su nullir undefined

		There's a non-intuitive behavior when`null`or `undefined` are compared to other values.
		Kai lyginami`null`ar `undefined`su kitomis vertėmis elgesys nėra intuityvus.

		For a strict equality check `===`
		:These values are different, because each of them is a different type.
		Griežtos lygybės patikrinime `===`
		:Šios vertės yra skirtingos, nes kiekviena jų yra skirtingo tipo.

		```js run
		alert( null === undefined ); // false
		```

		For a non-strict check `==`
		:There's a special rule. These two are a "sweet couple":they equal each other (in the sense of`==`),but not any other value.
		Negriežtos lygybės patikrai `==`
		:Yra speciali taisyklė. Šie du yra "saldi porelė":jie yra lygūs vienas kitam (kai yra`==`),bet jokioms kitoms vertėms.

		```js run
		alert( null == undefined ); // true
		```

		For maths and other comparisons `< > <= >=`
		: `null/undefined`are converted to numbers: `null`becomes `0`,while`undefined`becomes `NaN`.
		Matematiniuose ir kitokiuose palyginimuose `< > <= >=`
		: `null/undefined`yra paverčiami skaičiais: `null`tampa `0`,tuo tarpu`undefined`tampa `NaN`.

		Now let's see some funny things that happen when we apply these rules. And, what's more important, how to not fall into a trap with them.
		Dabar pasižiūrėkime į juokingus atvejus kai šios taisyklės būna pritaikomos. Ir visų svarbiausia kaip dėl jų nepakliūti į spąstus.

		###Strange result: null vs 0
		###Keistas rezultatas: null vs 0

		Let's compare`null`with a zero:
		Palyginkime`null`su nuliu:

		```js run
		alert( null > 0 ); // (1) false
		alert( null == 0 ); // (2) false
		alert( null >= 0 ); // (3) !true/!
		```

		Mathematically, that's strange. The last result states that"`null`is greater than or equal to zero",so in one of the comparisons above it must be `true`,but they are both false.
		Tai labai keista matematiškai. Rezultatas sako, kad"`null`yra didesnis arba lygus nuliu",vadinasi viename iš aukščiau esančių palyginimų turėtų būti taip pat `true`,bet jie abu yra neteisingi.

		The reason is that an equality check `==`and comparisons `> < >= <=`work differently. Comparisons convert `null`to a number, treating it as `0`.That's why(3) `null >= 0`is true and (1)`null > 0`is false.
		To priežastis yra tai, kad lygybės patikrinimas `==`ir palyginimai `> < >= <=`veikia kitaip. Palyginimai paverčia `null`į skaičių ir laiko jį nuliu `0`.Štai dėl ko(3) `null >= 0`yra tiesa, o`null > 0`yra netiesa.

		On the other hand, the equality check`==`for`undefined`and `null`is defined such that, without any conversions, they equal each other and don't equal anything else. That's why (2) `null == 0`is false.
		Iš kitos pusės, lygybės patikrinimas`==`kaip jau yra apibūdinta,`undefined`ir `null`kai jie nėra konvertuojami, jie yra vienas kitam lygūs, bet nelygūs niekam kitam. Štai kodėl (2) `null == 0`yra netiesa.

		###An incomparable undefined
		###Nepalyginimasis undefined

		The value`undefined`shouldn't be compared to other values:
		Vertė`undefined`neturėtų būti lyginima su kitomis vertėmis:

		```js run
		alert( undefined > 0 ); // false (1)
		alert( undefined < 0 ); // false (2)
		alert( undefined == 0 ); // false (3)
		```

		Why does it dislike zero so much? Always false!
		Kodėl jis taip nemėgsta nulio? Visada netiesa!

		We get these results because:
		Gauname tokius rezultatas, nes:

		-Comparisons `(1)`and `(2)`return `false` because `undefined`gets converted to`NaN` and `NaN`is a special numeric value which returns`false` for all comparisons.
		-The equality check`(3)`returns `false` because `undefined`only equals`null`, `undefined`, and no other value.
		-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.

		###Evade problems
		###Išvenkite problemų

		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 evade problems with them:
		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ų:

		Just treat any comparison with`undefined/null`except the strict equality`===` with exceptional care.
		Kiekvieną palyginimą susijusį su`undefined/null`vertinkite atsargiai, išskyrus su griežta lygybe`===`.

		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.
		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.

		##Summary
		##Santrauka

		-Comparison operators return a boolean value.
		-Strings are compared letter-by-letter in the "dictionary" order.
		-When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
		-The values`null`and `undefined`equal`==`each other and do not equal any other value.
		-Be careful when using comparisons like`>`or `<`with variables that can occasionally be`null/undefined`.Checking for`null/undefined`separately is a good idea.
		-Palyginimų operatoriai grąžina loginę vertę.
		-Eilutės yra tikrinamos paraidžiui "žodynėlio" eiliškumo principu.
		-Kai lyginamos skirtingų tipų vertės, jos yra paverčiamos į skaičius (išskyrus tik griežtą lygybės patikrinimą).
		-Vertės`null`ir `undefined`yra lygios`==`viena kitai, bet nelygios jokiai kitai vertei.
		-Būkite atsargūs kai naudojate tokius palyginimus kaip`>`arba `<`su kintamaisiai, kurie laikas nuo laiko gali būti`null/undefined`.Gera mintis yra patikrinti`null/undefined`atskirai.