JavaScript: Frameworky, knihovny a asynchronní programování

Co je JavaScript a proč je všude

JavaScript je dynamický, prototypový, víceparadigmatický programovací jazyk, který běží v prohlížeči i na serveru. Vznikl pro interaktivitu webu, dnes pohání front-end, back-end, mobilní a desktopové aplikace, skripty CI/CD, automatizaci i edge computing. Standardizován je jako ECMAScript (ES); každoroční specifikace definuje jazykové konstrukce, které implementují enginy (V8, SpiderMonkey, JavaScriptCore, Chakra/Node-Chakra dříve).

Jádro jazyka: hodnoty, typy a porovnávání

• Primitiva: undefined, null, boolean, number, bigint, string, symbol.
• Referenční typy: objekty a z nich odvozené struktury (Array, Map, Set, Date, RegExp atd.).
• Koercíe: JavaScript provádí implicitní převody (např. '2' * 3 → 6), které mohou překvapit; pro porovnání preferujte === (striktní shoda) před ==.
• Nečíselné hodnoty: NaN je „not a number“ a není rovno ničemu, ani sobě; testujte Number.isNaN().

Prototypová dědičnost a objektový model

JavaScript používá prototypy: každý objekt má interní odkaz na „prototyp“ (řetězec prototypů). „Třídy“ (class) jsou syntaktický cukr nad prototypy. Metody jako Object.create() nebo Object.setPrototypeOf() dávají jemnou kontrolu nad dědičností a složením chování.

Rozsahy, uzávěry (closures) a this-binding

• Lexikální rozsah: let a const jsou blokově omezené; var je funkčně omezený a hoistuje se – používejte moderní deklarace.
• Uzávěry: funkce si „pamatují“ prostředí, ve kterém vznikly – klíč pro modularitu, memoizaci, funkcionální techniky.
• this: hodnota se odvíjí od způsobu volání. Šipkové funkce (=>) nevážou vlastní this (dědí lexikálně), klasické funkce ano; pro kontrolu použijte call/apply/bind.

Asynchronní model: event loop, Promise a async/await

JavaScript je single-threaded s event loopem. I/O a časovače běží mimo hlavní vlákno a zpět plánují úlohy pomocí task a microtask front (microtasky – např. vyřízení Promise – mají prioritu). async/await staví na Promise a zpřehledňuje asynchronní kód; nezapomeňte na try/catch a paralelizaci pomocí Promise.all().

Moduly: ES Modules (ESM) vs. CommonJS

• ESM: import/export, statická analýza, tree-shaking, nativní v prohlížečích i Node.js (s type="module" nebo příponou .mjs).
• CommonJS: require()/module.exports, dynamické načítání, historicky v Node.js. V nových projektech preferujte ESM; interoperabilita vyžaduje pozornost.

Standardní knihovna a užitečné struktury

• Kolekce: Map/Set (deterministická iterace, žádné kolize klíčů jako u prostých objektů), WeakMap/WeakSet pro cache s garbage-collection.
• Iterátory a generátory: protokol Symbol.iterator; generátory (function*) pro lazy sekvence a kontrolované iterace.
• Symboly: unikátní klíče vlastností, integrace s interními protokoly (např. Symbol.toStringTag).
• Intl API: formátování čísel, měn, dat, relativního času (i pro i18n bez externích závislostí).

JavaScript a web: DOM, události a Web API

• DOM a události: moderní selekce (querySelector), delegace událostí, pasivní posluchače pro scroll/touch ({ passive: true }).
• Fetch a Streams: fetch s AbortController, Readable/Writable Streams pro práci s velkými daty.
• Web Workers a Worklets: paralelní výpočty mimo UI vlákno; AudioWorklet, PaintWorklet pro nízkoúrovňové scénáře.
• Service Worker a PWA: offline cache, background sync, push notifikace – klíč pro progresivní webové aplikace.

Server-side JavaScript: Node.js, Deno a Bun

• Node.js: de facto standard pro server, bohatý ekosystém NPM, modulární architektura (cluster/worker_threads), nativní Test Runner a fetch.
• Deno: bezpečnost podle oprávnění, ESM a URL importy, TypeScript „out of the box“.
• Bun: zaměřen na výkon (rychlý runtime, bundler, test runner, bun install), kompatibilita s Node API.

Nástroje, balíčkování a build

• Správa balíčků: npm, pnpm, Yarn; lockfile pro reprodukovatelné sestavení; workspaces pro monorepa.
• Bundlery a transformace: Vite, esbuild, Rollup, Webpack; transpilace přes Babel pro kompatibilitu.
• Lint & formát: ESLint + pravidla (např. typescript-eslint), formátování Prettierem.
• Testování: Vitest, Jest, Mocha pro unit/integrace, Playwright/Cypress pro end-to-end.

Bezpečnost: XSS, CSRF, supply chain

• XSS: sanitizace vstupu, Content-Security-Policy, textContent místo innerHTML pro uživatelská data.
• CSRF: same-site cookies, CSRF tokeny, idempotentní design API.
• Supply chain: audit závislostí (npm audit, lockfile signing), pinning verzí, minimální sadu balíčků.
• Sandboxing: princip nejmenších práv (Deno permissions, izolace workerů), vyhýbat se eval.

