    /* Datové typy */
    /** Primitiva **/
    12345                      // Číslo (v desítkové soustavě,
    0x3039                     ///       v šestnáctkové soustavě,
    0o30071                    ///       v oktalové soustavě, -- Novinka ECMAScriptu 6
    0b11000000111001           ///       v binární soustavě)  -- Novinka ECMAScriptu 6
    NaN                        //// Hodnota Not a Number (navrácena např. při dělení nulou)
    Infinity                   //// Pozitivní nekonečno
    -Infinity                  //// Negativní nekonečno

    "ahoj 'světe'"             // Textový řetězec
    'ahoj "světe"'
    "1, 2, 3, " + 4 + ', ' + (2 + 3)
    `1, 2, 3, ${4}, ${2 + 3}`  //// Interpolovaný řetězec -- Novinka ECMAScriptu 6

    true                       // Pravdivostní (boolean) hodnota
    false

    undefined                  // Nedefinovaná, prázdná hodnota
    Symbol()                   // Symbol -- Novinka ECMAScriptu 6

    /** Referenční typy **/
    [ 1, 2, 3, [4, 5] ]        // Pole             (objekt `Array`)
    new Array(1, 2, 3, new Array(4, 5))

    function a(b) { return b } // Funkce           (objekt `Function`)
    var a = function(b) { return b }
    var a = (b) => b           //// Lambda syntax -- Novinka ECMAScriptu 6
    var a = new Function("return arguments[0];")

    /ahoj\s*světe/ig           // Regulární výraz  (objekt `RegExp`)
    new RegExp("ahoj\\s*světe", "ig")

    new Date                   // Datum            (objekt `Date`)
    new Error                  // Výjimka          (objekt `Error`)
    new Number(12345)          // Zabalené číslo   (objekt `Number`)
    new String("foo bar")      // Zabalený řetězec (objekt `String`)
    new Boolean(true)          // Zabalený boolean (objekt `Boolean`)
    new Set([1, 2, 3, 1, 2])   // Množina          (objekt `Set`) -- Novinka ECMAScriptu 6

    ({ ahoj: "světe" })        // Obecný objekt   (objekt `Object`)
    null                       //// Nedefinovaný objekt

    /* Základní aritmetika */
    1 + (2 * 3) - 4 / 5        // Aritmetické operátory
    6 % 7                      //// Zbytek po celočíselném dělení
    Math.abs(-47.125)          // Absolutní hodnota argumentu
    Math.cos(0)                // Kosinus
    Math.acos(1)               // Arkus kosinus
    Math.sin(Math.PI / 2)      // Sinus
    Math.asin(1)               // Arkus sinus
    Math.tan(Math.PI / 4)      // Tangens
    Math.atan(1)               // Arkus tangens
    Math.atan2(1, 1)           // Úhel mezi osou x a daným bodem
    Math.ceil(1.05)            // Zaokrouhlování směrem nahoru
    Math.ceil(1.8)
    Math.round(1.05)           // Aritmetické zaokrouhlování
    Math.round(1.8)
    Math.floor(1.05)           // Zaokrouhlování směrem dolů
    Math.floor(1.8)
    Math.pow(2, 8)             // Výpočet osmé mocniny dvou
    Math.pow(Math.E, 8)        // Výpočet osmé mocniny Eulerova čísla
    Math.exp(8)
    Math.pow(2, 1/2)           // Výpočet druhé odmocniny dvou
    Math.sqrt(2)
    Math.log(2)                // Přirozený logaritmus
    Math.min(1, 2, 3, 4, 5)    // Nalezení nejmenšího argumentu
    Math.max(1, 2, 3, 4, 5)    // Nalezení největšího argumentu

    /* Operátory */
    /** Relační operátory **/
    1 < 2                      // Je menší než
    3 > 2                      // Je větší než
    3 >= 3                     // Je větší nebo rovno než
    3 <= 3                     // Je menší nebo rovno než
    3 == 3                     // Je rovno
    "3" == 3                   //// Operátor rovnosti provádí konverze primitiv.
    "3" != 3                   // Není rovno
    3 === 3                    // Je identické
    "3" === 3                  //// Operátor identity konverze primitiv neprovádí.
    "3" !== 3                  // Není identické
    "foo" === "foo"            //// Primitiva jsou identická, pokud si odpovídají hodnotou.
    [1, 2] === [1, 2]          //// Referenční typy jsou identické, pokud jde o totožný objekt.

    /** Logické operátory **/
    true  && true              // Logické AND
    true  && false
    false && true
    true  || true              // Logické OR
    true  || false
    false || true
    !true                      // Logické NOT
    !false

    /** Bitové operátory **/
    0b0011 & 0b1100                      // Bitové AND
    0b0011 & 0b0011
    0b0011 | 0b1100                      // Bitové OR
    0b0011 | 0b0011
    0b0011 ^ 0b1100                      // Bitové XOR
    0b0011 ^ 0b0011
    ~0b11111111111111111111111111111111  // Bitová inverze
    ~0b00000000000000000000000000000000
    0b0001 << 3                          // Bitový posun doleva
    0b1000 >> 3                          // Bitový posun doprava
    -0b1000 >>> 3                        // Bitový posun doprava s doplňováním nul
    -0b1000 >>  3

    /** Proměnné a přiřazovací operátory **/
    var a                      // Deklarace proměnné
    var a = 1                  // Deklarace a přiřazení hodnoty proměnné
    var a; a = 1

    a += 1                     // Inkrementace
    a = a + 1
    a++                        //// Tento operátor navrátí hodnotu proměnné před inkrementací
    ++a                        //// Tento operátor navrátí hodnotu proměnné po inkrementaci

    a -= 1                     // Dekrementace
    a = a - 1
    a--                        //// Tento operátor navrátí hodnotu proměnné před dekrementací
    --a                        //// Tento operátor navrátí hodnotu proměnné po dekrementaci

    a *= 2                     // Násobení
    a /= 2                     // Dělení
    a %= 2                     // Zbytek po celočíselném dělení

    /** Další operátory **/
    true  ? 1 : "foo"                            // Ternární operátor
    false ? 1 : "foo"
    typeof 12345                                 // Detekce primitivního datového typu
    typeof "foo bar"
    typeof true
    typeof undefined
    typeof Symbol()
    [ 1, 2, 3, [4, 5] ]        instanceof Array  // Detekce referenčního datového typu
    function a(b) { return b } instanceof Function
    /ahoj\s*světe/ig           instanceof RegExp
    new Date                   instanceof Date
    new Error                  instanceof Error
    new Number(12345)          instanceof Number
    new String("foo bar")      instanceof String
    new Boolean(true)          instanceof Boolean
    new Set([1, 2, 3, 1, 2])   instanceof Set
    ({ ahoj: "světe" })        instanceof Object
    "ahoj" in { ahoj: "světe" }                  // Kontrola existence klíče v objektu
    "foo"  in { ahoj: "světe" }

    /* Řídicí struktury */
    if (a === 1)               // Řídicí struktura `if` - `else` provede kód mezi
      "a se rovná 1"           /// `if` a `else`, pokud je splněna podmínka v záhlaví.
    else {                     /// V opačném případě se provede kód za nepovinným
      "už tu máme dva výrazy"  /// `else`. Pokud kód obsahuje více než jeden výraz,
      "a se nerovná 1"         /// je nutné jej obalit do složených závorek.
    }

    var str = "Počítáme: " + a /// Cyklus `while` provádí následující kód, dokud podmínka
    while (a < 10) {           /// v záhlaví cyklu zůstává platná.
      a += 1
      str += ", " + a
    }
    str

    var str = "Počítáme: " + a /// Cyklus `do` - `while` provádí následující kód, dokud
    do {                       /// podmínka v záhlaví cyklu zůstává platná. Na rozdíl
      a += 1                   /// od cyklu `while` k prvnímu průchodu cyklem dojde vždy
      str += ", " + a          /// a podmínka se kontroluje až při následujících průchodech.
    } while(a === "nesmysl")
    str

    var str = "Počítáme: 1"      // Cyklus `for` nejprve provede první příkaz záhlaví a
    for (var a = 2; a < 10; a++) /// zadeklaruje uvedené proměnné. Následně provádí následující
      str += ", " + a            /// kód, dokud druhý výraz v záhlaví zůstává platný. Po každé
    str                          /// iteraci se vykoná třetí výraz v záhlaví.

    var produkty = {           // Cyklus `for` - `in` provádí následující kód pro veškeré
      jablek:  "mošt",         /// klíče, které se nachází v příslušném objektu.
      jahod:   "marmeláda",
      rozinek: "zavařenina" };
    var str = "";
    for (var klíč in produkty)
      str += `Z ${klíč} se připravuje ${produkty[klíč]}. `
    str

    var produkty = new Set([      // Cyklus `for` - `of` provádí následující kód pro veškeré
      "mošt", "marmeládu", "zavařeninu" ]); /// hodnoty iterovatelného objektu. Jedná se
    var str = "Můžeme vyprodukovat:"; /// o novinku ECMAScriptu 6.
    for (var produkt of produkty)
      str += `\n * ${produkt}`
    str

    /* Výjimky */
    try {
      throw new Error("Neočekávaná výjimka")
    } catch (e) {
      "Došlo k následující chybě: " + e.message
    } finally {
      // Tento kód se provede vždy.
    }