Add Czech translation

content/cz/2-1-Identifiers.md

@@ -1,3 +1,38 @@
 ## 2.1. Hodnota, identifikátor, proměnná a konstanta, literál, přiřazení
 
-No translation
+```js
+const INTERVAL = 500;
+let counter = 0;
+const MAX_VALUE = 10;
+let timer = null;
+
+const event = () => {
+  if (counter === MAX_VALUE) {
+    console.log('The end');
+    clearInterval(timer);
+    return;
+  }
+  console.dir({ counter, date: new Date() });
+  counter++;
+};
+
+console.log('Begin');
+timer = setInterval(event, INTERVAL);
+```
+
+```js
+// Constants
+
+const SALUTATION = 'Ave';
+
+const COLORS = [
+  /* 0 */ 'černá',
+  /* 1 */ 'červená',
+  /* 2 */ 'zelená',
+  /* 3 */ 'žlutá',
+  /* 4 */ 'modrá',
+  /* 5 */ 'magenta',
+  /* 6 */ 'cyan',
+  /* 7 */ 'bílá',
+];
+```

content/cz/2-2-Types.md

@@ -1,3 +1,42 @@
 ## 2.2. Datové typy, skalární, referenční a strukturované typy
 
-No translation
+> Typ — množina hodnot a operací, které lze na těchto hodnotách provádět.
+
+Například v `JavaScript` typ `Boolean` předpokládá dvě hodnoty `true` a `false` a logické operace na nich, typ `Null` předpokládá jednu hodnotu `null` a typ `Number` je množina racionálních čísel s dodatečnými omezeními na minimální a maximální hodnoty, stejně jako omezení na přesnost a matematické operace `+ - * ** / % ++ -- > < >= <= & | ~ ^ << >>`.
+
+> Datové typy
+
+```js
+const values = [5, 'Praha', true, { size: 10 }, (a) => ++a];
+
+const types = values.map((x) => typeof x);
+console.log({ types });
+```
+
+> Skalární (Primitivní, Atomická hodnota) — hodnota primitivního datového typu.
+
+Skalární hodnota se kopíruje při přiřazení a předává se funkci hodnotou.
+
+> Reference ukazuje na hodnotu referenčního typu, tj. ne skalární hodnotu.
+
+Pro `JavaScript` jsou to podtypy: `Object`, `Function`, `Array`.
+
+> Strukturované typy (Složené typy) — složené typy nebo struktury, které se skládají z několika skalárních hodnot.
+
+Skalární hodnoty jsou kombinovány do jedné takovým způsobem, že na této kombinované hodnotě lze provádět sadu operací. Například: objekt, pole, množina, n-tice.
+
+> Výčtový typ
+
+> Příznak — logická hodnota, která určuje stav něčeho.
+
+Například: stav uzavřeného připojení, stav dokončení vyhledávání nad datovou strukturou atd.
+
+```js
+let flagName = false;
+```
+
+Někdy se příznaky mohou nazývat ne logické, ale výčtové typy.
+
+> Řetězec — posloupnost znaků
+
+Ve většině jazyků lze ke každému znaku přistupovat pomocí syntaxe přístupu k poli, jako jsou hranaté závorky.

content/cz/2-3-Blocks.md

@@ -1,3 +1,15 @@
 ## 2.3. Operátor a výraz, blok kódu, funkce, smyčka, podmínka
 
-No translation
+```js
+(len - 1) * f(x, INTERVAL);
+```
+
+```js
+const MAX_VALUE = 10;
+
+console.log('Begin');
+for (let i = 0; i < MAX_VALUE; i++) {
+  console.dir({ i, date: new Date() });
+}
+console.log('The end');
+```

content/cz/2-4-Context.md

@@ -1,3 +1,47 @@
 ## 2.4. Kontexty a lexikální rozsah
 
