Skip to content

Commit 0873e9b

Browse files
authored
Merge pull request #58 from javascript-tutorial/sync-741d90ce
Sync with upstream @ 741d90c
2 parents ac296c6 + 0513399 commit 0873e9b

File tree

3 files changed

+78
-0
lines changed

3 files changed

+78
-0
lines changed

1-js/04-object-basics/07-optional-chaining/article.md

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -108,9 +108,15 @@ Např. `?.` v `uživatel?.adresa.ulice.name` umožňuje, aby `uživatel` byl bez
108108
```warn header="Nepoužívejte volitelné zřetězení přehnaně často"
109109
Měli bychom používat `?.` jen tehdy, když je v pořádku, že něco neexistuje.
110110

111+
<<<<<<< HEAD
111112
Například pokud podle logiky našeho kódování musí objekt `uživatel` existovat, ale `adresa` je volitelná, pak bychom měli psát `uživatel.adresa?.ulice`, ale ne `uživatel?.adresa?.ulice`.
112113

113114
Pak pokud se v důsledku chyby stane, že `uživatel` bude nedefinovaný, uvidíme programátorskou chybu a opravíme ji. Jinak by se chyby v kódu mohly neohlásit i tehdy, když to není vhodné, a jejich ladění by bylo obtížnější.
115+
=======
116+
For example, if according to our code logic `user` object must exist, but `address` is optional, then we should write `user.address?.street`, but not `user?.address?.street`.
117+
118+
Then, if `user` happens to be undefined, we'll see a programming error about it and fix it. Otherwise, if we overuse `?.`, coding errors can be silenced where not appropriate, and become more difficult to debug.
119+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
114120
```
115121
116122
````warn header="Proměnná před `?.` musí být deklarovaná"
@@ -127,15 +133,23 @@ Proměnná musí být deklarovaná (tj. `let/const/var uživatel` nebo jako para
127133
128134
Jak bylo řečeno, `?.` okamžitě pozastaví („vyzkratuje“) vyhodnocování, jestliže levá část neexistuje.
129135
136+
<<<<<<< HEAD
130137
Jestliže tedy následují další volání funkcí nebo vedlejší efekty, neprovedou se.
138+
=======
139+
So, if there are any further function calls or operations to the right of `?.`, they won't be made.
140+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
131141

132142
Například:
133143

134144
```js run
135145
let uživatel = null;
136146
let x = 0;
137147
148+
<<<<<<< HEAD
138149
uživatel?.řekniAhoj(x++); // „řekniAhoj“ se neprovede, takže výkon se nedostane ke x++
150+
=======
151+
user?.sayHi(x++); // no "user", so the execution doesn't reach sayHi call and x++
152+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
139153
140154
alert(x); // 0, hodnota se nezvýšila
141155
```
@@ -179,7 +193,11 @@ let uživatel1 = {
179193
křestníJméno: "Jan"
180194
};
181195
196+
<<<<<<< HEAD
182197
let uživatel2 = null;
198+
=======
199+
let user2 = null;
200+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
183201
184202
alert( uživatel1?.[klíč] ); // Jan
185203
alert( uživatel2?.[klíč] ); // undefined

1-js/05-data-types/02-number/article.md

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,11 @@ Nyní zapišme něco velmi malého. Třeba 1 mikrosekundu (jednu milióntinu sek
4747
let mcs = 0.000001;
4848
```
4949

50+
<<<<<<< HEAD
5051
Stejně jako předtím nám může pomoci použití `"e"`. Jestliže se chceme vyhnout explicitnímu zápisu nul, můžeme zapsat totéž jako:
52+
=======
53+
Just like before, using `"e"` can help. If we'd like to avoid writing the zeroes explicitly, we could write the same as:
54+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
5155
5256
```js
5357
let mcs = 1e-6; // šest nul nalevo od 1
@@ -156,7 +160,11 @@ Existují dva způsoby, jak to udělat:
156160

157161
1. Násobit a dělit.
158162

163+
<<<<<<< HEAD
159164
Abychom například zaokrouhlili číslo na 2. číslici za desetinnou čárkou, můžeme toto číslo vynásobit `100` (nebo vyšší mocninou 10), zavolat zaokrouhlovací funkci a pak je znovu vydělit.
165+
=======
166+
For example, to round the number to the 2nd digit after the decimal, we can multiply the number by `100`, call the rounding function and then divide it back.
167+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
160168
```js run
161169
let číslo = 1.23456;
162170

@@ -184,21 +192,33 @@ Existují dva způsoby, jak to udělat:
184192
alert( číslo.toFixed(5) ); // "12.34000", přidají se nuly, aby číslic bylo přesně 5
185193
```
186194

195+
<<<<<<< HEAD
187196
Můžeme jej převést na číslo pomocí unárního plus nebo volání `Number()`: `+číslo.toFixed(5)`.
197+
=======
198+
We can convert it to a number using the unary plus or a `Number()` call, e.g write `+num.toFixed(5)`.
199+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
188200

189201
## Nepřesné výpočty
190202

191203
Číslo je vnitřně reprezentováno v 64-bitovém formátu [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision), takže se ukládá přesně do 64 bitů: 52 z nich se používá k uložení číslic, v 11 z nich je uložena pozice desetinné čárky (u celých čísel jsou tyto bity nulové) a 1 bit je pro znaménko.
192204

205+
<<<<<<< HEAD
193206
Je-li číslo příliš velké, překročí toto 64-bitové úložiště a stane se z něj nekonečno:
207+
=======
208+
If a number is really huge, it may overflow the 64-bit storage and become a special numeric value `Infinity`:
209+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
194210

195211
```js run
196212
alert( 1e500 ); // Infinity (nekonečno)
197213
```
198214

199215
Co může být trochu méně zřejmé, ale stává se poměrně často, je ztráta přesnosti.
200216

217+
<<<<<<< HEAD
201218
Uvažujme tento (nepravdivý!) test:
219+
=======
220+
Consider this (falsy!) equality test:
221+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
202222

203223
```js run
204224
alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
@@ -212,13 +232,21 @@ Zvláštní! Co tedy je, když ne `0.3`?
212232
alert( 0.1 + 0.2 ); // 0.30000000000000004
213233
```
214234

235+
<<<<<<< HEAD
215236
Ouvej! Tohle má větší důsledky než jen zdejší nekorektní porovnání. Představme si, že vytváříme elektronický obchod a návštěvník si do košíku uloží zboží za `$0.10` a za `$0.20`. Celková cena pak bude `$0.30000000000000004`. To každého překvapí.
237+
=======
238+
Ouch! Imagine you're making an e-shopping site and the visitor puts `$0.10` and `$0.20` goods into their cart. The order total will be `$0.30000000000000004`. That would surprise anyone.
239+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
216240

217241
Ale proč se to děje?
218242

219243
Číslo je v paměti uloženo ve své binární podobě, jako posloupnost bitů -- jedniček a nul. Ale desetinná čísla jako `0.1` nebo `0.2`, která v desítkové soustavě vypadají jednoduše, jsou ve své binární podobě ve skutečnosti nekonečná.
220244

245+
<<<<<<< HEAD
221246
Jinými slovy, co je `0.1`? Je to jedna děleno deseti `1/10`, jedna desetina. V desítkové soustavě lze taková čísla snadno reprezentovat. Srovnejme si to s jednou třetinou: `1/3`. Z ní se stane nekonečné desetinné číslo `0.33333(3)`.
247+
=======
248+
What is `0.1`? It is one divided by ten `1/10`, one-tenth. In decimal numeral system such numbers are easily representable. Compare it to one-third: `1/3`. It becomes an endless fraction `0.33333(3)`.
249+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
222250

223251
Je tedy zaručeno, že dělení mocninami `10` bude v desítkové soustavě fungovat dobře, ale dělení třemi ne. Ze stejného důvodu je v binární soustavě zaručeno, že bude fungovat dělení mocninami `2`, ale z `1/10` se stane nekonečné binární číslo.
224252

1-js/09-classes/03-static-properties-methods/article.md

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,15 @@
11

22
# Statické vlastnosti a metody
33

4+
<<<<<<< HEAD
45
Metodu můžeme přiřadit samotné funkci třídy namísto jejímu `„prototype"`. Takové metody se nazývají *statické*.
56

67
Ve třídě jsou předznamenány klíčovým slovem `static`, například:
8+
=======
9+
We can also assign a method to the class as a whole. Such methods are called *static*.
10+
11+
In a class declaration, they are prepended by `static` keyword, like this:
12+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
713
814
```js run
915
class Uživatel {
@@ -31,9 +37,17 @@ Uživatel.statickáMetoda(); // true
3137

3238
Hodnota `this` ve volání `Uživatel.statickáMetoda()` je samotný třídní konstruktor `Uživatel` (podle pravidla „objekt před tečkou“).
3339

40+
<<<<<<< HEAD
3441
Statické metody se obvykle používají k implementaci funkcí, které patří třídě, ale žádnému jejímu konkrétnímu objektu.
3542

3643
Například máme objekty třídy `Článek` a potřebujeme funkci, která je bude porovnávat. Přirozené řešení by bylo přidat metodu `Článek.porovnej`, například:
44+
=======
45+
Usually, static methods are used to implement functions that belong to the class as a whole, but not to any particular object of it.
46+
47+
For instance, we have `Article` objects and need a function to compare them.
48+
49+
A natural solution would be to add `Article.compare` static method:
50+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
3751
3852
```js run
3953
class Článek {
@@ -63,17 +77,29 @@ let články = [
6377
alert( články[0].titulek ); // CSS
6478
```
6579

80+
<<<<<<< HEAD
6681
Zde metoda `Článek.porovnej` stojí „nad“ články jako způsob jejich porovnávání. Není to metoda článku, ale metoda celé třídy.
6782

6883
Jiným příkladem může být tzv. „tovární“ metoda. Představme si, že potřebujeme několik způsobů, jak vytvořit článek:
84+
=======
85+
Here `Article.compare` method stands "above" articles, as a means to compare them. It's not a method of an article, but rather of the whole class.
86+
87+
Another example would be a so-called "factory" method.
88+
89+
Let's say, we need multiple ways to create an article:
90+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
6991
7092
1. Vytvořit jej ze zadaných parametrů (`titulek`, `datum` atd.).
7193
2. Vytvořit prázdný článek s dnešním datem.
7294
3. ...nebo nějak jinak.
7395

7496
První způsob můžeme implementovat konstruktorem. A pro druhý můžeme vytvořit statickou metodu třídy.
7597

98+
<<<<<<< HEAD
7699
Například `Článek.vytvořDnešní()` zde:
100+
=======
101+
Such as `Article.createTodays()` here:
102+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
77103
78104
```js run
79105
class Článek {
@@ -100,9 +126,15 @@ Nyní pokaždé, když budeme potřebovat vytvořit dnešní přehled, můžeme
100126
Statické metody se také používají ve třídách vztažených k databázím pro hledání/ukládání/odstraňování záznamů z databáze, například:
101127

102128
```js
129+
<<<<<<< HEAD
103130
// předpokládejme, že Článek je speciální třída pro práci s články
104131
// statická metoda pro odstranění článku:
105132
Článek.odstraň({id: 12345});
133+
=======
134+
// assuming Article is a special class for managing articles
135+
// static method to remove the article by id:
136+
Article.remove({id: 12345});
137+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
106138
```
107139

108140
## Statické vlastnosti

0 commit comments

Comments
 (0)