Skip to content

Commit 6dc5032

Browse files
authored
Merge pull request #116 from javascript-tutorial/sync-1edb0a38
Sync with upstream @ 1edb0a3
2 parents b6ec721 + d8de43c commit 6dc5032

File tree

23 files changed

+115
-54
lines changed

23 files changed

+115
-54
lines changed

1-js/01-getting-started/1-intro/article.md

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ Výše uvedené pojmy je dobré si pamatovat, protože se používají ve vývoj
3535
Enginy jsou složité, ale jejich základy jsou jednoduché.
3636
3737
1. Engine (v případě prohlížeče zahrnutý do něj) načte („rozebere“, „parsuje“) skript.
38-
2. Pak přeloží („zkompiluje“) skript do strojového jazyka.
38+
2. Pak přeloží („zkompiluje“) skript do strojového kódu.
3939
3. A pak se strojový kód hezky rychle spustí.
4040
4141
Při každém kroku procesu engine aplikuje optimalizace. Dokonce sleduje, jak zkompilovaný skript běží, analyzuje data, která jím protékají, a podle těchto znalostí dále optimalizuje strojový kód.
@@ -59,7 +59,7 @@ Například JavaScript v prohlížeči může:
5959

6060
## Co NEMŮŽE JavaScript v prohlížeči dělat?
6161

62-
Schopnosti JavaScriptu v prohlížeči jsou omezeny v zájmu bezpečnosti uživatele. Cílem je zabránit zlé webové stránce v přístupu k soukromým informacím nebo v poškození uživatelových dat.
62+
Schopnosti JavaScriptu v prohlížeči jsou omezeny, aby byla chráněna bezpečnost uživatele. Cílem je zabránit zlé webové stránce v přístupu k soukromým informacím nebo v poškození uživatelových dat.
6363

6464
Příklady takových omezení:
6565

