JavaScript patrí medzi najpoužívanejšie programovacie jazyky na svete - využíva sa na strane klienta aj na strane servera. Je to flexibilný, dynamický jazyk, ktorý sa neustále vyvíja. Napriek tomu písanie kódu v JavaScripte nie je úplne jednoduché. JavaScript vymedzuje bloky zloženými zátvorkami, zatiaľ čo Python používa odsadenie. Na rozdiel od staticky typovanej Javy je JavaScript dynamicky typovaný. Zabudnutá bodkočiarka, nadbytočná čiarka alebo neuzavretá zložená zátvorka môžu zastaviť celý program. Pre vývojárov, ktorí trávia denne hodiny za klávesnicou, je presnosť kľúčová. Pri nácviku strojopisu sa učíš zadávať kód presne a bez pohľadu na klávesnicu. Pri písaní sa potom môžeš viac sústrediť na logiku programu než na hľadanie jednotlivých klávesov.

Dynamické typy a deklarácie premenných

JavaScript je dynamicky typovaný jazyk, čo znamená, že premenné môžu obsahovať akúkoľvek hodnotu a počas behu meniť svoj typ. Táto flexibilita uľahčuje začiatky, ale je aj zdrojom chýb. Nové premenné sa zvyčajne deklarujú pomocou let a const, ktoré majú blokový rozsah platnosti. Premennej deklarovanej pomocou let možno priradiť novú hodnotu, väzbe deklarovanej pomocou const nie. var zostáva platnou konštrukciou s rozsahom funkcie, skriptu alebo modulu. Preklep alebo zlá voľba môžu viesť k ťažko odhaliteľným bugom. Pri nácviku strojopisu si môžeš precvičiť presné zadávanie const a let. Výber správneho kľúčového slova závisí od použitia premennej v programe.

// Použi let pre meniace sa premenné
let counter = 0;
counter++;

// Použi const pre konštanty
const PI = 3.14159;

// var sa v modernom kóde neodporúča
var legacy = "starý štýl";

Bodkočiarka a automatické vkladanie

Jednou z najdiskutovanejších vlastností JavaScriptu je automatické vkladanie bodkočiarky. Mnohé príkazy môžu byť napísané aj bez nej, ale to môže viesť k nečakaným chybám. Typickým príkladom je použitie return s hodnotou na nasledujúcom riadku - JavaScript to vyhodnotí ako return;. Vrátený výraz sa musí začínať na rovnakom riadku ako return; doplnenie bodkočiarky tento problém nevyrieši. Niektoré štýly bodkočiarky vyžadujú, iné ich vynechávajú, preto dodržuj pravidlá projektu. Strojopis robí z tohto malého, opakovaného stlačenia klávesu zvyk.

// Nebezpečné: vráti undefined
function bad() {
  return
  {
    name: "Ján"
  };
}

// Správne: bodkočiarka zabezpečí návratovú hodnotu
function good() {
  return {
    name: "Ján"
  };
}

Objekty a JSON

JavaScript je postavený na objektoch. Objektové literály vyžadujú zložené zátvorky {}, dvojbodky : a čiarky , na správnych miestach. JSON, ktorý odráža syntax JavaScriptových objektov, je prísny: jedna nadbytočná čiarka zneplatní celý súbor. Vďaka strojopisu sa písanie týchto symbolov stane rutinou, takže sa programátor môže sústrediť na dátovú štruktúru.

// Objektový literál
const user = {
  id: 1,
  name: "Ján",
  active: true
};

Funkcie: deklarácie, výrazy a arrow functions

JavaScript umožňuje definovať funkcie viacerými spôsobmi: klasickými deklaráciami, anonymnými výrazmi alebo arrow functions. Arrow functions používajú =>, čo sa ľahko píše nesprávne. Začiatočníci často zabúdajú na zátvorky alebo umiestnia šípku na nesprávne miesto. Strojopis z tohto vzoru urobí prirodzený zvyk. JavaScript podporuje aj predvolené parametre, rest parametre (...args) a deštrukturalizáciu argumentov. To robí jazyk expresívnejším, ale vyžaduje si väčšiu presnosť pri písaní.

// Klasická funkcia
function greet(name) {
  return "Ahoj " + name;
}

// Arrow function
const greetArrow = (name) => "Ahoj " + name;

// Funkcia s predvolenými a rest parametrami
function log(message = "Info", ...args) {
  console.log(message, args);
}

Closures a callbacks

