JavaScript je jedním z nejpoužívanějších programovacích jazyků na světě - pohání aplikace na straně klienta i serveru. Je to flexibilní, dynamický jazyk, který se neustále vyvíjí. Psaní kódu v JavaScriptu má však svá úskalí. JavaScript vymezuje bloky složenými závorkami, zatímco Python k tomu používá odsazení. Na rozdíl od staticky typované Javy pracuje JavaScript s dynamickými typy. Chybějící středník, nadbytečná čárka nebo zapomenutá závorka mohou způsobit problémy. Pro vývojáře, kteří tráví u klávesnice hodiny denně, je proto klíčová jistota a přesnost. Při nácviku psaní všemi deseti se učíš zadávat kód přesně a bez pohledu na klávesnici. Při práci se pak můžeš více soustředit na logiku programu než na hledání jednotlivých kláves.

Dynamické typování a deklarace proměnných

JavaScript je dynamicky typovaný jazyk, což znamená, že proměnné mohou uchovávat hodnoty libovolného typu a typ se může měnit během běhu programu. Tato flexibilita usnadňuje začátky, ale je také zdrojem chyb. Pro nové proměnné se běžně používají let a const, obě s blokovým rozsahem platnosti. Proměnné deklarované pomocí let lze přiřadit novou hodnotu, vazbu deklarovanou pomocí const nikoli. Platné zůstává i var, které má rozsah funkce, skriptu nebo modulu. Překlep nebo nesprávné použití vede k obtížně odhalitelným chybám. Při nácviku psaní všemi deseti si můžeš procvičit přesné zadávání const a let; správné klíčové slovo vybíráš podle toho, co má proměnná v programu dělat.

// Použití let pro proměnné, které se mění
let counter = 0;
counter++;

// Použití const pro neměnné hodnoty
const PI = 3.14159;

// Var je dnes zastaralý
var legacy = "starý styl";

Středníky a automatické vkládání

Jednou z nejkontroverznějších vlastností JavaScriptu je automatické vkládání středníků (automatic semicolon insertion). Technicky lze mnoho příkazů zapsat bez středníků, ale jejich vynechání může vést k podivným chybám. Klasickým příkladem je příkaz return, kde je hodnota uvedena na další řádce - JavaScript to interpretuje jako return; a vrátí undefined. Výraz, který má funkce vrátit, musí začínat na stejném řádku jako return; samotné doplnění středníku tento problém nevyřeší. Některé styly středníky vyžadují, jiné je vynechávají, proto se řiď pravidly projektu. Při psaní všemi deseti si můžeš procvičit zadávání středníků tam, kde je vyžaduje zvolený styl. Současně kontroluj, kde příkaz skutečně končí.

// Nebezpečné: vrací undefined
function bad() {
  return
  {
    name: "Alena"
  };
}

// Správné: středník zajistí návrat hodnoty
function good() {
  return {
    name: "Alena"
  };
}

Objekty a JSON

JavaScript je postaven na objektech. Zápis literálů objektů vyžaduje složené závorky {}, dvojtečky : a čárky , na správných místech. JSON, který kopíruje objektovou syntaxi JavaScriptu, je přísný: nadbytečná čárka na konci zneplatní celý soubor. Pro vývojáře, kteří nejsou zvyklí na přesné psaní interpunkce, je to častý zdroj chyb. Psaní všemi deseti pomáhá vybudovat jistotu při používání těchto znaků - závorky, dvojtečky a čárky se píší automaticky, zatímco pozornost zůstává na struktuře dat.

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

Funkce: deklarace, výrazy a šipkové funkce

JavaScript umožňuje definovat funkce několika způsoby: klasické deklarace, anonymní výrazy nebo funkce šipkové. Právě šipkové funkce využívají symbol =>, který je snadné napsat špatně. Začátečníci často zapomínají závorku nebo umístí šipku nesprávně. Díky psaní všemi deseti se však zápis => stává instinktivním. JavaScript navíc podporuje výchozí parametry, parametry rest (...args) a destrukturalizaci v seznamu parametrů. To dodává jazyku expresivitu, ale zároveň zvyšuje množství znaků, které je nutné přesně napsat.

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

// Šipková funkce
const greetArrow = (name) => "Ahoj " + name;

// Funkce s výchozím a rest parametrem
function log(message = "Info", ...args) {
  console.log(message, args);
}

Uzávěry (closures) a callbacky

