You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Měli bychom používat `?.` jen tehdy, když je v pořádku, že něco neexistuje.
110
110
111
+
<<<<<<<HEAD
111
112
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`.
112
113
113
114
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
114
120
```
115
121
116
122
````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
127
133
128
134
Jak bylo řečeno, `?.` okamžitě pozastaví („vyzkratuje“) vyhodnocování, jestliže levá část neexistuje.
129
135
136
+
<<<<<<< HEAD
130
137
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
131
141
132
142
Například:
133
143
134
144
```js run
135
145
let uživatel = null;
136
146
let x = 0;
137
147
148
+
<<<<<<< HEAD
138
149
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++
Copy file name to clipboardExpand all lines: 1-js/05-data-types/02-number/article.md
+28Lines changed: 28 additions & 0 deletions
Original file line number
Diff line number
Diff line change
@@ -47,7 +47,11 @@ Nyní zapišme něco velmi malého. Třeba 1 mikrosekundu (jednu milióntinu sek
47
47
let mcs =0.000001;
48
48
```
49
49
50
+
<<<<<<< HEAD
50
51
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
51
55
52
56
```js
53
57
let mcs =1e-6; // šest nul nalevo od 1
@@ -156,7 +160,11 @@ Existují dva způsoby, jak to udělat:
156
160
157
161
1.Násobit a dělit.
158
162
163
+
<<<<<<<HEAD
159
164
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
160
168
```js run
161
169
let číslo = 1.23456;
162
170
@@ -184,21 +192,33 @@ Existují dva způsoby, jak to udělat:
184
192
alert( číslo.toFixed(5) ); // "12.34000", přidají se nuly, aby číslic bylo přesně 5
185
193
```
186
194
195
+
<<<<<<< HEAD
187
196
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
188
200
189
201
## Nepřesné výpočty
190
202
191
203
Čí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.
192
204
205
+
<<<<<<< HEAD
193
206
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
194
210
195
211
```js run
196
212
alert( 1e500 ); // Infinity (nekonečno)
197
213
```
198
214
199
215
Co může být trochu méně zřejmé, ale stává se poměrně často, je ztráta přesnosti.
200
216
217
+
<<<<<<< HEAD
201
218
Uvažujme tento (nepravdivý!) test:
219
+
=======
220
+
Consider this (falsy!) equality test:
221
+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
202
222
203
223
```js run
204
224
alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
@@ -212,13 +232,21 @@ Zvláštní! Co tedy je, když ne `0.3`?
212
232
alert( 0.1 + 0.2 ); // 0.30000000000000004
213
233
```
214
234
235
+
<<<<<<< HEAD
215
236
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
216
240
217
241
Ale proč se to děje?
218
242
219
243
Čí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á.
220
244
245
+
<<<<<<< HEAD
221
246
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
222
250
223
251
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.
Hodnota `this` ve volání `Uživatel.statickáMetoda()` je samotný třídní konstruktor `Uživatel` (podle pravidla „objekt před tečkou“).
33
39
40
+
<<<<<<< HEAD
34
41
Statické metody se obvykle používají k implementaci funkcí, které patří třídě, ale žádnému jejímu konkrétnímu objektu.
35
42
36
43
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
37
51
38
52
```js run
39
53
class Článek {
@@ -63,17 +77,29 @@ let články = [
63
77
alert( články[0].titulek ); // CSS
64
78
```
65
79
80
+
<<<<<<< HEAD
66
81
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.
67
82
68
83
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
69
91
70
92
1. Vytvořit jej ze zadaných parametrů (`titulek`, `datum` atd.).
71
93
2. Vytvořit prázdný článek s dnešním datem.
72
94
3. ...nebo nějak jinak.
73
95
74
96
První způsob můžeme implementovat konstruktorem. A pro druhý můžeme vytvořit statickou metodu třídy.
75
97
98
+
<<<<<<< HEAD
76
99
Například `Článek.vytvořDnešní()` zde:
100
+
=======
101
+
Such as `Article.createTodays()` here:
102
+
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
77
103
78
104
```js run
79
105
class Článek {
@@ -100,9 +126,15 @@ Nyní pokaždé, když budeme potřebovat vytvořit dnešní přehled, můžeme
100
126
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:
101
127
102
128
```js
129
+
<<<<<<<HEAD
103
130
// předpokládejme, že Článek je speciální třída pro práci s články
104
131
// statická metoda pro odstranění článku:
105
132
Článek.odstraň({id:12345});
133
+
=======
134
+
// assuming Article is a special class for managing articles
0 commit comments