Revert "1.2.7"

1-js/02-first-steps/07-type-conversions/article.md

@@ -1,149 +1,150 @@
-# Typová konverze
+# Type Conversions
 
-Operátory a funkce většinou automaticky převedou hodnoty, které jim byly zadány, na správný typ.
+Most of the time, operators and functions automatically convert the values given to them to the right type.
 
-Například `alert` automaticky převede libovolnou hodnotu na řetězec a ten zobrazí. Matematické operace převádějí hodnoty na čísla.
+For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
 
-Existují však případy, v nichž musíme konverzi hodnoty na potřebný typ explicitně uvést.
+There are also cases when we need to explicitly convert a value to the expected type.
 
-```smart header="Zatím nehovoříme o objektech"
-V této kapitole se ještě nebudeme zabývat objekty. Prozatím budeme hovořit jen o primitivních typech.
+```smart header="Not talking about objects yet"
+In this chapter, we won't cover objects. For now, we'll just be talking about primitives.
 
-Až se později dozvíme něco o objektech, v kapitole <info:object-toprimitive> uvidíme, jak do toho zapadají.
+Later, after we learn about objects, in the chapter <info:object-toprimitive> we'll see how objects fit in.
 ```
 
-## Konverze na řetězec
+## String Conversion
 
-Konverze na řetězec se odehraje tehdy, když potřebujeme hodnotu ve formě řetězce.
+String conversion happens when we need the string form of a value.
 
-Provádí ji například `alert(hodnota)`, aby mohla zobrazit hodnotu.
+For example, `alert(value)` does it to show the value.
 
-Můžeme také volat funkci `String(hodnota)`, která převede zadanou hodnotu na řetězec:
+We can also call the `String(value)` function to convert a value to a string:
 
 ```js run
-let hodnota = true;
-alert(typeof hodnota); // boolean
+let value = true;
+alert(typeof value); // boolean
 
 *!*
-hodnota = String(hodnota); // hodnota je nyní řetězec "true"
-alert(typeof hodnota); // string (řetězec)
+value = String(value); // now value is a string "true"
+alert(typeof value); // string
 */!*
 ```
 
-Konverze na řetězec je většinou zřejmá: `false` se převede na `"false"`, `null` se převede na `"null"`, atd.
+String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc.
 
-## Konverze na číslo
+## Numeric Conversion
 
-Konverze na číslo se automaticky odehrává v matematických funkcích a výrazech.
+Numeric conversion happens in mathematical functions and expressions automatically.
 
-Například když použijeme dělení `/` na něco jiného než čísla:
+For example, when division `/` is applied to non-numbers:
 
 ```js run
-alert( "6" / "2" ); // 3, řetězce se konvertují na čísla
+alert( "6" / "2" ); // 3, strings are converted to numbers
 ```
 
-Pro explicitní konverzi hodnoty `hodnota` na číslo můžeme použít funkci `Number(hodnota)`:
+We can use the `Number(value)` function to explicitly convert a `value` to a number:
 
 ```js run
-let řtzc = "123";
-alert(typeof řtzc); // string (řetězec)
+let str = "123";
+alert(typeof str); // string
 
-let čslo = Number(řtzc); // stane se z něj číslo 123
+let num = Number(str); // becomes a number 123
 
-alert(typeof čslo); // number (číslo)
+alert(typeof num); // number
 ```
 
-Explicitní konverze je obvykle potřebná, když načítáme hodnotu z řetězcového zdroje, například z textového formuláře, ale očekáváme zadání čísla.
+Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
 
-Není-li v řetězci platné číslo, výsledkem konverze bude `NaN`. Například:
+If the string is not a valid number, the result of such a conversion is `NaN`. For instance:
 
 ```js run
-let věk = Number("nějaký řetězec místo čísla");
+let age = Number("an arbitrary string instead of a number");
 
-alert(věk); // NaN, konverze neuspěla
+alert(age); // NaN, conversion failed
 ```
 
-Pravidla pro konverzi na číslo:
+Numeric conversion rules:
 
-| Hodnota |  Převede se na... |
-|---------|-------------------|
+| Value |  Becomes... |
+|-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
-|<code>true</code>&nbsp;a&nbsp;<code>false</code> | `1` a `0` |
-| `řetězec` | Odstraní se bílé znaky (mezery, tabulátory, konce řádku) ze začátku a konce. Je-li výsledný řetězec prázdný, výsledkem je `0`. Jinak se číslo „přečte“ z řetězce. Při chybě je vydáno `NaN`. |
+|<code>true&nbsp;and&nbsp;false</code> | `1` and `0` |
+| `string` | Whitespaces from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. |
 
-Příklady:
+Examples:
 
 ```js run
 alert( Number("   123   ") ); // 123