@@ -70,9 +70,9 @@ Příklady takových omezení:
7070
Existují způsoby, jak komunikovat s kamerou, mikrofonem nebo jinými zařízeními, ale ty vyžadují výslovné svolení uživatele. Stránka s povoleným JavaScriptem tedy nemůže bez vědomí uživatele zapnout webovou kameru, nasnímat okolí a nahrávku poslat do [NSA](https://cs.wikipedia.org/wiki/Národní_bezpečnostní_agentura).
7171
- Různé záložky a okna o sobě navzájem obvykle nevědí. Někdy ano, například tehdy, když jedno okno používá JavaScript k otevření druhého. Ale ani v tomto případě JavaScript z jedné stránky nemůže přistupovat k jiné, pokud pocházejí z různých webových sídel (z jiné domény, protokolu nebo portu).
7272

73-
Tento postup se nazývá „politika stejného původu“. Je možné ji obejít tak, že *obě stránky* souhlasí s výměnou dat a obsahují speciální JavaScriptový kód, který to umožňuje. V tomto tutoriálu to budeme probírat.
73+
Tento postup se nazývá „politika stejného původu“. Je možné ji obejít tak, že *obě stránky* musí souhlasit s výměnou dat a musí obsahovat speciální JavaScriptový kód, který to umožňuje. V tomto tutoriálu to budeme probírat.
7474

75-
Toto omezení je zde opět pro bezpečnost uživatele. Stránka z `http://anysite.com`, kterou uživatel otevřel, nesmí mít možnost přistupovat k jiné záložce prohlížeče s URL `http://gmail.com` a krást odtamtud informace.
75+
Toto omezení je zde opět pro bezpečnost uživatele. Stránka z `http://anysite.com`, kterou uživatel otevřel, nesmí mít možnost přistupovat k jiné záložce prohlížeče s URL například `http://gmail.com` a krást odtamtud informace.
7676
- JavaScript může jednoduše komunikovat po síti se serverem, z něhož přišla aktuální stránka, ale jeho schopnost získávat data z jiných sídel/domén je značně omezená. Přestože je to možné, vyžaduje to výslovný souhlas (uvedený v HTTP hlavičce) vzdálené strany. I to je bezpečnostní omezení.
7777

7878
![](limitations.svg)
@@ -92,7 +92,7 @@ JavaScript je jediná prohlížečová technologie, která má všechny tyto tř
9292

9393
To vše činí JavaScript unikátním. To vše je důvodem, proč je dnes nejrozšířenějším nástrojem pro vytváření prohlížečových rozhraní.
9494

95-
Při tom všem však JavaScript umožňuje vytvářet i servery, mobilní aplikace a podobně.
95+
Při tom všem však lze JavaScript použít i k vytváření serverů, mobilních aplikací a podobně.
9696

9797
## Jazyky „nad“ JavaScriptem
9898

@@ -113,7 +113,7 @@ Příklady takových jazyků:
113113
- [Brython](https://brython.info/) je transpiler Pythonu do JavaScriptu, který umožňuje psát aplikace v čistém Pythonu bez JavaScriptu.
114114
- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) je moderní, stručný a bezpečný programovací jazyk, jehož cílem může být prohlížeč nebo Node.
115115

116-
Jsou i další. Samozřejmě i když používáme některý z transpilovaných jazyků, měli bychom znát i JavaScript, abychom skutečně porozuměli tomu, co se děje.
116+
Jsou i další. Samozřejmě i když používáme některý z těchto transpilovaných jazyků, měli bychom znát i JavaScript, abychom skutečně porozuměli tomu, co se děje.
117117

118118
## Shrnutí
119119

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ Pravidla pro konverzi na číslo:
7070
|`undefined`|`NaN`|
7171
|`null`|`0`|
7272
|<code>true</code>&nbsp;a&nbsp;<code>false</code> | `1` a `0` |
73-
| `ř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`. |
73+
| `řetězec` | Odstraní se bílé znaky (mezery, tabulátory `\t`, konce řádku `\n` atd.) 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`. |
7474

7575
Příklady:
7676

@@ -130,7 +130,7 @@ Konverze se řídí těmito pravidly:
130130
|`undefined`|`NaN`|
131131
|`null`|`0`|
132132
|<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
133-
| `ř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`. |
133+
| `řetězec` | Načte se „doslovně“, bílé znaky (mezery, tabulátory `\t`, konce řádku `\n` atd.) na obou stranách se ignorují. Z prázdného řetězce se stane `0`. Při chybě je vydáno `NaN`. |
134134
135135
**`Konverze na boolean`** -- Nastává při logických operacích. Můžeme ji provést pomocí `Boolean(hodnota)`.
136136

1-js/02-first-steps/08-operators/article.md

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -195,18 +195,18 @@ Následuje výtažek z [tabulky priorit](https://developer.mozilla.org/en-US/doc
195195
| Priorita | Název | Znak |
196196
|----------|-------|------|
197197
| ... | ... | ... |
198-
| 15 | unární plus | `+` |
199-
| 15 | unární negace | `-` |
200-
| 14 | umocňování | `**` |
201-
| 13 | násobení | `*` |
202-
| 13 | dělení | `/` |
203-
| 12 | sčítání | `+` |
204-
| 12 | odčítání | `-` |
198+
| 14 | unární plus | `+` |
199+
| 14 | unární negace | `-` |
200+
| 13 | umocňování | `**` |
201+
| 12 | násobení | `*` |
202+
| 12 | dělení | `/` |
203+
| 11 | sčítání | `+` |
204+
| 11 | odčítání | `-` |
205205
| ... | ... | ... |
206206
| 2 | přiřazení | `=` |
207207
| ... | ... | ... |
208208

209-
Jak vidíme, „unární plus“ má prioritu `15`, která je vyšší než priorita `12` „sčítání“ (binární plus). To je důvod, proč se ve výrazu `"+jablka + +pomeranče"` unární plusy vyhodnotí před sčítáním.
209+
Jak vidíme, „unární plus“ má prioritu `14`, která je vyšší než priorita `11` „sčítání“ (binární plus). To je důvod, proč se ve výrazu `"+jablka + +pomeranče"` unární plusy vyhodnotí před sčítáním.
210210

211211
## Přiřazení
212212

@@ -304,9 +304,9 @@ Tyto operátory mají stejnou prioritu jako běžné přiřazení, takže se pro
304304
```js run
305305
let n = 2;
306306
307-
n *= 3 + 5;
307+
n *= 3 + 5; // napřed se provede část vpravo, totéž jako n *= 8
308308
309-
alert( n ); // 16 (napřed se provede část vpravo, totéž jako n *= 8)
309+
alert( n ); // 16
310310
```
311311

312312
## Inkrementace a dekrementace

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -105,7 +105,7 @@ V praxi je nulová výška často platnou hodnotou, takže by neměla být nahra
105105
106106
## Priorita
107107
108-
Priorita operátoru `??` je stejná jako `||`. Oba operátory mají v [tabulce MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) prioritu `4`.
108+
Priorita operátoru `??` je stejná jako `||`. Oba operátory mají v [tabulce MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) prioritu `3`.
109109
110110
To znamená, že operátor koalescence `??` se stejně jako `||` vyhodnocuje před `=` a `?`, ale až po většině ostatních operací, například `+`, `*`.
111111

1-js/02-first-steps/15-function-basics/article.md

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ Napřed je uvedeno klíčové slovo `function`, pak *název funkce*, potom máme
2424

2525
```js
2626
functionzev(parametr1, parametr2, ... parametrN) {
27-
...tělo...
27+
// tělo
2828
}
2929
```
3030

@@ -209,6 +209,12 @@ zobrazZprávu("Anna"); // Anna: text není zadán
209209
210210
Jestliže argument k parametru `text` nebude předán, bude mít hodnotu `"text není zadán"`.
211211
212+
Výchozí hodnota bude nastavena i tehdy, když parametr existuje, ale je striktně roven `undefined`, například:
213+
214+
```js
215+
showMessage("Anna", undefined); // Anna: text není zadán
216+
```
217+
212218
Zde `"text není zadán"` je řetězec, ale může to být složitější výraz, který se vyhodnotí a přiřadí jen tehdy, jestliže argument chybí. Je tedy možné i toto:
213219
214220
```js run

1-js/03-code-quality/05-testing-mocha/article.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ So, the development is *iterative*. We write the spec, implement it, make sure t
7979

8080
Let's see this development flow in our practical case.
8181

82-
The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
82+
The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use a few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
8383

8484
## The spec in action
8585

1-js/04-object-basics/09-object-toprimitive/article.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -136,8 +136,8 @@ As we can see from the code, `user` becomes a self-descriptive string or a money
136136

137137
If there's no `Symbol.toPrimitive` then JavaScript tries to find methods `toString` and `valueOf`:
138138

139-
- For the `"string"` hint: call `toString` method, and if it doesn't exist, then `valueOf` (so `toString` has the priority for string conversions).
140-
- For other hints: `valueOf`, and if it doesn't exist, then `toString` (so `valueOf` has the priority for maths).
139+
- For the `"string"` hint: call `toString` method, and if it doesn't exist or if it returns an object instead of a primitive value, then call `valueOf` (so `toString` has the priority for string conversions).
140+
- For other hints: call `valueOf`, and if it doesn't exist or if it returns an object instead of a primitive value, then call `toString` (so `valueOf` has the priority for maths).
141141

142142
Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
143143

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

Lines changed: 34 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -334,15 +334,44 @@ alert( isFinite(num) );
334334

335335
Please note that an empty or a space-only string is treated as `0` in all numeric functions including `isFinite`.
336336

337-
```smart header="Compare with `Object.is`"
337+
````smart header="`Number.isNaN` and `Number.isFinite`"
338+
[Number.isNaN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN) and [Number.isFinite](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite) methods are the more "strict" versions of `isNaN` and `isFinite` functions. They do not autoconvert their argument into a number, but check if it belongs to the `number` type instead.
339+
340+
- `Number.isNaN(value)` returns `true` if the argument belongs to the `number` type and it is `NaN`. In any other case it returns `false`.
341+
342+
```js run
343+
alert( Number.isNaN(NaN) ); // true
344+
alert( Number.isNaN("str" / 2) ); // true
345+
346+
// Note the difference:
347+
alert( Number.isNaN("str") ); // false, because "str" belongs to the string type, not the number type
348+
alert( isNaN("str") ); // true, because isNaN converts string "str" into a number and gets NaN as a result of this conversion
349+
```
350+
351+
- `Number.isFinite(value)` returns `true` if the argument belongs to the `number` type and it is not `NaN/Infinity/-Infinity`. In any other case it returns `false`.
352+
353+
```js run
354+
alert( Number.isFinite(123) ); // true
355+
alert( Number.isFinite(Infinity) ); //false
356+
alert( Number.isFinite(2 / 0) ); // false
357+
358+
// Note the difference:
359+
alert( Number.isFinite("123") ); // false, because "123" belongs to the string type, not the number type
360+
alert( isFinite("123") ); // true, because isFinite converts string "123" into a number 123
361+
```
362+
363+
In a way, `Number.isNaN` and `Number.isFinite` are simpler and more straightforward than `isNaN` and `isFinite` functions. In practice though, `isNaN` and `isFinite` are mostly used, as they're shorter to write.
364+
````
365+
366+
```smart header="Comparison with `Object.is`"
338367
There is a special built-in method `Object.is` that compares values like `===`, but is more reliable for two edge cases:
339368

340369
1. It works with `NaN`: `Object.is(NaN, NaN) === true`, that's a good thing.
341370
2. Values `0` and `-0` are different: `Object.is(0, -0) === false`, technically that's true, because internally the number has a sign bit that may be different even if all other bits are zeroes.
342371

343372
In all other cases, `Object.is(a, b)` is the same as `a === b`.
344373

345-
This way of comparison is often used in JavaScript specification. When an internal algorithm needs to compare two values for being exactly the same, it uses `Object.is` (internally called [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)).
374+
We mention `Object.is` here, because it's often used in JavaScript specification. When an internal algorithm needs to compare two values for being exactly the same, it uses `Object.is` (internally called [SameValue](https://tc39.github.io/ecma262/#sec-samevalue)).
346375
```
347376

348377

@@ -435,7 +464,9 @@ For different numeral systems:
435464
For regular number tests:
436465

437466
- `isNaN(value)` converts its argument to a number and then tests it for being `NaN`
438-
- `isFinite(value)` converts its argument to a number and returns `true` if it's a regular number, not `NaN/Infinity/-Infinity`
467+
- `Number.isNaN(value)` checks whether its argument belongs to the `number` type, and if so, tests it for being `NaN`
468+
- `isFinite(value)` converts its argument to a number and then tests it for not being `NaN/Infinity/-Infinity`
469+
- `Number.isFinite(value)` checks whether its argument belongs to the `number` type, and if so, tests it for not being `NaN/Infinity/-Infinity`
439470

440471
For converting values like `12pt` and `100px` to a number:
441472

1-js/05-data-types/03-string/article.md

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -445,6 +445,8 @@ There are 3 methods in JavaScript to get a substring: `substring`, `substr` and
445445
alert( str.substr(-4, 2) ); // 'gi', from the 4th position get 2 characters
446446
```
447447

448+
This method resides in the [Annex B](https://tc39.es/ecma262/#sec-string.prototype.substr) of the language specification. It means that only browser-hosted Javascript engines should support it, and it's not recommended to use it. In practice, it's supported everywhere.
449+
448450
Let's recap these methods to avoid any confusion:
449451

450452
| method | selects... | negatives |

1-js/05-data-types/05-array-methods/article.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -262,8 +262,8 @@ The method [arr.lastIndexOf](mdn:js/Array/lastIndexOf) is the same as `indexOf`,
262262
```js run
263263
let fruits = ['Apple', 'Orange', 'Apple']
264264

265-
alert( arr.indexOf('Apple') ); // 0 (first Apple)
266-
alert( arr.lastIndexOf('Apple') ); // 2 (last Apple)
265+
alert( fruits.indexOf('Apple') ); // 0 (first Apple)
266+
alert( fruits.lastIndexOf('Apple') ); // 2 (last Apple)
267267
```
268268

269269
````smart header="The `includes` method handles `NaN` correctly"

0 commit comments

Comments
 (0)