Jednou z charakteristických čŕt JavaScriptu je používanie closures. Funkcie môžu "zachytiť" premenné zo svojho vonkajšieho scope. Je to silná vlastnosť, ale aj zdroj chýb, najmä v cykloch alebo asynchrónnom kóde. Písanie callbacks často znamená veľa vnorených zložených zátvoriek a zátvoriek. Strojopis uľahčuje správne a plynulé písanie takýchto opakovaných štruktúr.

// Closure, ktoré zachytáva premennú
function makeCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

Asynchrónny kód: callbacks, promises, async/await

JavaScript podporuje asynchrónne operácie. Na ich spracovanie možno použiť callbacks, promises a syntax async/await. Každá konštrukcia má svoje špecifiká: callbacks znamenajú veľa zložených zátvoriek, promises možno spracovať reťazením .then() alebo pomocou await a async/await zavádza nové kľúčové slová. Vďaka strojopisu je možné tieto opakujúce sa vzory písať rýchlejšie a presnejšie.

// Príklad s Promise
fetch("/api/data")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(err => console.error(err));

// Príklad s async/await
async function loadData() {
  try {
    const response = await fetch("/api/data");
    const data = await response.json();
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

Štýl a konvencie

Tak ako sa v Pythone hovorí o "pythonic" kóde, v JavaScripte sa diskutuje o štýlových príručkách ako Airbnb, StandardJS alebo Google konvenciách. Tie riešia odsadenie (dve alebo štyri medzery), používanie bodkočiarky, konvencie pomenovania (camelCase pre premenné, PascalCase pre triedy) a dĺžku riadkov. Nástroje ako ESLint a Prettier môžu podľa svojho nastavenia kontrolovať alebo formátovať kód. Vďaka strojopisu je jednoduchšie tieto štandardy dodržiavať - aj pri opakujúcich sa vzoroch ako arrow functions alebo reťazenie metód.

Bežné syntaktické chyby

Medzi najčastejšie chyby v JavaScripte patrí zabudnutý backtick v template strings, zámena jednoduchých a dvojitých úvodzoviek alebo neuzavreté zátvorky. Template strings s interpoláciou ${...} sú silné, ale vyžadujú presnú postupnosť: backtick, znak dolára a zložené zátvorky. Strojopis pomáha urobiť z tohto vzoru automatický návyk.

// Template string s interpoláciou
const name = "Ján";
console.log(`Ahoj, ${name}!`);

Triedy a objektovo orientované programovanie

Pred ES6 JavaScript používal prototypy. Dnes existuje syntax pre triedy, aj keď prototypy fungujú na pozadí. Metóda constructor inicializuje inštanciu, ale nemusíš ju definovať. Pomocou super sa volá konštruktor rodičovskej triedy z vlastného konštruktora odvodenej triedy. Metódy sa definujú bez kľúčového slova function. Častou chybou je zabudnutie this alebo zle umiestnená zátvorka. Strojopis zjednodušuje správne písanie týchto opakujúcich sa štruktúr. Podobne ako v Jave sa názvy tried v JavaScripte zvyčajne píšu v PascalCase, čo vyžaduje dôslednosť.

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log(`${this.name} vydáva zvuk.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} šteká.`);
  }
}

Moduly a imports

Moderný JavaScript používa ES moduly s import a export. Tie často obsahujú dlhé cesty a zložené zátvorky. Napísať správne a rýchlo príkaz ako import { readFile, writeFile } from "fs"; nie je vždy jednoduché. Strojopis robí vkladanie zátvoriek a úvodzoviek prirodzeným zvykom.

import { readFile, writeFile } from "fs";
import express from "express";

Zhrnutie

JavaScript je dynamický, flexibilný a expresívny jazyk. Jeho syntax kombinuje množstvo znakov - zložené zátvorky, hranaté zátvorky, dvojbodky, čiarky, bodkočiarky, backticky - čo robí presné písanie neustálou výzvou. Podobne ako Java, aj JavaScript rozlišuje veľké a malé písmená; chýbajúci znak vyžadovaný syntaxou môže zabrániť spusteniu programu. Na rozdiel od Pythonu nevynucuje odsadenie, ale komunita očakáva konzistentné formátovanie. Strojopis pomáha vývojárom tieto požiadavky zvládnuť: menej chýb, rýchlejšie písanie opakujúcich sa vzorov (ako arrow functions či imports) a väčšie sústredenie na architektúru programu namiesto klávesnice. Ak píšeš JavaScript každý deň, nácvik strojopisu ti môže uľahčiť presné zadávanie kódu. Aby program fungoval správne, musíš tiež rozumieť jeho logike a overiť jeho správanie.