-alert( Number("123z") );      // NaN (chyba při čtení čísla u znaku "z")
+alert( Number("123z") );      // NaN (error reading a number at "z")
 alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
-Všimněte si, že `null` a `undefined` se tady chovají rozdílně: `null` se převede na nulu, zatímco `undefined` se převede na `NaN`.
+Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`.
 
-Tuto konverzi provádí i většina matematických operátorů. Uvidíme to v následující kapitole.
+Most mathematical operators also perform such conversion, we'll see that in the next chapter.
 
-## Konverze na boolean
+## Boolean Conversion
 
-Konverze na boolean je nejjednodušší.
+Boolean conversion is the simplest one.
 
-Odehrává se v logických operátorech (později se setkáme s testy platnosti podmínky a podobnými věcmi), ale můžeme ji provést i explicitně voláním `Boolean(value)`.
+It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
 
-Pravidla konverze:
+The conversion rule:
 
-- Hodnoty, které jsou intuitivně „prázdné“, tj. `0`, prázdný řetězec, `null`, `undefined` a `NaN`, se převedou na `false`.
-- Ostatní hodnoty se převedou na `true`.
+- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`.
+- Other values become `true`.
 
-Příklad:
+For instance:
 
 ```js run
 alert( Boolean(1) ); // true
 alert( Boolean(0) ); // false
 
-alert( Boolean("ahoj") ); // true
+alert( Boolean("hello") ); // true
 alert( Boolean("") ); // false
 ```
 
-````warn header="Všimněte si: řetězec s nulou `\"0\"` se převede na `true`"
-Některé jazyky (konkrétně PHP) zacházejí s řetězcem `"0"` jako s `false`, avšak v JavaScriptu je neprázdný řetězec vždy `true`.
+````warn header="Please note: the string with zero `\"0\"` is `true`"
+Some languages (namely PHP) treat `"0"` as `false`. But in JavaScript, a non-empty string is always `true`.
 
 ```js run
 alert( Boolean("0") ); // true
-alert( Boolean(" ") ); // mezery, také true (každý neprázdný řetězec je true)
+alert( Boolean(" ") ); // spaces, also true (any non-empty string is true)
 ```
 ````
 
-## Shrnutí
+## Summary
 
-Tři nejčastěji používané typové konverze jsou na řetězec, na číslo a na boolean.
+The three most widely used type conversions are to string, to number, and to boolean.
 
-**`Konverze na řetězec`** -- Nastává, když něco vypisujeme. Můžeme ji provést pomocí `String(hodnota)`. Konverze na řetězec je u primitivních typů obvykle zřejmá.
+**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
 
-**`Konverze na číslo`** -- Nastává při matematických operacích. Můžeme ji provést pomocí `Number(hodnota)`.
+**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`.
 
-Konverze se řídí těmito pravidly:
+The conversion follows the rules:
 
-| Hodnota |  Převede se na... |
-|---------|-------------------|
+| Value |  Becomes... |
+|-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
-| `řetězec` | Načte se „doslovně“, bílé znaky na obou stranách se ignorují. Z prázdného řetězce se stane `0`. Při chybě je vydáno `NaN`. |
+| `string` | The string is read "as is", whitespaces from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
 
-**`Konverze na boolean`** -- Nastává při logických operacích. Můžeme ji provést pomocí `Boolean(hodnota)`.
+**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
 
-Řídí se těmito pravidly:
+Follows the rules:
 
-| Hodnota |  Převede se na... |
-|---------|-------------------|
+| Value |  Becomes... |
+|-------|-------------|
 |`0`, `null`, `undefined`, `NaN`, `""` |`false`|
-|jakákoli jiná hodnota| `true` |
+|any other value| `true` |
 
-Většinu těchto pravidel je snadné pochopit a zapamatovat si. Významné výjimky, v nichž lidé obvykle chybují, jsou:
 
-- `undefined` převedené na číslo je `NaN`, ne `0`.
-- `"0"` a řetězce obsahující jen mezery, např. `"   "`, jsou po převodu na boolean vyhodnoceny jako true.
+Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are:
 
-O objektech se zde nezmiňujeme. Později, až se v JavaScriptu naučíme všechny potřebné základy, se k nim vrátíme v kapitole <info:object-toprimitive>, která je věnována výlučně objektům.
+- `undefined` is `NaN` as a number, not `0`.
+- `"0"` and space-only strings like `"   "` are true as a boolean.
+
+Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.