-No translation
+> Oblast viditelnosti (Scope)
+
+Oblast viditelnosti - část kódu, ze které je "viditelný" identifikátor. Podívejme se na příklad:
+
+```js
+const level = 1;
+
+const f = () => {
+  const level = 2;
+  {
+    const level = 3;
+    console.log(level); // 3
+  }
+  console.log(level); // 2
+};
+```
+
+V moderním standardu JavaScript je oblast viditelnosti vytvářena funkcí nebo jakýmkoli blokem příkazů, který má složené závorky {}. V Pythonu je scope vytvářen pouze funkcemi. Porovnejte tento kód s předchozím příkladem:
+
+```py
+level = 1
+
+def f():
+  level = 2
+  if level == 2:
+    level = 3
+    print(level) // 3
+  print(level) // 3
+
+f()
+```
+
+> Lexikální kontext (Lexical environment)
+
+Sada identifikátorů dostupných v lokálním bloku nebo funkci. Pokud identifikátor není nalezen v lexikálním kontextu, vyhledávání pokračuje v nadřazeném kontextu, protože kontexty mají vnořenou strukturu. Pokud se po dosažení kořene identifikátor nenajde, bude provedeno vyhledávání v globálním kontextu. Pro JavaScript jsou lexikální kontexty omezeny bloky {} a funkcemi, pro Python pouze funkcemi.
+
+Lexikální kontext nebo lexikální prostředí má vnořenost, tj. kromě lokálních proměnných v bloku, který vytváří kontext, existuje i nadřazený blok se svým kontextem. Pokud je identifikátor definován v nadřazeném kontextu, je viditelný ve všech vnořených, pokud nedochází k překrytí názvů. Překrytí je případ, kdy je ve vnořeném kontextu znovu deklarován identifikátor, který již existuje ve vnějším, pak se hodnota z vnějšího kontextu stává nedostupnou a můžeme přistupovat pouze k vnitřnímu.
+
+> Objektový kontext
+
+Objekt dostupný z metod a funkcí prostřednictvím speciálního identifikátoru `this` se také používá jako kontext. Ve většině programovacích jazyků se metoda váže s `this` při vytváření objektu třídy. Ale v JavaScriptu mohou být funkce připojeny k `this` pomocí `bind` nebo jednorázově volány v kontextu objektu prostřednictvím `call` a `apply`. Všechny funkce kromě šipkových mohou být vázány s objekty.
+
+> Globální kontext (Global context)
+
+Pokud identifikátor není nalezen v žádném z vnořených lexikálních kontextů, bude provedeno jeho vyhledávání v globálním objektu-referenčním, který je globálním kontextem (v JavaScriptu `global` nebo `window`).

content/cz/2-5-Procedure.md

@@ -1,3 +1,53 @@
 ## 2.5. Procedurální paradigma, volání, zásobník a halda
 
