Merge pull request #147 from javascript-tutorial/sync-b258d7d5

Sync with upstream @ b258d7d

Author: otmon76

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: iliakan

1-js/02-first-steps/04-variables/article.md

@@ -88,16 +88,26 @@ Ve starších skriptech můžete najít i jiné klíčové slovo: `var` namísto
 *!*var*/!* zpráva = 'Ahoj';
 ```
 
+<<<<<<< HEAD
 Klíčové slovo `var` znamená *skoro* totéž jako `let`. Rovněž deklaruje proměnnou, ale trochu jiným, „staroškolským“ způsobem.
 
 Mezi `let` a `var` existují drobné rozdíly, ale ty nás zatím nezajímají. Podrobně je probereme v kapitole <info:var>.
+=======
+The `var` keyword is *almost* the same as `let`. It also declares a variable but in a slightly different, "old-school" way.
+
+There are subtle differences between `let` and `var`, but they do not matter to us yet. We'll cover them in detail in the chapter <info:var>.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 ````
 
 ## Analogie s reálným životem
 
 Koncept „proměnné“ můžeme snadno pochopit, když si ji představíme jako „krabičku“ na data, na níž je nalepen štítek s unikátním názvem.
 
+<<<<<<< HEAD
 Například proměnnou `zpráva` si můžeme představit jako krabičku se štítkem `"zpráva"`, v níž je hodnota `"Ahoj!"`:
+=======
+For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 ![](variable.svg)
 
@@ -197,15 +207,24 @@ let moje-jméno; // spojovník '-' není v názvu povolen
 Proměnné s názvy `jablko` a `JABLKO` jsou dvě různé proměnné.
 ```
 
+<<<<<<< HEAD
 ````smart header="Nelatinská písmena jsou povolena, ale nedoporučují se"
 Je dovoleno použít písmena z jakéhokoli jazyka, včetně písmen z kyrilice, čínských znaků a podobně, třeba takto:
+=======
+````smart header="Non-Latin letters are allowed, but not recommended"
+It is possible to use any language, including Cyrillic letters, Chinese logograms and so on, like this:
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
+<<<<<<< HEAD
 Technicky zde není žádná chyba. Takové názvy jsou povoleny, ale podle mezinárodní konvence se v názvech proměnných používá angličtina. I když píšeme malý skript, může mít před sebou dlouhý život a lidé z jiných zemí si ho možná někdy budou potřebovat přečíst.
+=======
+Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it sometime.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 ````
 
 ````warn header="Rezervované názvy"