Výkon: měření, profily a optimalizace

• Měření: Performance API, Lighthouse, User Timing, RUM metriky (FCP, LCP, INP).
• Optimalizace kódu: vyhýbat se skrytým megamorfním voláním, upřednostnit monomorfismus objektů, micro-opt minimalizovat v horkých cestách.
• Načítání: code-splitting, lazy-loading, preload/prefetch, minimalizace JS „payloadu“.
• UI výkon: batchování DOM změn, requestAnimationFrame, IntersectionObserver.

Architektury front-endu: SPA, SSR, SSG, ISR a edge

• SPA: rychlé interakce, ale nároky na klientský JS a SEO; řešení – hydratační strategie, islands architektura.
• SSR/SSG: render na serveru pro rychlý první obsah; incremental static regeneration pro částečné obnovy.
• Edge render: serverové komponenty a middleware blízko uživateli pro nižší latenci.

Ekosystém frameworků a knihoven

• UI knihovny: React (včetně serverových komponent), Vue, Svelte, Solid – každá s jiným kompromisem mezi reaktivitou a ergonomií.
• Meta-frameworky: Next.js/Nuxt/SvelteKit/Astro pro routing, data-fetching, renderingové režimy a build pipeline.
• Stav a data: Redux Toolkit, Zustand, Vuex/Pinia, tanstack/query (kešování serverových dat), Signals přístupy pro jemnozrnnou reaktivitu.

TypeScript a typování v JS světě

TypeScript přináší strukturální typování, které pomáhá s údržbou velkých kódových základen. V čistém JS lze použít JSDoc anotace a checkJs pro postupné typování. Důležité je držet hranici typů na vstupu a výstupu modulů (např. generovat typy z API schémat).

Práce s daty: JSON, binární formáty a čas

• JSON: JSON.parse/stringify, pozor na bezpečnost (neserializovat funkce, validovat schématy – AJV).
• Binární data: ArrayBuffer, TypedArray, DataView, URL.createObjectURL pro blob zdroje.
• Čas a datum: Date je limitovaný; používejte osvědčené knihovny nebo moderní API v bězích, které ho podporují. Zásadou je držet UTC v doménové vrstvě a formátovat až na okraji.

API vrstvy a síťová komunikace

• REST: idempotentní metody, správné kódy odpovědí, ETag a cache.
• GraphQL: přesná data na dotaz, ale pozor na N+1 a složité resolvery; persisted queries.
• WebSocket/SSE: realtime push, backoff strategie, heartbeat/probes.

Průmyslové vzory a idiomy

• Kompozice nad dědičností: funkce vracející chování (factory), mixiny, moduly s explicitním rozhraním.
• Imutabilita dat: kopie s rozprostřením ({ ...obj }, [...arr]), funkční aktualizace, vyhýbat se neviditelným side-effectům.
• Tenké komponenty, tlusté domény: UI jako pohled na stav, doménová logika v samostatných modulech.

Testovatelnost a kvalita

• Unit testy: izolace, determinismus, malé povrchy API.
• Integrační a E2E: testovací identity, seedované databáze, kontraktní testy proti mock serverům.
• Static analysis: ESLint pravidla, dead-code elim, dependency review.

Observabilita a provoz

• Logování: strukturované logy (JSON), korelační ID, ochrana citlivých údajů.
• Metriky a tracing: Web Vitals, aplikační metriky, OpenTelemetry; alerty na symptomy, ne jen na prahy.
• Rollout strategie: canary, feature flagy, postupná expozice, automatický rollback.

Časté chyby a jak se jim vyhnout

• Globální stav a side-effecty: kapslovat do modulů, jasné rozhraní, čisté funkce tam, kde to dává smysl.
• Nezvládnuté Promise: vždy vracejte nebo await; zachytit chyby (.catch / try/catch), vyvarovat se „floating promises“.
• Přetěžování klienta JS: minimalizovat bundle, serverové renderování, rozumné hydratační strategie.
• Nedůsledná typová smlouva: validovat vstupy na okraji aplikace, generovat typy ze schémat.

Checklist pro produkční JavaScript

1. Modulární kód v ESM, jasná veřejná API, tree-shakeable.
2. ESLint + Prettier v CI, jednotná pravidla kvality.
3. Testy (unit/integrace/E2E) a pokrytí klíčových cest.
4. Snížený „payload“ (code-split, lazy-load), dobré metriky LCP/INP.
5. Bezpečnostní hlavičky (CSP, COOP/COEP dle potřeby), audit závislostí.
6. Observabilita (logy, metriky, tracing), alerting a runbooky.
7. Automatizované buildy a release s rollbackem a feature flagy.

Závěr

JavaScript je univerzální runtime platforma se standardem, který se vyvíjí evolučně a s masivní podporou nástrojů. O úspěchu nerozhoduje jen znalost syntaxe, ale schopnost volit správné architektury, procesy a nástroje. S důrazem na kvalitu, bezpečnost, výkon a udržovatelnost může JavaScript poskytnout od lehkého interaktivního widgetu až po globálně škálující systémy špičkové uživatelské zkušenosti.