Jedním z charakteristických rysů JavaScriptu jsou uzávěry. Funkce mohou zachytit proměnné ze svého okolí. To je velmi silný koncept, ale snadno se v něm chybuje, zejména v cyklech nebo asynchronním kódu. Psaní callbacků často znamená mnoho vnořených závorek a složených závorek. Bez dobrého ovládání klávesnice je snadné něco vynechat. Psaní všemi deseti dává těmto konstrukcím rytmus a spolehlivost.

// Closure zachycující proměnnou
function makeCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

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

Asynchronní kód: callbacky, promisy, async/await

JavaScript podporuje asynchronní operace. K jejich zpracování slouží callbacky, promisy a syntaxe async/await. Každá z těchto konstrukcí má své nároky: callbacky vedou k mnohonásobně vnořeným závorkám, promisy využívají řetězení .then(), async/await přidává nová klíčová slova. Psaní všemi deseti pomáhá zvládat tyto vzory, protože umožňuje rychle a přesně zapisovat opakující se struktury jako try { ... } catch(e) { ... } nebo await fetch(...). Přesné zadávání znaků snižuje riziko překlepů v těchto strukturách; správnou asynchronní logiku je potřeba ověřit v samotném programu.

// Použití Promise
fetch("/api/data")
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(err => console.error(err));

// Použití 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);
  }
}

Styl a konvence

Zatímco u Pythonu se mluví o pojmu pythonic, v JavaScriptu se diskuse točí kolem stylových příruček jako Airbnb, StandardJS nebo konvencí Google. Tyto příručky řeší odsazení (dvě nebo čtyři mezery), používání středníků, konvence pojmenování (camelCase pro proměnné, PascalCase pro třídy) nebo délku řádků. Nástroje jako ESLint a Prettier mohou podle svého nastavení kontrolovat nebo upravovat styl kódu. Díky psaní všemi deseti je dodržování těchto pravidel snazší - rytmus psaní se stane přirozeným, ať už jde o šipkové funkce, objekty nebo řetězené metody.

Časté syntaktické chyby

Mezi nejčastější chyby v JavaScriptu patří zapomenuté ukončení řetězců šablon (template literals) uzavíraných backtickem, záměna jednoduchých a dvojitých uvozovek nebo nezavřené závorky. Šablony ES6 s interpolací ${...} jsou mocné, ale vyžadují přesné pořadí znaků: backtick, znak dolaru a složené závorky. Bez jistoty na klávesnici to bývá zdlouhavé. Psaní všemi deseti dělá z těchto sekvencí rutinu.

// Template string s interpolací
const name = "Alena";
console.log(`Ahoj, ${name}!`);

Třídy a objektově orientované prvky

Před ES6 JavaScript využíval prototypy. Dnes je k dispozici syntaxe tříd, i když prototypy stále existují na pozadí. Metoda constructor slouží k inicializaci instance, ale nemusíš ji definovat. Volání super je potřeba při volání konstruktoru rodičovské třídy z vlastního konstruktoru odvozené třídy. Metody se definují bez klíčového slova function. Častou chybou je zapomenuté this nebo špatně umístěné složené závorky. Díky psaní všemi deseti je psaní těchto opakujících se struktur hladší a méně chybové. Stejně jako v Javě se třídy v JavaScriptu často pojmenovávají PascalCase, což také vyžaduje disciplínu.

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

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

Moduly a importy

Moderní JavaScript využívá ES moduly s příkazy import a export. Ty často obsahují dlouhé cesty a složené závorky. Zápis příkazu jako import { readFile, writeFile } from "fs"; rychle a bez chyby není pro začátečníky samozřejmý. Díky psaní všemi deseti si programátor osvojí spolehlivé vkládání složených závorek a uvozovek, což usnadňuje práci s moduly.

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

Shrnutí

JavaScript je dynamický, flexibilní a expresivní jazyk. Jeho syntaxe spojuje velké množství znaků - složené závorky, hranaté závorky, dvojtečky, čárky, středníky, backticky - a to činí psaní přesného kódu neustálou výzvou. Stejně jako Java rozlišuje JavaScript malá a velká písmena; vynechání znaku, který syntaxe vyžaduje, může zabránit spuštění programu. Na rozdíl od Pythonu nevynucuje odsazení, ale komunita očekává konzistentní formátování. Psaní všemi deseti pomáhá vývojářům zvládat všechny tyto nároky: snižuje chybovost při interpunkci, zjednodušuje psaní opakujících se vzorců (šipkové funkce, importy) a umožňuje soustředit se na návrh programu namísto na klávesnici. Pokud píšeš JavaScript každý den, psaní všemi deseti ti může usnadnit přesný zápis kódu. Aby program fungoval správně, musíš také rozumět jeho logice a ověřit jeho chování.