diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md index 632b1cf4e..480a91a61 100644 --- a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md +++ b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md @@ -2,7 +2,7 @@ ```js no-beautify 5 > 4 → true -"apple" > "pineapple" → false +"ananas" > "jablko" → false "2" > "12" → true undefined == null → true undefined === null → false @@ -10,12 +10,12 @@ null == "\n0\n" → false null === +"\n0\n" → false ``` -Some of the reasons: +Některé z důvodů: -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. +1. Samozřejmě true. +2. Slovníkové porovnání, proto false. `"a"` je menší než `"j"`. +3. Opět slovníkové porovnání, první znak `"2"` je větší než první znak `"1"`. +4. Hodnoty `null` a `undefined` se rovnají jedině sobě navzájem. +5. Striktní rovnost je striktní. Různé typy na obou stranách vedou k výsledku false. +6. Obdobně jako ve `(4)` se `null` rovná jedině `undefined`. +7. Striktní rovnost s různými typy vrací false. diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md index be7f75ddd..ac9c70d08 100644 --- a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md +++ b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md @@ -2,13 +2,13 @@ importance: 5 --- -# Comparisons +# Porovnávání -What will be the result for these expressions? +Jaký bude výsledek těchto výrazů? ```js no-beautify 5 > 4 -"apple" > "pineapple" +"ananas" > "jablko" "2" > "12" undefined == null undefined === null diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md index a69317fee..35b2ce048 100644 --- a/1-js/02-first-steps/09-comparison/article.md +++ b/1-js/02-first-steps/09-comparison/article.md @@ -1,47 +1,47 @@ -# Comparisons +# Porovnávání -We know many comparison operators from maths. +Z matematiky známe mnoho porovnávacích operátorů. -In JavaScript they are written like this: +V JavaScriptu se píší následovně: -- Greater/less than: a > b, a < b. -- Greater/less than or equals: a >= b, a <= b. -- 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 ≠, but in JavaScript it's written as a != b. +- Větší/menší než: a > b, a < b. +- Větší/menší nebo rovno: a >= b, a <= b. +- Rovno: `a == b`. Prosíme všimněte si, že znak dvou rovnítek za sebou `==` znamená test rovnosti, zatímco jediné rovnítko `a = b` znamená přiřazení. +- Nerovno: v matematice se používá znak ≠, ale v JavaScriptu se píše a != b. -In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities. +V tomto článku se dozvíme víc o různých druzích porovnání a o tom, jak s nimi JavaScript zachází, včetně důležitých zvláštností. -At the end you'll find a good recipe to avoid "JavaScript quirks"-related issues. +Na konci najdete recept, jak se vyhnout různým problémům způsobeným JavaScriptovými „vtípky“. -## Boolean is the result +## Výsledkem je typ boolean -All comparison operators return a boolean value: +Všechny porovnávací operátory vracejí hodnotu typu boolean: -- `true` -- means "yes", "correct" or "the truth". -- `false` -- means "no", "wrong" or "not the truth". +- `true` -- znamená „ano“, „správně“ nebo „pravda“. +- `false` -- znamená „ne“, „nesprávně“ nebo „nepravda“. -For example: +Příklad: ```js run -alert( 2 > 1 ); // true (correct) -alert( 2 == 1 ); // false (wrong) -alert( 2 != 1 ); // true (correct) +alert( 2 > 1 ); // true (správně) +alert( 2 == 1 ); // false (nesprávně) +alert( 2 != 1 ); // true (správně) ``` -A comparison result can be assigned to a variable, just like any value: +Výsledek porovnání můžeme přiřadit do proměnné, stejně jako každou jinou hodnotu: ```js run -let result = 5 > 4; // assign the result of the comparison -alert( result ); // true +let výsledek = 5 > 4; // přiřadíme výsledek porovnání +alert( výsledek ); // true ``` -## String comparison +## Porovnávání řetězců -To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order. +Ke zjištění, zda je jeden řetězec větší než jiný, JavaScript používá tzv. „slovníkové“ neboli „lexikografické“ pořadí. -In other words, strings are compared letter-by-letter. +Jinými slovy, řetězce se porovnávají znak po znaku. -For example: +Příklad: ```js run alert( 'Z' > 'A' ); // true @@ -49,55 +49,55 @@ alert( 'Glow' > 'Glee' ); // true alert( 'Bee' > 'Be' ); // true ``` -The algorithm to compare two strings is simple: +Algoritmus pro porovnání dvou řetězců je jednoduchý: -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. Porovnej první znak obou řetězců. +2. Je-li první znak prvního řetězce větší (nebo menší) než první znak druhého řetězce, je první řetězec větší (nebo menší) než druhý. Tím jsme hotovi. +3. V opačném případě, tedy jsou-li první znaky obou řetězců stejné, porovnej stejným způsobem druhé znaky. +4. Tento proces opakuj, dokud nedojdeš na konec některého z řetězců. +5. Mají-li oba řetězce stejnou délku, jsou si rovny. V opačném případě je delší řetězec větší. -In the first example above, the comparison `'Z' > 'A'` gets to a result at the first step. +Ve výše uvedených příkladech porovnání `'Z' > 'A'` dojde k výsledku hned v prvním kroku. -The second comparison `'Glow'` and `'Glee'` needs more steps as strings are compared character-by-character: +Porovnání řetězců `"Glow"` a `"Glee"` však vyžaduje více kroků, jelikož řetězce se porovnávají znak po znaku: -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` je stejné jako `G`. +2. `l` je stejné jako `l`. +3. `o` je větší než `e`. Tady se zastavíme. První řetězec je větší. -```smart header="Not a real dictionary, but Unicode order" -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="Není to skutečný slovník, ale pořadí podle Unicode" +Uvedený porovnávací algoritmus zhruba odpovídá tomu, jaký se používá k řazení ve slovnících nebo telefonních seznamech, ale není úplně stejný. -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 table JavaScript uses (Unicode). We'll get back to specific details and consequences of this in the chapter . +Například záleží na velikosti písmen. Velké písmeno `"A"` není rovno malému `"a"`. Které je větší? Malé `"a"`. Proč? Protože malá písmena mají v interní kódovací tabulce, kterou JavaScript používá (Unicode), vyšší index. Ke specifickým podrobnostem a důsledkům se vrátíme v kapitole . ``` -## Comparison of different types +## Porovnávání rozdílných typů -When comparing values of different types, JavaScript converts the values to numbers. +Když JavaScript porovnává hodnoty různých typů, převádí je na čísla. -For example: +Příklad: ```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, řetězec '2' se převede na číslo 2 +alert( '01' == 1 ); // true, řetězec '01' se převede na číslo 1 ``` -For boolean values, `true` becomes `1` and `false` becomes `0`. +U hodnot typu boolean se `true` převede na `1` a `false` na `0`. -For example: +Příklad: ```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="Legrační důsledek" +Je možné, že současně: -- Two values are equal. -- One of them is `true` as a boolean and the other one is `false` as a boolean. +- Dvě hodnoty se budou rovnat. +- Jedna z nich bude jako boolean `true` a druhá `false`. -For example: +Příklad: ```js run let a = 0; @@ -109,67 +109,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. +Z pohledu JavaScriptu je tento výsledek zcela normální. Test rovnosti převádí hodnoty pomocí konverze na čísla (proto se `"0"` převede na `0`), zatímco explicitní konverze `Boolean` funguje podle jiných pravidel. ```` -## Strict equality +## Striktní rovnost -A regular equality check `==` has a problem. It cannot differentiate `0` from `false`: +Běžné ověření rovnosti `==` má problém. Nedokáže rozlišit `0` od `false`: ```js run alert( 0 == false ); // true ``` -The same thing happens with an empty string: +Totéž platí pro prázdný řetězec: ```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. +To se děje proto, že operátor rovnosti `==` převádí operandy různých typů na čísla. Prázdný řetězec, stejně jako `false`, se převede na nulu. -What to do if we'd like to differentiate `0` from `false`? +Co máme dělat, jestliže chceme rozlišit `0` od `false`? -**A strict equality operator `===` checks the equality without type conversion.** +**Operátor striktní rovnosti `===` zkontroluje rovnost bez typové konverze.** -In other words, if `a` and `b` are of different types, then `a === b` immediately returns `false` without an attempt to convert them. +Jinými slovy, jsou-li `a` a `b` různých typů, pak `a === b` okamžitě vrátí `false`, aniž by se je pokusil konvertovat. -Let's try it: +Zkusme to: ```js run -alert( 0 === false ); // false, because the types are different +alert( 0 === false ); // false, protože typy jsou různé ``` -There is also a "strict non-equality" operator `!==` analogous to `!=`. +Existuje i operátor „striktní nerovnosti“ `!==`, který je analogický s `!=`. -The strict equality operator is a bit longer to write, but makes it obvious what's going on and leaves less room for errors. +Operátor striktní rovnosti se píše trošičku déle, ale díky němu je hned zřejmé, o co tady jde, a ponechává méně prostoru k chybám. -## Comparison with null and undefined +## Porovnávání s null a undefined -There's a non-intuitive behavior when `null` or `undefined` are compared to other values. +Chování při porovnávání `null` nebo `undefined` s jinými hodnotami není zcela intuitivní. -For a strict equality check `===` -: These values are different, because each of them is a different type. +U operátoru striktní rovnosti `===` +: Tyto hodnoty jsou různé, protože každá z nich je jiného typu. ```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. +U operátoru nestriktní rovnosti `==` +: Platí zvláštní pravidlo. Tyto dvě hodnoty tvoří „zamilovanou dvojici“: jsou si navzájem rovny (ve smyslu `==`), ale nejsou rovny žádné jiné hodnotě. ```js run alert( null == undefined ); // true ``` -For maths and other comparisons `< > <= >=` -: `null/undefined` are converted to numbers: `null` becomes `0`, while `undefined` becomes `NaN`. +U matematických a jiných porovnání `< > <= >=` +: `null/undefined` se převádějí na čísla: `null` se převede na `0`, zatímco `undefined` se převede na `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. +Nyní se podívejme na některé legrační jevy, k nimž dochází při použití těchto pravidel. A, což je důležitější, jak se s nimi nechytit do pasti. -### Strange result: null vs 0 +### Podivný výsledek: null vs 0 -Let's compare `null` with a zero: +Porovnejme `null` s nulou: ```js run alert( null > 0 ); // (1) false @@ -177,15 +177,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. +Matematicky je to zvláštní. Poslední uvedený výsledek tvrdí, že „`null` je větší nebo rovno nule“, takže jedno z výše uvedených porovnání musí být `true`, ale obě jsou `false`. -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. +Důvodem je, že test rovnosti `==` a porovnání `> < >= <=` fungují odlišně. Porovnání převedou `null` na číslo a zacházejí s ním jako s `0`. Proto (3) `null >= 0` platí a (1) `null > 0` neplatí. -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. +Naproti tomu rovnost `==` pro `undefined` a `null` je definována tak, že se bez jakýchkoli konverzí rovnají navzájem a nerovnají se ničemu jinému. Proto (2) `null == 0` neplatí. -### An incomparable undefined +### Neporovnatelné undefined -The value `undefined` shouldn't be compared to other values: +Hodnota `undefined` by neměla být porovnávána s jinými hodnotami: ```js run alert( undefined > 0 ); // false (1) @@ -193,24 +193,24 @@ alert( undefined < 0 ); // false (2) alert( undefined == 0 ); // false (3) ``` -Why does it dislike zero so much? Always false! +Proč ji porovnávání nemá tak rádo? Vždycky vyjde false! -We get these results because: +Tyto výsledky jsme získali, protože: -- 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. +- Porovnání `(1)` a `(2)` vracejí `false`, protože `undefined` se převede na `NaN` a `NaN` je speciální číselná hodnota, která při všech porovnáních vrátí `false`. +- Test rovnosti `(3)` vrací `false`, protože `undefined` se rovná jedině `null` a `undefined`, žádné jiné hodnotě. -### Avoid problems +### Jak se vyhnout problémům -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: +Jak se přes tyto příklady přenést? Měli bychom si tyto zvláštnosti neustále pamatovat? Vlastně ani ne. Ve skutečnosti se s těmito triky postupem času sžijete, ale existuje solidní způsob, jak se vyhnout problémům, které způsobují: -- 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. +- Zacházejte s každým porovnáním s `undefined/null` kromě striktní rovnosti `===` výjimečně opatrně. +- Nepoužívejte porovnání `>= > < <=` na proměnnou, která by mohla být `null/undefined`, pokud si opravdu nejste jisti tím, co děláte. Může-li proměnná obsahovat tyto hodnoty, ověřte je zvlášť. -## Summary +## Shrnutí -- 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. +- Porovnávací operátory vracejí hodnotu typu boolean. +- Řetězce se porovnávají znak po znaku podle „slovníkového“ pořadí. +- Když se porovnávají hodnoty různých typů, převedou se na čísla (s výjimkou operátoru striktní rovnosti). +- Hodnoty `null` a `undefined` se rovnají `==` sobě navzájem, ale nerovnají se žádné jiné hodnotě. +- Buďte opatrní při používání porovnávání jako `<` nebo `>` na proměnné, které mohou být `null/undefined`. Dobrý nápad je odděleně ověřit, zda opravdu jsou `null/undefined`.