-No translation
+> Procedura nebo podprogram (Procedure, Subroutine) - logicky související skupina instrukcí nebo operátorů, která má jméno.
+
+Procedura podporuje opakované použití kódu a může být volána z různých částí programu mnohokrát a s různými argumenty. Procedura nevrací hodnoty, na rozdíl od funkcí, ale v některých jazycích (ale ne v JavaScript) může modifikovat své argumenty. V mnoha jazycích je procedura popsána pomocí syntaxe funkcí (například typu void).
+
+> Funkce (Function) - abstrakce transformace hodnot. Funkce jednoznačně mapuje jednu množinu hodnot na jinou množinu hodnot.
+
+Funkce může být zadána blokem operátorů nebo výrazem. Funkce má sadu argumentů. Funkce může být volána podle jména nebo prostřednictvím ukazatele. Funkce podporuje opakované použití kódu a může být volána z různých částí programu mnohokrát a s různými argumenty. V JavaScriptu je funkce popsána pomocí `function` nebo syntaxe šipek (lambda funkcí).
+
+Signatura funkce (Function signature) zahrnuje: jméno (identifikátor), počet argumentů a jejich typy (a někdy i jména argumentů), typ výsledku.
+
+> Metoda - funkce nebo procedura spojená s objektem nebo třídou.
+
+```js
+{
+  a: 10,
+  b: 10,
+  sum() {
+    return this.a + this.b;
+  }
+}
+```
+
+```js
+const colorer = (s, color) => `\x1b[3${color}m${s}\x1b[0m`;
+
+const colorize = (name) => {
+  let res = '';
+  const letters = name.split('');
+  let color = 0;
+  for (const letter of letters) {
+    res += colorer(letter, color++);
+    if (color > COLORS.length) color = 0;
+  }
+  return res;
+};
+
+const greetings = (name) =>
+  name.includes('Augustus')
+    ? `${SALUTATION}, ${colorize(name)}!`
+    : `Hello, ${name}!`;
+```
+
+> Použití
+
+```js
+const fullName = 'Marcus Aurelius Antoninus Augustus';
+console.log(greetings(fullName));
+
+const shortName = 'Marcus Aurelius';
+console.log(greetings(shortName));
+```

content/cz/2-6-Function.md

@@ -1,3 +1,118 @@
 ## 2.6. Funkce vyššího řádu, čistá funkce, vedlejší účinky
 
-No translation
+Deklarace funkce (Function definition) - v `JavaScript` je to způsob deklarace funkce, který je viditelný odkudkoli v lexikálním kontextu, ve kterém je funkce deklarována, příklad:
+
+```js
+function sum(a, b) {
+  return a + b;
+}
+```
+
+Funkční výraz (Function expression) - propojení funkce s identifikátorem pomocí přiřazení, kde hodnota je dostupná prostřednictvím identifikátoru ne v celém lexikálním kontextu, ale pouze po místě přiřazení. Má několik syntaktických variant:
+
+Funkční výraz s pojmenovanou funkcí (Named function expression):
+
+```js
+const sum = function sum(a, b) {
+  return a + b;
+};
+```
+
+Anonymní funkční výraz (Anonymous function expression):
+
+```js
+const sum = function (a, b) {
+  return a + b;
+};
+```
+
+Šipková nebo lambda funkce (Arrow, Lambda function):
+
+```js
+const sum = (a, b) => {
+  return a + b;
+};
+```
+
+Lambda výraz, šipková funkce s výrazem jako tělem (Lambda expression, Arrow function):
+
+```js
+const sum = (a, b) => a + b;
+```
+
+> Čistá funkce (Pure Function) - deterministická funkce bez vedlejších účinků.
+
+Čistá funkce je funkce, která počítá výsledek pouze na základě argumentů, nemá stav a nepřistupuje k operacím vstupu-výstupu. Výsledek takové funkce je vždy deterministický a bez vedlejších účinků (viz vedlejší účinek).
+
+> Uzávěr (Closure) - funkce spojená s lexikálním prostředím v okamžiku svého vytvoření.
+
+Pokud je funkce `g` vrácena z funkce `f`, pak `g` uvidí kontext funkce `f`, stejně jako své vlastní argumenty. Pokud `f` vrací `g`, říká se, že instance `g` uzavřela kontext `f`. Uzávěr je způsob, jak propojit funkci s kontextem (s daty nebo kontextovými proměnnými). Uzávěr umožňuje vytvořit efekt podobný stavu objektu (sadě jeho vlastností) v OOP. Vlastnosti jsou propojeny s metodami prostřednictvím objektu, v podstatě je objekt v OOP sám kontextem propojení. Uzávěr také vytváří podobný kontext, ale na základě funkcí první třídy a lexikálního kontextu, ne objektově orientovaného.
+
+Pomocí uzávěrů lze implementovat funkční dědičnost.
+
+Příklady:
+
+```js
+const sum = (a) => (b) => a + b;
+
+const hash =
+  (data = {}) =>
+  (key, value) => ((data[key] = value), data);
+```
+
+> Superpozice (Superposition) - kombinace volání funkcí ve výrazech tak, že výsledek některých funkcí se stává argumenty jiných funkcí.
+
+```js
+const expr2 = sum(
+  pow(mul(5, 8), 2),
+  div(inc(sqrt(20)), log(2, 7))
+);
+```
+
+> Kompozice (Composition) - vytvoření nové funkce kombinací jednodušších.
+
+```js
+const compose = (f1, f2) => (x) => f2(f1(x));
+```
+
+```js
+// prettier-ignore
+const compose = (...funcs) => (...args) =>
+  funcs.reduce((args, fn) => [fn(...args)], args);
+```
+
+> Částečná aplikace (Partial application)
+
+```js
+// prettier-ignore
+const partial = (fn, x) => (...args) => fn(x, ...args);
+```
+
+> Curryfikace (Currying)
+
+```js
+const result = curry((a, b, c) => a + b + c)(1, 2)(3);
+```
+
+> Vedlejší účinky (Side effects)
+
+> Funkce vyššího řádu (Higher-order Function)
+
+1. Pokud je funkce předána jako argument jiné funkci, je to callback.
+2. Pokud je funkce vrácena jako výsledek, je to továrna funkcí na uzávěrech.
+3. Pokud má vrácená funkce stejnou sémantiku jako přijatá v argumentech, ale s dodatečným (rozšířeným) chováním, je to wrapper funkce.
+4. Zřídka se stává, že vrácená funkce není propojena s funkcí z argumentů nebo není propojena přímo a má také jinou sémantiku a není wrapper funkcí.
+5. Pokud na výstupu je třída nebo konstruktorová funkce, jsou to továrny pro třídy a prototypy.
+
+> Wrapper funkce (Wrapper)
+
+Funkce, která obaluje jinou funkci (někdy objekt, rozhraní nebo funkční objekt) a přidává jí dodatečné chování. Můžete obalit celé API rozhraní a dokonce asynchronní funkci spolu s callbacky (pokud je známá smlouva).
+
+```js
+const sum = (a, b) => a + b;
+
+console.log(`Add nums:    ${sum(5, 2)}`);
+console.log(`Add float:   ${sum(5.1, 2.3)}`);
+console.log(`Concatenate: ${sum('5', '2')}`);
+console.log(`Subtraction: ${sum(5, -2)}`);
+```