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
112
111
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`.
113
112
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
113
+
Pak pokud se stane, že `uživatel` bude nedefinovaný, ohlásí se programátorská chyba a my ji opravíme. Kdybychom však přehnaně používali `?.`, mohly by se chyby v kódu neohlásit i tehdy, když to není vhodné, a jejich ladění by bylo obtížnější.
120
114
```
121
115
122
116
````warn header="Proměnná před `?.` musí být deklarovaná"
123
117
Pokud proměnná `uživatel` vůbec neexistuje, pak `uživatel?.cokoli` ohlásí chybu:
124
118
125
119
```js run
126
-
// ReferenceError: uživatel is not defined
120
+
// ReferenceError: uživatel není definován
127
121
uživatel?.adresa;
128
122
```
129
123
Proměnná musí být deklarovaná (tj. `let/const/varuživatel` nebojakoparametrfunkce). Volitelné zřetězení fungujejenprodeklarované proměnné.
@@ -133,23 +127,15 @@ Proměnná musí být deklarovaná (tj. `let/const/var uživatel` nebo jako para
133
127
134
128
Jak bylo řečeno, `?.` okamžitě pozastaví („vyzkratuje“) vyhodnocování, jestliže levá část neexistuje.
135
129
136
-
<<<<<<< HEAD
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
130
+
Jestliže tedy za pozastaveným `?.` vpravo následují další volání funkcí nebo operace, nevykonají se.
141
131
142
132
Například:
143
133
144
134
```js run
145
135
let uživatel = null;
146
136
let x = 0;
147
137
148
-
<<<<<<< HEAD
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++
152
-
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
138
+
uživatel?.řekniAhoj(x++); // „uživatel“ není, takže výkon se nedostane k volání řekniAhoj a x++
Copy file name to clipboardExpand all lines: 1-js/05-data-types/02-number/article.md
+7-34Lines changed: 7 additions & 34 deletions
Original file line number
Diff line number
Diff line change
@@ -47,11 +47,7 @@ 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
51
50
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
55
51
56
52
```js
57
53
let mcs =1e-6; // šest nul nalevo od 1
@@ -160,11 +156,8 @@ Existují dva způsoby, jak to udělat:
160
156
161
157
1.Násobit a dělit.
162
158
163
-
<<<<<<<HEAD
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
159
+
Abychom například zaokrouhlili číslo na 2. číslici za desetinnou čárkou, můžeme toto číslo vynásobit `100`, zavolat zaokrouhlovací funkci a pak je znovu vydělit.
160
+
168
161
```js run
169
162
let číslo = 1.23456;
170
163
@@ -192,33 +185,21 @@ Existují dva způsoby, jak to udělat:
192
185
alert( číslo.toFixed(5) ); // "12.34000", přidají se nuly, aby číslic bylo přesně 5
193
186
```
194
187
195
-
<<<<<<< HEAD
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
+
Můžeme jej převést na číslo pomocí unárního plus nebo volání `Number()`, např. napsat`+číslo.toFixed(5)`.
200
189
201
190
## Nepřesné výpočty
202
191
203
192
Čí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.
204
193
205
-
<<<<<<< HEAD
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
+
Je-li číslo opravdu obrovské, může toto 64-bitové úložiště překročit a stát se speciální číselnou hodnotou `Infinity` (nekonečno):
210
195
211
196
```js run
212
197
alert( 1e500 ); // Infinity (nekonečno)
213
198
```
214
199
215
200
Co může být trochu méně zřejmé, ale stává se poměrně často, je ztráta přesnosti.
216
201
217
-
<<<<<<< HEAD
218
-
Uvažujme tento (nepravdivý!) test:
219
-
=======
220
-
Consider this (falsy!) equality test:
221
-
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
202
+
Uvažujme tento (nepravdivý!) test rovnosti:
222
203
223
204
```js run
224
205
alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!*
@@ -232,21 +213,13 @@ Zvláštní! Co tedy je, když ne `0.3`?
232
213
alert( 0.1 + 0.2 ); // 0.30000000000000004
233
214
```
234
215
235
-
<<<<<<< HEAD
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
+
Ouvej!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í.
240
217
241
218
Ale proč se to děje?
242
219
243
220
Čí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á.
244
221
245
-
<<<<<<< HEAD
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
+
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)`.
250
223
251
224
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“).
39
33
40
-
<<<<<<< HEAD
41
-
Statické metody se obvykle používají k implementaci funkcí, které patří třídě, ale žádnému jejímu konkrétnímu objektu.
42
-
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.
34
+
Statické metody se obvykle používají k implementaci funkcí, které patří třídě jako celku, ale nepatří žádnému jejímu konkrétnímu objektu.
46
35
47
-
For instance, we have `Article` objects and need a function to compare them.
36
+
Například máme objekty třídy `Článek` a potřebujeme funkci, která je bude porovnávat.
48
37
49
-
A natural solution would be to add `Article.compare` static method:
50
-
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
38
+
Přirozené řešení by bylo přidat statickou metodu `Článek.porovnej`:
51
39
52
40
```js run
53
41
class Článek {
@@ -77,29 +65,19 @@ let články = [
77
65
alert( články[0].titulek ); // CSS
78
66
```
79
67
80
-
<<<<<<< HEAD
81
68
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.
82
69
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.
70
+
Jiným příkladem může být tzv. „tovární“ metoda.
88
71
89
-
Let's say, we need multiple ways to create an article:
90
-
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
72
+
Dejme tomu, že potřebujeme více způsobů, jak vytvořit článek:
91
73
92
74
1. Vytvořit jej ze zadaných parametrů (`titulek`, `datum` atd.).
93
75
2. Vytvořit prázdný článek s dnešním datem.
94
76
3. ...nebo nějak jinak.
95
77
96
78
První způsob můžeme implementovat konstruktorem. A pro druhý můžeme vytvořit statickou metodu třídy.
97
79
98
-
<<<<<<< HEAD
99
80
Například `Článek.vytvořDnešní()` zde:
100
-
=======
101
-
Such as `Article.createTodays()` here:
102
-
>>>>>>> 741d90ce8a730d66e987bff5e9794d6e41cb2f05
103
81
104
82
```js run
105
83
class Článek {
@@ -126,15 +104,9 @@ Nyní pokaždé, když budeme potřebovat vytvořit dnešní přehled, můžeme
126
104
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:
127
105
128
106
```js
129
-
<<<<<<<HEAD
130
107
// předpokládejme, že Článek je speciální třída pro práci s články
131
-
// statická metoda pro odstranění článku:
108
+
// statická metoda pro odstranění článku podle jeho id:
132
109
Článek.odstraň({id:12345});
133
-
=======
134
-
// assuming Article is a special class for managing articles
0 commit comments