Takmer každá aplikácia napísaná v jazyku JavaScript do určitej miery pracuje s časmi alebo dátumami. Na začiatku to bolo obmedzené na vstavané rozhranie Date API. Toto API obsahuje základné funkcie, ale je dosť obmedzené v tom, čo dokáže. Knižnice tretích strán, ako je Moment.js, a neskôr vstavané API, ako napríklad Intl API a nové Temporal API, pridávajú oveľa väčšiu flexibilitu pri práci s časmi a dátumami. Vzostup a pád momentu.js Moment.js je JavaScriptová knižnica s výkonnými nástrojmi na prácu s časmi a dátumami. Zahŕňa chýbajúce funkcie zo základného rozhrania Date API, ako je manipulácia s časovým pásmom, a zjednodušuje mnohé bežné operácie. Moment obsahuje aj funkcie na formátovanie dátumov a časov. Stala sa široko používanou knižnicou v mnohých rôznych aplikáciách. Moment však mal aj svoj podiel na problémoch. Je to veľká knižnica a môže výrazne zvýšiť veľkosť balíka aplikácie. Keďže knižnica nepodporuje trepanie stromov (funkcia moderných zväzkov, ktorá dokáže odstrániť nepoužívané časti knižníc), je zahrnutá celá knižnica Moment, aj keď používate iba jednu alebo dve z jej funkcií. Ďalším problémom s Momentom je skutočnosť, že objekty, ktoré vytvára, sú meniteľné. Volanie určitých funkcií na objekt Moment má vedľajšie účinky a mení hodnotu tohto objektu. To môže viesť k neočakávanému správaniu alebo chybám. V roku 2020 sa správcovia Momentu rozhodli uviesť knižnicu do režimu údržby. Nevyvíja sa žiadna nová funkcia a správcovia ju neodporúčajú používať na nové projekty. Existujú ďalšie knižnice dátumov JavaScriptu, ako napríklad date-fns, ale v meste je nový hráč, rozhranie API zabudované priamo do JavaScriptu: Temporal. Je to nový štandard, ktorý vypĺňa diery v pôvodnom rozhraní Date API a zároveň rieši niektoré obmedzenia nachádzajúce sa v knižniciach Moment a iných. Čo je dočasné? Temporal je nové rozhranie API pre čas a dátum, ktoré sa pridáva do štandardu ECMAScript, ktorý definuje moderný JavaScript. V marci 20266 dosiahol 4. štádium procesu TC39 (výbor, ktorý dohliada na návrhy a doplnky k jazyku JavaScript) a bude zahrnutý do ďalšej verzie špecifikácie ECMAScript. Už bol implementovaný vo viacerých prehliadačoch: Chrome 144+ a Firefox 139+, pričom sa očakáva, že čoskoro bude nasledovať aj Safari. Polyfill je k dispozícii aj pre nepodporované prehliadače a Node.js. Temporal API vytvára objekty, ktoré vo všeobecnosti predstavujú časové okamihy. Môžu to byť pečiatky na plný úväzok a dátumové pečiatky v danom časovom pásme, alebo to môže byť všeobecná inštancia času „nástenných hodín“ bez akýchkoľvek informácií o časovom pásme alebo dátume. Niektoré z hlavných funkcií Temporal zahŕňajú:
Časy s dátumami alebo bez nich. Dočasný objekt môže predstavovať konkrétny čas v konkrétny dátum alebo čas bez akýchkoľvek informácií o dátume. Môže byť znázornený aj konkrétny dátum bez času. Podpora časových pásiem. Časové objekty sú plne informované o časovom pásme a možno ich previesť v rôznych časových pásmach. Moment podporuje aj časové pásma, ale vyžaduje dodatočnú knižnicu moment-časové pásmo. Immutability. Po vytvorení dočasného objektu ho nemožno zmeniť. Časová aritmetika alebo prevody časových pásiem nemenia základný objekt. Namiesto toho vygenerujú nový dočasný objekt. Indexovanie založené na 1. Bežným zdrojom chýb v rozhraní Date API (ako aj v prípade Moment) je, že mesiace sú indexované s nulou. To znamená, že január je mesiac 0, nie mesiac 1, ako všetci chápeme v reálnom živote. Temporal to rieši pomocou indexovania založeného na 1 – január je mesiac 1. Je zabudovaný do prehliadača. Keďže Temporal je rozhranie API v samotnom prehliadači, nepridáva nič k veľkosti balíka vašej aplikácie.
Je tiež dôležité poznamenať, že rozhranie Date API nezmizne. Zatiaľ čo Temporal nahrádza toto API, nie je odstránené ani zastarané. Mnoho aplikácií by sa pokazilo, keby prehliadače náhle odstránili Date API. Majte však tiež na pamäti, že Moment je teraz považovaný za starší projekt v režime údržby. Vo zvyšku článku sa pozrieme na niekoľko „receptov“ na migráciu kódu založeného na Momente do nového Temporal API. Začnime refaktorovať! Vytváranie objektov dátumu a času Predtým, ako budeme môcť manipulovať s dátumami a časmi, musíme vytvoriť objekty, ktoré ich reprezentujú. Ak chcete vytvoriť objekt Moment predstavujúci aktuálny dátum a čas, použite funkciu moment. const now = moment(); console.log(teraz); // Moment<2026-02-18T21:26:29-05:00>
Tento objekt je teraz možné podľa potreby formátovať alebo s ním manipulovať.
// prevod na UTC //varovanie: Toto zmutuje objekt Moment a uvedie ho do režimu UTC! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// vytlačí naformátovaný reťazec – všimnite si, že teraz sa používa čas UTC console.log(now.format('MM/DD/RRRR hh:mm:ss a')); // 19.02.2026 02:27:07
Kľúčová vec, ktorú si treba o Momente zapamätať, je, že objekt Moment vždy obsahuje informácie o čase a dátume. Ak potrebujete pracovať iba s časovými informáciami, je to zvyčajne v poriadku, ale môže to spôsobiť neočakávané správanie v situáciách, ako je letný čas alebo prestupné roky, kedy môže mať dátum vplyv na výpočty času. Temporal je flexibilnejší. Môžete vytvoriť objekt predstavujúci aktuálny dátum a čas vytvorením objektu Temporal.Instant. Toto predstavuje časový bod definovaný časom od „epochy“ (polnoc UTC 1. januára 1970). Temporal dokáže odkazovať na tento okamih v čase s presnosťou na nanosekundovej úrovni. const now = Temporal.Now.instant();
// pozri surové nanosekundy od epochy console.log(now.epochNanosekundy); // 1771466342612000000n
// formát pre UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// formát pre konkrétne časové pásmo console.log(now.toString({ časové pásmo: 'Amerika/New_York' })); // 2026-02-18T20:56:57.905-05:00
Objekty Temporal.Instant možno vytvoriť aj pre konkrétny čas a dátum pomocou statickej metódy from.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formátovanie okamihu v miestnom časovom pásme. Všimnite si, že toto iba riadi // formátovanie - nezmutuje objekt ako moment.utc. console.log(myInstant.toString({ časové pásmo: 'Amerika/New_York' })); // 2026-02-18T21:10:00-05:00
Môžete vytvárať aj iné typy dočasných objektov vrátane:
Temporal.PlainDate: Dátum bez informácií o čase. Temporal.PlainTime: Čas bez informácií o dátume. Temporal.ZonedDateTime: Dátum a čas v určitom časovom pásme.
Každá z nich má metódu from, ktorú možno volať s objektom špecifikujúcim dátum a/alebo čas, alebo reťazec dátumu na analýzu. // Len rande const today = Temporal.PlainDate.from({ rok: 2026, mesiac: 2, // všimnite si, že pre február používame 2 deň: 18 }); console.log(today.toString()); // 2026-02-18
// Len čas const lunchTime = Temporal.PlainTime.from({ hodina: 12 }); console.log(obed.čas.toString()); // 12:00:00
// Dátum a čas vo východnom časovom pásme USA const dueAt = Temporal.ZonedDateTime.from({ časové pásmo: 'Amerika/New_York', rok: 2026, mesiac: 3, deň: 1, hodina: 12, minúta: 0, sekunda: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Analýza Zaoberali sme sa programovým vytváraním informácií o dátume a čase. Teraz sa pozrime na analýzu. Analýza je jednou z oblastí, kde je Moment flexibilnejší ako vstavané Temporal API. Reťazec dátumu môžete analyzovať jeho odovzdaním funkcii moment. S jediným argumentom Moment očakáva reťazec dátumu ISO, ale môžete použiť alternatívne formáty, ak poskytnete druhý argument určujúci používaný formát dátumu.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/RR h:mm:ss');
console.log(isoDate); // Moment<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Moment<2026-02-21T09:00:00-05:00>
V starších verziách by Moment najlepšie odhadol, že analyzuje ľubovoľne naformátovaný dátumový reťazec. To môže viesť k nepredvídateľným výsledkom. Napríklad, je 02-03-2026 2. februára alebo 3. marca? Z tohto dôvodu novšie verzie aplikácie Moment zobrazujú výrazné upozornenie na ukončenie podpory, ak sa volá bez reťazca dátumu vo formáte ISO (pokiaľ nie je uvedený aj druhý argument s požadovaným formátom). Temporal analyzuje iba špecificky naformátovaný dátumový reťazec. Reťazec musí byť v súlade s formátom ISO 8601 alebo jeho rozšírením RFC 9557. Ak sa do metódy from odovzdá nevyhovujúci dátumový reťazec, Temporal vyvolá chybu RangeError.
// Použitie reťazca dátumu RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ časové pásmo: 'Amerika/New_York' })); // 2026-02-21T09:00:00-05:00
// Použitie neznámeho dátumu reťazca const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Dočasná chyba: Neplatný znak pri analýze hodnoty roku.
Presné požiadavky na dátumový reťazec závisia od toho, aký druh dočasného objektu vytvárate. Vo vyššie uvedenom príklade vyžaduje Temporal.Instant úplné ISO8601 alebo RFC 9557 dátumový reťazec určujúci dátum a čas s posunom časového pásma, ale môžete tiež vytvoriť objekty PlainDate alebo PlainTime iba pomocou podmnožiny formátu dátumu. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Upozorňujeme, že tieto reťazce musia stále zodpovedať očakávanému formátu, inak sa zobrazí chyba.
// Použitie nevyhovujúcich časových reťazcov. To všetko vyvolá chybu RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Tip pre profesionálov: Zaobchádzanie s reťazcami, ktoré nie sú ISO, Pretože Temporal uprednostňuje spoľahlivosť, nebude sa snažiť uhádnuť formát reťazca ako 02-01-2026. Ak váš zdroj údajov používa takéto reťazce, budete musieť vykonať nejakú manipuláciu s reťazcami, aby ste preusporiadali hodnoty do reťazca ISO, napríklad 2026-02-01, skôr než sa ho pokúsite použiť s Temporal.
Formátovanie Keď budete mať objekt Moment alebo Temporal, pravdepodobne ho budete chcieť v určitom okamihu previesť na formátovaný reťazec. Toto je prípad, keď je Moment o niečo stručnejší. Zavoláte metódu formátu objektu pomocou reťazca tokenov, ktoré popisujú požadovaný formát dátumu. const date = moment();
console.log(date.format('MM/DD/RRRR')); // 22.02.2026
console.log(date.format('MMMM Do RRRR, h:mm:ss a')); // 22. februára 2026, 20:18:30
Na druhej strane, Temporal vyžaduje, aby ste boli o niečo podrobnejší. Dočasné objekty, ako napríklad Instant, majú metódu toLocaleString, ktorá akceptuje rôzne možnosti formátovania špecifikované ako vlastnosti objektu.
const date = Temporal.Now.instant();
// bez argumentov získame predvolený formát pre aktuálne miestne nastavenie console.log(date.toLocaleString()); // 22/2/2026, 20:23:36 (za predpokladu, že miestne nastavenie je en-US)
// odovzdanie možností formátovania na vygenerovanie vlastného formátovacieho reťazca console.log(date.toLocaleString('en-US', { mesiac: 'dlhý', deň: 'číselný', rok: 'numeric', hodina: '2-miestne', minúta: „2-miestne“ })); // 22. februára 2026 o 20:23
// vo formátovacom reťazci odovzdajte iba polia, ktoré chcete console.log(date.toLocaleString('en-US', { mesiac: 'krátky', deň: 'numeric' })); // 22. február
Časové formátovanie dátumu v skutočnosti využíva rozhranie Intl.DateTimeFormat API (ktoré je už ľahko dostupné v moderných prehliadačoch). To znamená, že môžete vytvoriť opakovane použiteľný objekt DateTimeFormat s vlastnými možnosťami formátovania a potom odovzdať dočasné objekty jeho metóde formátovania. Z tohto dôvodu nepodporuje vlastné formáty dátumu ako Moment. Ak potrebujete niečo ako „1. štvrťrok 2026“ alebo iné špecializované formátovanie, možno budete potrebovať vlastný kód na formátovanie dátumu alebo siahnuť po knižnici tretej strany. const formatter = new Intl.DateTimeFormat('en-US', { mesiac: '2-miestne', deň: '2-miestne', rok: 'numeric' });
const date = Temporal.Now.instant(); console.log(formatter.format(date)); // 22.02.2026
Tokeny formátovania Moment sa píšu jednoduchšie, ale nie sú vhodné pre miestne nastavenia. Formát reťazcov „pevný kód“ vecí, ako je poradie mesiaca/dňa. Výhodou použitia konfiguračného objektu, ako to robí Temporal, je, že sa automaticky prispôsobí akémukoľvek danému miestu a použije správny formát. const date = Temporal.Now.instant();
const formatOptions = { mesiac: 'numeric', deň: 'číselný', rok: 'numeric' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.2.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Výpočty dátumov V mnohých aplikáciách budete musieť dokončiť nejaké výpočty v dátume. Možno budete chcieť pridať alebo odčítať jednotky času (dni, hodiny, sekundy atď.). Ak máte napríklad aktuálny dátum, možno budete chcieť používateľovi zobraziť dátum o 1 týždeň. Momentové objekty majú metódy ako sčítanie a odčítanie, ktoré vykonávajú tieto operácie. Tieto funkcie majú hodnotu a jednotku, napríklad: add(7, 'dni'). Jedným veľmi dôležitým rozdielom medzi Moment a Temporal je však to, že pri vykonávaní týchto výpočtov dátumu sa základný objekt upraví a jeho pôvodná hodnota sa stratí. const now = moment();
console.log(teraz); // Moment<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dni'); console.log(budúci týždeň); // Moment<2026-03-03T20:08:36-05:00>
// Gotcha - pôvodný objekt bol zmutovaný console.log(teraz); // Moment<2026-03-03T20:08:36-05:00>
Aby ste predišli strate pôvodného dátumu, môžete zavolať klon na objekt Moment a vytvoriť kópiu. konšt= moment(); const nextWeek = now.clone().add(7, 'dni');
console.log(teraz); // Moment<2026-02-24T20:12:55-05:00>
console.log(budúci týždeň); // Moment<2026-03-03T20:12:55-05:00>
Na druhej strane, dočasné objekty sú nemenné. Po vytvorení objektu ako Instant, PlainDate atď. sa hodnota tohto objektu nikdy nezmení. Časové objekty majú tiež metódy sčítania a odčítania. Temporal je trochu vyberavý, pokiaľ ide o to, ktoré časové jednotky možno pridať ku ktorým typom objektov. Do okamžitého okna napríklad nemôžete pridať dni:
const now = Temporal.Now.instant(); const nextWeek = now.add({ days: 7 }); // RangeError: Dočasná chyba: Najväčšia jednotka nemôže byť jednotkou dátumu
Je to preto, že objekty Instant predstavujú konkrétny bod v čase v UTC a sú agnostické pre kalendár. Keďže dĺžka dňa sa môže meniť na základe pravidiel časového pásma, ako je napríklad letný čas, tento výpočet nie je k dispozícii v okamžitom režime. Túto operáciu však môžete vykonať na iných typoch objektov, ako je napríklad PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.2.2026, 20:23:59
const nextWeek = now.add({ days: 7 });
// Všimnite si, že pôvodný PlainDateTime zostáva nezmenený console.log(now.toLocaleString()); // 24.2.2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3. 3. 2026, 20:23:59
Môžete tiež vypočítať, koľko času je medzi dvoma objektmi Moment alebo Temporal. S funkciou rozdielu Momentu musíte poskytnúť jednotku podrobnosti, inak vráti rozdiel v milisekundách. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'dni')); // 1
Ak to chcete urobiť s objektom Temporal, môžete do jeho metód do alebo od odovzdať iný objekt Temporal. Toto vráti objekt Temporal.Duration obsahujúci informácie o časovom rozdiele. Objekt Duration má vlastnosti pre každú zložku rozdielu a môže tiež vygenerovať reťazec trvania ISO 8601 predstavujúci časový rozdiel.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// najväčšia jednotka určuje najväčšiu jednotku času, ktorá sa má reprezentovať // vo výpočte trvania const diff = date2.since(dátum1, { najväčšiaJednotka: 'deň' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(rozdiel.minúty); // 30
console.log(diff.toString()); // P1DT1H30M // (reťazec trvania ISO 8601: 1 deň, 1 hodina, 30 minút)
Porovnanie dátumov a časov Moment a Temporal vám umožňujú porovnávať dátumy a časy, aby ste určili, ktorý čas predchádza druhému, ale používajú rôzne prístupy k API. Moment poskytuje metódy ako isBefore, isAfter a isSame na porovnanie dvoch objektov Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // pravda
Temporal používa metódu statického porovnávania na vykonanie porovnania medzi dvoma objektmi rovnakého typu. Vráti -1, ak je prvý dátum pred druhým, 0, ak sú rovnaké, alebo 1, ak prvý dátum nasleduje po druhom. Nasledujúci príklad ukazuje, ako porovnať dva objekty PlainDate. Oba argumenty Temporal.PlainDate.compare musia byť objekty PlainDate.
const date1 = Temporal.PlainDate.from({ rok: 2026, mesiac: 2, deň: 24 }); const date2 = Temporal.PlainDate.from({ rok: 2026, mesiac: 3, deň: 24 });
// dátum1 predchádza dátum2, teda -1 console.log(Temporal.PlainDate.compare(dátum1, dátum2));
// Chyba, ak sa pokúšame porovnať dva objekty rôznych typov console.log(Temporal.PlainDate.compare(dátum1, Temporal.Now.instant())); // TypeError: Dočasná chyba: Boli poskytnuté neplatné polia PlainDate.
Najmä to uľahčuje chronologické triedenie poľa časových objektov. // Pole objektov Temporal.PlainDate konštantné dátumy = [ ... ];
// použite Temporal.PlainDate.compare ako funkciu porovnávača dátumy.zoradiť(Časový.ObyčajnýDátum.porovnať);
Konverzie časového pásma Hlavná knižnica Moment nepodporuje konverzie časových pásiem. Ak potrebujete túto funkciu, musíte si nainštalovať aj balík moment-timezone. Tento balík nie je otrasiteľný, a preto môže výrazne zvýšiť veľkosť balíka. Po nainštalovaní moment-časového pásma môžete previesť objekty Moment do rôznych časových pásiem pomocou metódy tz. Rovnako ako pri iných operáciách Moment, toto mutuje podkladobjekt. // Za predpokladu východného času USA const now = moment(); console.log(teraz); // Moment<2026-02-28T20:08:20-05:00>
// Prevod na tichomorský čas. // Pôvodný východný čas je stratený. now.tz('Amerika/Los_Angeles'); console.log(teraz); // Moment<2026-02-28T17:08:20-08:00>
Funkcia časového pásma je zabudovaná do Temporal API pri použití objektu Temporal.ZonedDateTime. Tieto objekty zahŕňajú metódu withTimeZone, ktorá vracia nový ZonedDateTime predstavujúci rovnaký okamih v čase, ale v určenom časovom pásme. // Opäť za predpokladu východného času USA const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28. 2. 2026, 20:12:02 EST
// Prevod na tichomorský čas const nowPacific = now.withTimeZone('Amerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28. 2. 2026, 17:12:02 PST
// Pôvodný objekt zostáva nezmenený console.log(now.toLocaleString()); // 28. 2. 2026, 20:12:02 EST
Poznámka: Formátované hodnoty vrátené toLocaleString sú, ako už názov napovedá, závislé od miestnych nastavení. Vzorový kód bol vyvinutý v lokálnom prostredí en-US, takže formát je takýto: 2/28/2026, 17:12:02 PST. V inom prostredí to môže byť iné. Napríklad v lokálnom nastavení en-GB by ste dostali niečo ako 28/2/2026, 17:12:02 GMT-8. Refaktoring v reálnom svete Predpokladajme, že vytvárame aplikáciu na plánovanie udalostí v rôznych časových pásmach. Súčasťou tejto aplikácie je funkcia getEventTimes, ktorá preberá reťazec ISO 8601 predstavujúci čas a dátum udalosti, miestne časové pásmo a cieľové časové pásmo. Funkcia vytvorí formátované reťazce času a dátumu pre udalosť v oboch časových pásmach. Ak funkcia dostane vstupný reťazec, ktorý nie je platným reťazcom času a dátumu, vyvolá chybu. Tu je pôvodná implementácia pomocou Moment (vyžaduje aj použitie balíka moment-timezone).
importovať moment z „moment-timezone“;
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Vytvorte počiatočný moment v časovom pásme používateľa const eventTime = moment.tz( inputString, moment.ISO_8601, // Očakávajte reťazec ISO 8601 true, // Striktná analýza userTimeZone );
// Vyvolá chybu, ak inputString nepredstavuje platný dátum if (!eventTime.isValid()) { throw new Error('Neplatný dátum/čas'); }
// 2. Vypočítajte cieľový čas // KRITICKÉ: Musíme klonovať, inak sa „čas udalosti“ navždy zmení! const targetTime = eventTime.clone().tz(targetTimeZone);
vrátiť { local: eventTime.format(timeFormat), cieľ: targetTime.format(timeFormat), }; }
const harmonogram = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', "Európa/Londýn", );
console.log(schedule.local); // 5. marec 2026, 15:00:00 EST
console.log(schedule.target); // 5. marec 2026, 20:00:00 GMT
V tomto príklade používame očakávaný formát dátumu ISO 8601, ktorý je užitočne zabudovaný do Moment. Používame aj striktnú analýzu, čo znamená, že Moment sa nebude pokúšať uhádnuť pomocou reťazca dátumu, ktorý nezodpovedá formátu. Ak sa odošle reťazec dátumu, ktorý nie je ISO, bude to mať za následok neplatný dátumový objekt a vyvoláme chybu. Implementácia Temporal vyzerá podobne, má však niekoľko kľúčových rozdielov.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analyzujte vstup priamo do Instant a potom vytvorte // ZonedDateTime v zóne používateľa. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Konvertujte na cieľovú zónu // Toto automaticky vráti NEW objekt; 'eventTime' je bezpečné. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formátovanie pomocou Intl (vstavané) const options = { rok: 'numeric', mesiac: 'krátky', deň: 'číselný', hodina: 'numeric', minúta: '2-miestne', druhý: '2-miestne', timeZoneName: 'short' };
vrátiť { local: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, options) }; }
const harmonogram = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Európa/Londýn', );
console.log(schedule.local); // 5. marec 2026, 15:00:00 EST
console.log(schedule.target); // 5. marec 2026, 20:00:00 GMT
V programe Moment musíme explicitne špecifikovať formátovací reťazec pre výsledné dátumové reťazce. Bez ohľadu na polohu alebo miestne nastavenie používateľa budú časy udalostí vždy vo formáte 5. marca 2026, 3:00:00pm EST. Okrem toho nemusíme výslovne hádzať výnimku. Ak sa do Temporal.Instant.from odošle neplatný reťazec, Temporal nám vyvolá výnimku. Jedna vec, ktorú treba poznamenať, je, že aj pri prísnej analýze je verzia Moment stále miernejšia. Temporal vyžaduje posun časového pásma na konci reťazca. Mali by ste tiež poznamenať, že keďže používame navigator.language, tento kód sa spustí iba v prostredí prehliadača, keďže navigátor nie je definovaný v prostredí Node.js. Implementácia Temporal používa aktuálne miestne nastavenie prehliadača (navigator.language), takže používateľ automaticky získa časy udalostí vo formáte miestneho času. V národnom prostredí en-US je to 5. marec 2026, 15:00:00 EST. Ak sa však používateľ nachádza napríklad v Londýne, časy udalostí budú vo formáte 5. marca 2026, 15:00:00 GMT-5. Zhrnutie
Akcia Moment.js Časový Aktuálny čas moment() Temporal.Now.zonedDateTimeISO() Analýza ISO moment(str) Temporal.Instant.from(str) Pridajte čas .add(7, 'dni') (mutuje) .add({ dní: 7 }) (nový objekt) Rozdiel .diff(ostatné, 'hodiny') .od(ostatných).hodín Časové pásmo .tz('Zóna/Názov') .withTimeZone('Zone/Name')
Na prvý pohľad môže byť rozdiel mierne odlišný (a v prípade Temporal niekedy podrobnejší a prísnejší) syntax, no používanie Temporal oproti Moment.js má niekoľko kľúčových výhod:
Byť explicitnejší znamená menej prekvapení a neúmyselných chýb. Moment sa môže zdať zhovievavejší, ale zahŕňa „dohady“, ktoré môžu niekedy viesť k nesprávnym dátumom. Ak dáte Temporal niečo neplatné, vyhodí chybu. Ak sa kód spustí, viete, že máte platný dátum. Moment môže pridať významnú veľkosť balíku aplikácie, najmä ak používate balík moment-timezone. Temporal nič nepridáva (po odoslaní do vašich cieľových prehliadačov). Nemennosť vám dáva istotu, že pri vykonávaní konverzií dátumov a operácií nikdy nestratíte ani neprepíšete údaje. Rôzne zobrazenia času (Okamžité, PlainDateTime, ZonedDateTime) v závislosti od vašich požiadaviek, kde Moment je vždy obal okolo časovej pečiatky UTC. Temporal používa Intl API na formátovanie dátumu, čo znamená, že môžete mať formátovanie s ohľadom na miestne nastavenie bez toho, aby ste museli explicitne špecifikovať tokeny.
Poznámky k Polyfill Ako už bolo spomenuté, k dispozícii je Temporal polyfill distribuovaný ako balík npm s názvom @js-temporal/polyfill. Ak chcete dnes používať Temporal, budete potrebovať túto polyfill na podporu prehliadačov, ako je Safari, ktoré ešte nedodali API. Zlou správou je, že sa tým zvýši veľkosť vášho balíka. Dobrou správou je, že stále pridáva podstatne menej ako moment alebo moment-timezone. Tu je porovnanie veľkostí balíkov, ako ich uvádza Bundlephobia.com, webová stránka, ktorá prezentuje informácie o veľkostiach balíkov npm (kliknutím na názov každého balíka zobrazíte analýzu balíkov):
Balíček Minifikované Minifikované a gzipované @js-temporal/polyfill 154,1 kB 44,1 kB moment 294,4 kB 75,4 kB moment-časové pásmo 1 MB 114,2 kB
Polyfill má tiež historicky určité problémy s výkonom v súvislosti s využívaním pamäte a v čase písania tohto článku sa považuje za v stave alfa. Z tohto dôvodu ho možno nebudete chcieť použiť vo výrobe, kým nedosiahne zrelší stav. Ďalšou dobrou správou je, že dúfajme, že polyfill už nebude potrebný oveľa dlhšie (pokiaľ samozrejme nepotrebujete podporovať staršie prehliadače). V čase písania tohto článku bol Temporal dodávaný v prehliadačoch Chrome, Edge a Firefox. V prehliadači Safari ešte nie je úplne pripravený, aj keď sa zdá, že je k dispozícii s príznakom runtime v najnovšej ukážke technológie.