@@ -260,11 +279,19 @@ const mojeDatumNarození = '18.04.1982';
 mojeDatumNarození = '01.01.2001'; // chyba, nelze změnit konstantu!
 ```
 
+<<<<<<< HEAD
 Když má programátor jistotu, že hodnota proměnné se nikdy nezmění, může ji deklarovat pomocí `const`, aby tuto skutečnost pojistil a všem jasně sdělil.
+=======
+When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and communicate that fact to everyone.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 ### Konstanty velkými písmeny
 
+<<<<<<< HEAD
 Je široce rozšířenou praktikou používat konstanty jako názvy obtížně zapamatovatelných hodnot, které jsou známy ještě před spuštěním programu.
+=======
+There is a widespread practice to use constants as aliases for difficult-to-remember values that are known before execution.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 Názvy takových konstant se uvádějí velkými písmeny a s podtržítky.
 
@@ -289,15 +316,23 @@ Výhody:
 
 Kdy bychom měli používat pro konstantu velká písmena a kdy bychom ji měli pojmenovat obvyklým způsobem? Ujasníme si to.
 
+<<<<<<< HEAD
 Být „konstanta“ znamená prostě to, že hodnota proměnné se nikdy nezmění. Existují však konstanty, které jsou známy již před spuštěním programu (například hexadecimální hodnota červené barvy), a pak jsou konstanty, které se *vypočítají* až za běhu programu, ale jejich vypočtená hodnota se nikdy nezmění.
+=======
+Being a "constant" just means that a variable's value never changes. But some constants are known before execution (like a hexadecimal value for red) and some constants are *calculated* in run-time, during the execution, but do not change after their initial assignment.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 Příklad:
 
 ```js
 const dobaNačítáníStránky = /* doba, kterou trvá načíst webovou stránku */;
 ```
 
+<<<<<<< HEAD
 Hodnota proměnné `dobaNačítáníStránky` není známa dříve, než se stránka načte, proto je pojmenována obvyklým způsobem. Je to však konstanta, protože se po přiřazení již nezmění.
+=======
+The value of `pageLoadTime` is not known before the page load, so it's named normally. But it's still a constant because it doesn't change after the assignment.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 Jinými slovy, názvy konstant zapsané velkými písmeny se používají jen pro pojmenování „natvrdo uvedených“ hodnot.
 
@@ -307,18 +342,31 @@ Když už mluvíme o proměnných, je tady jedna velice důležitá věc.
 
 Název proměnné by měl mít jasný a jednoznačný význam a měl by popisovat data, která jsou v proměnné uložena.
 
+<<<<<<< HEAD
 Pojmenovávání proměnných je jednou z nejdůležitějších a nejsložitějších dovedností v programování. Rychlý pohled na názvy proměnných nám může prozradit, zda kód psal začátečník nebo zkušený vývojář.
 
 V reálných projektech většinu času nezabere psaní něčeho úplně nového od základů, ale úprava a rozšiřování již existujícího kódu. Když se vrátíme k nějakému kódu poté, co jsme nějakou dobu dělali něco jiného, je mnohem jednodušší najít potřebné informace, když jsou vhodně pojmenovány. Nebo, jinými slovy, když proměnné mají vhodné názvy.
+=======
+Variable naming is one of the most important and complex skills in programming. A glance at variable names can reveal which code was written by a beginner versus an experienced developer.
+
+In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 Než deklarujete proměnnou, dobře si promyslete její název. Bohatě se vám to vyplatí.
 
 Některá pravidla, která je vhodné dodržovat, jsou:
 
+<<<<<<< HEAD
 - Používejte názvy čitelné člověkem, například `uživatelskéJméno` nebo `nákupníVozík`.
 - Zdržte se zkratek nebo krátkých názvů typu `a`, `b`, `c`, leda že byste opravdu dobře věděli, co děláte.
 - Volte názvy co nejpopisnější a nejstručnější. Příklady špatných názvů jsou `data` nebo `hodnota`. Takové názvy nic neříkají. Je vhodné je používat jen tehdy, když je z kontextu kódu naprosto zřejmé, jaká data nebo hodnota se v proměnné nachází.
 - Dohodněte se na pojmech se svým týmem a promyslete si je. Jestliže se návštěvník stránky nazývá „uživatel“, pak byste příslušné proměnné měli pojmenovat `aktuálníUživatel` nebo `novýUživatel`, a ne `aktuálníNávštěvník` nebo `novýPánVeMěstě`.
+=======
+- Use human-readable names like `userName` or `shoppingCart`.
+- Stay away from abbreviations or short names like `a`, `b`, and `c`, unless you know what you're doing.
+- Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
+- Agree on terms within your team and in your mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 Zní to jednoduše? Bezpochyby ano, ale vytvářet popisné a stručné názvy proměnných v praxi jednoduché není.
 

1-js/02-first-steps/05-types/article.md

@@ -95,13 +95,17 @@ const bigInt = 1234567890123456789012345678901234567890n;
 
 Protože čísla typu `BigInt` potřebujeme jen málokdy, nebudeme je tady probírat, ale věnujeme jim zvláštní kapitolu <info:bigint>. Až budete tak velká čísla potřebovat, přečtěte si ji.
 
+<<<<<<< HEAD
 ```smart header="Otázka kompatibility"
 Právě nyní je `BigInt` podporován ve Firefoxu/Chrome/Edge/Safari, ale ne v IE.
 ```
 
 Nahlédnutím do [*MDN* tabulky kompatibility pro BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) zjistíte, které verze prohlížeče jej podporují.
 
 ## Řetězec
+=======
+## String
+>>>>>>> b258d7d5b635c88228f7556e14fbe5e5ca7f736d
 
 Řetězec (anglicky string) v JavaScriptu musí být uzavřen do uvozovek.
 

1-js/03-code-quality/06-polyfills/article.md

@@ -7,7 +7,7 @@ Teams behind JavaScript engines have their own ideas about what to implement fir
 
 So it's quite common for an engine to implement only part of the standard.
 
-A good page to see the current state of support for language features is <https://kangax.github.io/compat-table/es6/> (it's big, we have a lot to study yet).
+A good page to see the current state of support for language features is <https://compat-table.github.io/compat-table/es6/> (it's big, we have a lot to study yet).
 
 As programmers, we'd like to use most recent features. The more good stuff - the better!
 
@@ -73,7 +73,6 @@ JavaScript is a highly dynamic language. Scripts may add/modify any function, ev
 
 Two interesting polyfill libraries are:
 - [core js](https://github.com/zloirock/core-js) that supports a lot, allows to include only needed features.
-- [polyfill.io](https://polyfill.io/) service that provides a script with polyfills, depending on the features and user's browser.
 
 
 ## Summary
@@ -85,7 +84,7 @@ Just don't forget to use a transpiler (if using modern syntax or operators) and
 For example, later when you're familiar with JavaScript, you can setup a code build system based on [webpack](https://webpack.js.org/) with the [babel-loader](https://github.com/babel/babel-loader) plugin.
 
 Good resources that show the current state of support for various features:
-- <https://kangax.github.io/compat-table/es6/> - for pure JavaScript.
+- <https://compat-table.github.io/compat-table/es6/> - for pure JavaScript.
 - <https://caniuse.com/> - for browser-related functions.
 
 P.S. Google Chrome is usually the most up-to-date with language features, try it if a tutorial demo fails. Most tutorial demos work with any modern browser though.

1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -4,7 +4,7 @@ importance: 2
 
 # Chaining
 
-There's a `ladder` object that allows to go up and down:
+There's a `ladder` object that allows you to go up and down:
 
 ```js
 let ladder = {
@@ -21,7 +21,7 @@ let ladder = {
 };
 ```
 
-Now, if we need to make several calls in sequence, can do it like this:
+Now, if we need to make several calls in sequence, we can do it like this:
 
 ```js
 ladder.up();
@@ -32,10 +32,10 @@ ladder.down();
 ladder.showStep(); // 0
 ```
 
-Modify the code of `up`, `down` and `showStep` to make the calls chainable, like this:
+Modify the code of `up`, `down`, and `showStep` to make the calls chainable, like this:
 
 ```js
 ladder.up().up().down().showStep().down().showStep(); // shows 1 then 0
 ```
 
-Such approach is widely used across JavaScript libraries.
+Such an approach is widely used across JavaScript libraries.

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

@@ -253,7 +253,7 @@ let obj = {
   }
 };
 
-alert(obj + 2); // 22 ("2" + 2), conversion to primitive returned a string => concatenation
+alert(obj + 2); // "22" ("2" + 2), conversion to primitive returned a string => concatenation
 ```
 
 ## Summary