.
```
-## 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;
@@ -101,67 +101,67 @@ 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 null and undefined
+## Palyginimai su null ir 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
@@ -169,15 +169,15 @@ 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)
@@ -185,25 +185,25 @@ 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.
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