Téměř každá aplikace napsaná v JavaScriptu do určité míry pracuje s časy nebo daty. Na začátku to bylo omezeno na vestavěné rozhraní Date API. Toto API obsahuje základní funkce, ale je dosti omezené v tom, co dokáže. Knihovny třetích stran, jako je Moment.js, a později vestavěná rozhraní API, jako jsou Intl API a nové Temporal API, přidávají mnohem větší flexibilitu při práci s časy a daty. Vzestup a pád Moment.js Moment.js je JavaScriptová knihovna s výkonnými nástroji pro práci s časy a daty. Zahrnuje chybějící funkce ze základního rozhraní Date API, jako je manipulace s časovým pásmem, a zjednodušuje mnoho běžných operací. Moment také obsahuje funkce pro formátování data a času. Stala se široce používanou knihovnou v mnoha různých aplikacích. Moment však měl také svůj podíl na problémech. Je to velká knihovna a může výrazně zvýšit velikost balíčku aplikace. Protože knihovna nepodporuje protřepávání stromu (funkce moderních svazků, která dokáže odstranit nepoužívané části knihoven), je zahrnuta celá knihovna Moment, i když používáte pouze jednu nebo dvě její funkce. Dalším problémem s Momentem je skutečnost, že objekty, které vytváří, jsou proměnlivé. Volání určitých funkcí na objektu Moment má vedlejší účinky a mutuje hodnotu tohoto objektu. To může vést k neočekávanému chování nebo chybám. V roce 2020 se správci Momentu rozhodli uvést knihovnu do režimu údržby. Žádné nové funkce se nevyvíjejí a správci doporučují nepoužívat je pro nové projekty. Existují další knihovny data JavaScript, jako je date-fns, ale ve městě je nový hráč, API zabudované přímo do JavaScriptu: Temporal. Je to nový standard, který vyplňuje díry původního Date API a také řeší některá omezení nalezená v Moment a dalších knihovnách. Co je temporální? Temporal je nové rozhraní API pro čas a datum, které se přidává do standardu ECMAScript, který definuje moderní JavaScript. V březnu 20266 dosáhl 4. fáze procesu TC39 (výbor, který dohlíží na návrhy a doplňky jazyka JavaScript) a bude zahrnut do další verze specifikace ECMAScript. Byl již implementován v několika prohlížečích: Chrome 144+ a Firefox 139+, přičemž se očekává, že brzy bude následovat Safari. Polyfill je k dispozici také pro nepodporované prohlížeče a Node.js. Temporal API vytváří objekty, které obecně představují okamžiky v čase. Mohou to být razítka na plný úvazek a datum v daném časovém pásmu, nebo to může být obecný příklad času „nástěnných hodin“ bez jakýchkoli informací o časovém pásmu nebo datu. Některé z hlavních funkcí Temporal zahrnují:
Časy s datem nebo bez něj. Časový objekt může představovat konkrétní čas v určité datum nebo čas bez jakýchkoli informací o datu. Může být také uvedeno konkrétní datum bez času. Podpora časových pásem. Časové objekty jsou plně informovány o časovém pásmu a lze je převádět v různých časových pásmech. Moment podporuje také časová pásma, ale vyžaduje další knihovnu moment-časové pásmo. Immutability. Jakmile je vytvořen Temporal objekt, nelze jej změnit. Časová aritmetika nebo převody časového pásma nemění základní objekt. Místo toho vygenerují nový dočasný objekt. Indexování založené na 1. Běžným zdrojem chyb s Date API (stejně jako s Momentem) je, že měsíce jsou indexovány nulově. To znamená, že leden je měsíc 0, spíše než měsíc 1, jak všichni chápeme v reálném životě. Temporal to řeší pomocí indexování založeného na 1 – leden je 1. měsíc. Je zabudován do prohlížeče. Vzhledem k tomu, že Temporal je rozhraní API v samotném prohlížeči, nepřidává nic k velikosti balíčku vaší aplikace.
Je také důležité poznamenat, že rozhraní Date API nezmizí. I když Temporal nahrazuje toto API, není odstraněno ani zastaralé. Mnoho aplikací by se zlomilo, kdyby prohlížeče náhle odstranily rozhraní Date API. Mějte však také na paměti, že Moment je nyní v režimu údržby považován za starší projekt. Ve zbytku článku se podíváme na některé „recepty“ pro migraci kódu založeného na Momentu do nového Temporal API. Začněme refaktorovat! Vytváření objektů data a času Než budeme moci manipulovat s daty a časy, musíme vytvořit objekty, které je představují. Chcete-li vytvořit objekt Moment představující aktuální datum a čas, použijte funkci moment. const now = moment(); console.log(nyní); // Moment<2026-02-18T21:26:29-05:00>
Tento objekt lze nyní podle potřeby formátovat nebo s ním manipulovat.
// převod na UTC //varování: To zmutuje objekt Moment a přepne jej do režimu UTC! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// vytiskne formátovaný řetězec - všimněte si, že nyní používá čas UTC console.log(now.format('MM/DD/RRRR hh:mm:ss a')); // 19.02.2026 02:27:07
Klíčová věc, kterou je třeba si u Moment zapamatovat, je, že objekt Moment vždy obsahuje informace o čase a datu. Pokud potřebujete pracovat pouze s časovými informacemi, je to obvykle v pořádku, ale může to způsobit neočekávané chování v situacích, jako je letní čas nebo přestupné roky, kdy datum může mít vliv na výpočty času. Temporal je flexibilnější. Můžete vytvořit objekt představující aktuální datum a čas vytvořením objektu Temporal.Instant. To představuje bod v čase definovaný časem od „epochy“ (půlnoc UTC 1. ledna 1970). Temporal dokáže odkazovat na tento okamžik v čase s přesností na úrovni nanosekund. const now = Temporal.Now.instant();
// vidět surové nanosekundy od epochy console.log(now.epochNanosekundy); // 1771466342612000000n
// formát pro UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// formát pro konkrétní časové pásmo console.log(now.toString({ timeZone: 'Amerika/New_York' })); // 2026-02-18T20:56:57.905-05:00
Objekty Temporal.Instant lze také vytvořit pro konkrétní čas a datum pomocí statické metody from.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Naformátujte okamžik v místním časovém pásmu. Všimněte si, že toto pouze řídí // formátování - nezmutuje objekt jako moment.utc. console.log(myInstant.toString({ časové pásmo: 'Amerika/New_York' })); // 2026-02-18T21:10:00-05:00
Můžete také vytvářet další typy dočasných objektů, včetně:
Temporal.PlainDate: Datum bez informací o čase. Temporal.PlainTime: Čas bez informací o datu. Temporal.ZonedDateTime: Datum a čas v určitém časovém pásmu.
Každá z nich má metodu from, kterou lze volat s objektem určujícím datum a/nebo čas nebo řetězcem data k analýze. // Jen rande const today = Temporal.PlainDate.from({ rok: 2026, měsíc: 2, // všimněte si, že pro únor používáme 2 den: 18 }); console.log(today.toString()); // 2026-02-18
// Jen čas const lunchTime = Temporal.PlainTime.from({ hodina: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Datum a čas ve východním časovém pásmu USA const dueAt = Temporal.ZonedDateTime.from({ časové pásmo: 'Amerika/New_York', rok: 2026, měsíc: 3, den: 1, hodina: 12, minuta: 0, sekunda: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/New_York]
Analýza Zabývali jsme se programovým vytvářením informací o datu a čase. Nyní se podívejme na analýzu. Analýza je jednou z oblastí, kde je Moment flexibilnější než vestavěné Temporal API. Řetězec data můžete analyzovat tak, že jej předáte funkci moment. S jediným argumentem Moment očekává řetězec data ISO, ale můžete použít alternativní formáty, pokud zadáte druhý argument určující používaný formát data.
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>
Ve starších verzích by Moment nejlépe odhadl, že analyzuje libovolný libovolně formátovaný řetězec data. To by mohlo vést k nepředvídatelným výsledkům. Je například 02-03-2026 2. února nebo 3. března? Z tohoto důvodu novější verze aplikace Moment zobrazují výrazné upozornění na ukončení podpory, pokud je volána bez řetězce data ve formátu ISO (pokud není uveden také druhý argument s požadovaným formátem). Temporal analyzuje pouze specificky formátovaný řetězec data. Řetězec musí být v souladu s formátem ISO 8601 nebo jeho rozšířením RFC 9557. Pokud je do metody from předán nevyhovující řetězec data, Temporal vyvolá chybu RangeError.
// Použití řetězce data RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ timeZone: 'Amerika/New_York' })); // 2026-02-21T09:00:00-05:00
// Použití neznámého data řetězce const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Dočasná chyba: Neplatný znak při analýze hodnoty roku.
Přesné požadavky na řetězec data závisí na tom, jaký druh dočasného objektu vytváříte. Ve výše uvedeném příkladu vyžaduje Temporal.Instant úplné ISO8601 nebo RFC 9557 datový řetězec určující datum a čas s posunem časového pásma, ale můžete také vytvořit objekty PlainDate nebo PlainTime pouze pomocí podmnožiny formátu data. 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
Pamatujte, že tyto řetězce musí stále odpovídat očekávanému formátu, jinak dojde k chybě.
// Použití nevyhovujících časových řetězců. To vše vyvolá chybu RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Tip pro profesionály: Manipulace s řetězci bez ISO Protože Temporal upřednostňuje spolehlivost, nebude se snažit uhodnout formát řetězce jako 02-01-2026. Pokud váš zdroj dat používá takové řetězce, budete muset provést nějakou manipulaci s řetězci, abyste přeuspořádali hodnoty do řetězce ISO, jako je 2026-02-01, než se jej pokusíte použít s Temporal.
Formatting Jakmile budete mít objekt Moment nebo Temporal, pravděpodobně jej budete chtít v určitém okamžiku převést na formátovaný řetězec. Toto je příklad, kdy je Moment trochu stručnější. Voláte metodu formátu objektu pomocí řetězce tokenů, které popisují požadovaný formát data. 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. února 2026, 20:18:30
Na druhou stranu Temporal vyžaduje, abyste byli trochu podrobnější. Dočasné objekty, jako je Instant, mají metodu toLocaleString, která přijímá různé možnosti formátování zadané jako vlastnosti objektu.
const date = Temporal.Now.instant();
// bez argumentů získáme výchozí formát pro aktuální národní prostředí console.log(date.toLocaleString()); // 22. 2. 2026, 20:23:36 (předpokládá se národní prostředí en-US)
// předá možnosti formátování pro vygenerování vlastního formátovacího řetězce console.log(date.toLocaleString('en-US', { měsíc: 'dlouhý', den: 'numeric', rok: 'numeric', hour: '2-digit', minuta: '2místné' })); // 22. února 2026 ve 20:23
// ve formátovacím řetězci předá pouze pole, která chcete console.log(date.toLocaleString('en-US', { měsíc: 'krátký', den: 'numeric' })); // 22. února
Časové formátování data ve skutečnosti využívá API Intl.DateTimeFormat (které je již snadno dostupné v moderních prohlížečích). To znamená, že můžete vytvořit znovu použitelný objekt DateTimeFormat s vlastními možnostmi formátování a poté předat dočasné objekty jeho metodě formátování. Z tohoto důvodu nepodporuje vlastní formáty data jako Moment. Pokud potřebujete něco jako 'Q1 2026' nebo jiné specializované formátování, možná budete potřebovat nějaký vlastní kód pro formátování data nebo sáhnout po knihovně třetí strany. const formatter = new Intl.DateTimeFormat('en-US', { měsíc: '2místný', den: '2místný', rok: 'numeric' });
const date = Temporal.Now.instant(); console.log(formatter.format(datum)); // 22.02.2026
Formátovací tokeny Moment jsou jednodušší na zápis, ale nejsou vhodné pro místní prostředí. Formát řetězců „pevný kód“ věci, jako je pořadí měsíce/den. Výhodou použití konfiguračního objektu, jako to dělá Temporal, je, že se automaticky přizpůsobí jakémukoli danému národnímu prostředí a použije správný formát. const date = Temporal.Now.instant();
const formatOptions = { měsíc: 'numeric', den: 'numeric', rok: 'numeric' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.2.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22. 2. 2026
Výpočty data In many applications, you’ll need to end up performing some calculations on a date. Možná budete chtít přidat nebo odečíst jednotky času (dny, hodiny, sekundy atd.). Pokud máte například aktuální datum, možná budete chtít uživateli zobrazit datum za 1 týden. Objekty Moment mají metody, jako je sčítání a odečítání, které tyto operace provádějí. Tyto funkce mají hodnotu a jednotku, například: add(7, 'dny'). Jedním z velmi důležitých rozdílů mezi Moment a Temporal je však to, že při provádění těchto výpočtů data je základní objekt upraven a jeho původní hodnota je ztracena. const now = moment();
console.log(nyní); // Moment<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dny'); console.log(příštítýden); // Moment<2026-03-03T20:08:36-05:00>
// Gotcha - původní objekt byl zmutován console.log(nyní); // Moment<2026-03-03T20:08:36-05:00>
Chcete-li předejít ztrátě původního data, můžete zavolat klonování objektu Moment a vytvořit kopii. nyní konst= moment(); const nextWeek = now.clone().add(7, 'dny');
console.log(nyní); // Moment<2026-02-24T20:12:55-05:00>
console.log(příštítýden); // Moment<2026-03-03T20:12:55-05:00>
Na druhou stranu, dočasné objekty jsou neměnné. Jakmile vytvoříte objekt, jako je Instant, PlainDate a tak dále, hodnota tohoto objektu se nikdy nezmění. Časové objekty mají také metody sčítání a odečítání. Temporal je trochu vybíravý v tom, jaké časové jednotky lze přidat ke kterým typům objektů. Do okamžitého okamžiku například nemůžete přidat dny:
const now = Temporal.Now.instant(); const nextWeek = now.add({ days: 7 }); // RangeError: Dočasná chyba: Největší jednotka nemůže být jednotkou data
Je to proto, že objekty Instant představují konkrétní časový bod v UTC a jsou agnostické pro kalendář. Vzhledem k tomu, že délka dne se může měnit na základě pravidel časového pásma, jako je letní čas, není tento výpočet v Instanci dostupný. Tuto operaci však můžete provést na jiných typech objektů, jako je PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24. 2. 2026, 20:23:59
const nextWeek = now.add({ days: 7 });
// Všimněte si, že původní PlainDateTime zůstává nezměněn console.log(now.toLocaleString()); // 24. 2. 2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3. 3. 2026, 20:23:59
Můžete také vypočítat, kolik času je mezi dvěma objekty Moment nebo Temporal. S funkcí rozdílu Momentu musíte zadat jednotku pro zrnitost, jinak vrátí rozdíl 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, 'dny')); // 1
Chcete-li to provést pomocí objektu Temporal, můžete předat jiný objekt Temporal jeho metodám till nebo since. Tím se vrátí objekt Temporal.Duration obsahující informace o časovém rozdílu. Objekt Duration má vlastnosti pro každou složku rozdílu a také může generovat řetězec trvání ISO 8601 představující časový rozdíl.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// největší jednotka určuje největší jednotku času, která má být reprezentována // ve výpočtu doby trvání const diff = datum2.od(datum1, { největšíJednotka: 'den' });
console.log(diff.days); // 1
console.log(rozdil.hodiny); // 1
console.log(rozdil.minuty); // 30
console.log(diff.toString()); // P1DT1H30M // (řetězec trvání ISO 8601: 1 den, 1 hodina, 30 minut)
Porovnání dat a časů Moment a Temporal vám umožňují porovnávat data a časy, abyste určili, který čas předchází druhému, ale používají různé přístupy k rozhraní API. Moment poskytuje metody jako isBefore, isAfter a isSame pro porovnání dvou objektů 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žívá metodu statického porovnání k provedení srovnání mezi dvěma objekty stejného typu. Vrátí -1, pokud je první datum před druhým, 0, pokud jsou stejné, nebo 1, pokud první datum následuje po druhém. Následující příklad ukazuje, jak porovnat dva objekty PlainDate. Oba argumenty pro Temporal.PlainDate.compare musí být objekty PlainDate.
const date1 = Temporal.PlainDate.from({ rok: 2026, měsíc: 2, den: 24 }); const date2 = Temporal.PlainDate.from({ rok: 2026, měsíc: 3, den: 24 });
// datum1 je před datem2, takže -1 console.log(Temporal.PlainDate.compare(datum1, datum2));
// Chyba, pokud se pokoušíme porovnat dva objekty různých typů console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Dočasná chyba: Byla zadána neplatná pole PlainDate.
Zejména to usnadňuje chronologické řazení řady Temporal objektů. // Pole objektů Temporal.PlainDate const date = [ ... ];
// jako funkci komparátoru použijte Temporal.PlainDate.compare data.sort(Dočasné.ObyčejnéDatum.porovnat);
Konverze časového pásma Základní knihovna momentů nepodporuje převody časových pásem. Pokud tuto funkci potřebujete, musíte si také nainstalovat balíček moment-timezone. Tento balíček není otřesitelný, a proto může výrazně zvětšit velikost vašeho balíčku. Jakmile nainstalujete moment-timezone, můžete převést objekty Moment do různých časových pásem pomocí metody tz. Stejně jako u jiných operací Moment toto mutuje podkladobjekt. // Za předpokladu východního času USA const now = moment(); console.log(nyní); // Moment<2026-02-28T20:08:20-05:00>
// Převod na tichomořský čas. // Původní východní čas je ztracen. now.tz('Amerika/Los_Angeles'); console.log(nyní); // Moment<2026-02-28T17:08:20-08:00>
Funkce časového pásma je zabudována do Temporal API při použití objektu Temporal.ZonedDateTime. Tyto objekty zahrnují metodu withTimeZone, která vrací nový ZonedDateTime představující stejný okamžik v čase, ale v určeném časovém pásmu. // Opět za předpokladu východního času USA const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28. 2. 2026, 20:12:02 EST
// Převod na tichomořský čas const nowPacific = now.withTimeZone('Amerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28. 2. 2026, 17:12:02 PST
// Původní objekt zůstane nezměněn console.log(now.toLocaleString()); // 28. 2. 2026, 20:12:02 EST
Poznámka: Formátované hodnoty vrácené toLocaleString jsou, jak název napovídá, závislé na národním prostředí. Ukázkový kód byl vyvinut v národním prostředí en-US, takže formát je tento: 2/28/2026, 17:12:02 PST. V jiném národním prostředí to může být jiné. Například v národním prostředí en-GB byste získali něco jako 28/2/2026, 17:12:02 GMT-8. Refaktoring v reálném světě Předpokládejme, že vytváříme aplikaci pro plánování událostí v různých časových pásmech. Součástí této aplikace je funkce getEventTimes, která přebírá řetězec ISO 8601 představující čas a datum události, místní časové pásmo a cílové časové pásmo. Funkce vytvoří formátované řetězce času a data pro událost v obou časových pásmech. Pokud funkce dostane vstupní řetězec, který není platným řetězcem času a data, vyvolá chybu. Zde je původní implementace pomocí Moment (také vyžadující použití balíčku moment-timezone).
importovat moment z 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Vytvořte počáteční okamžik v časovém pásmu uživatele const eventTime = moment.tz( inputString, moment.ISO_8601, // Očekávejte řetězec ISO 8601 true, // Přísná analýza userTimeZone );
// Vyvolá chybu, pokud inputString nepředstavuje platné datum if (!eventTime.isValid()) { throw new Error('Neplatný vstup data/času'); }
// 2. Vypočítejte cílový čas // KRITICKÉ: Musíme klonovat, nebo se 'čas události' navždy změní! const targetTime = eventTime.clone().tz(targetTimeZone);
vrátit { local: eventTime.format(timeFormat), cíl: targetTime.format(timeFormat), }; }
const harmonogram = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Evropa/Londýn', );
console.log(plán.místní); // 5. března 2026, 15:00:00 EST
console.log(schedule.target); // 5. března 2026, 20:00:00 GMT
V tomto příkladu používáme očekávaný formát data ISO 8601, který je užitečně integrován do Moment. Používáme také striktní analýzu, což znamená, že se Moment nebude snažit uhodnout pomocí řetězce data, který neodpovídá formátu. Pokud je předán řetězec data, který není ISO, bude to mít za následek neplatný objekt data a vyvoláme chybu. Implementace Temporal vypadá podobně, ale má několik klíčových rozdílů.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analyzujte vstup přímo do Instant a poté vytvořte // ZonedDateTime v zóně uživatele. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Převeďte do cílové zóny // Toto automaticky vrátí NEW objekt; 'eventTime' je bezpečné. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formátování pomocí Intl (vestavěné) const options = { rok: 'numeric', měsíc: 'krátký', den: 'numeric', hodina: 'numeric', minuta: '2místné', druhý: '2místné', timeZoneName: 'short' };
vrátit { local: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, options) }; }
const harmonogram = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Evropa/Londýn', );
console.log(plán.místní); // 5. března 2026, 15:00:00 EST
console.log(schedule.target); // 5. března 2026, 20:00:00 GMT
S Moment musíme explicitně specifikovat formátovací řetězec pro výsledné datové řetězce. Bez ohledu na polohu nebo národní prostředí uživatele budou časy událostí vždy ve formátu 5. března 2026, 3:00:00odpoledne EST. Také nemusíme explicitně vyvolávat výjimku. Pokud je do Temporal.Instant.from předán neplatný řetězec, Temporal za nás vyvolá výjimku. Jedna věc, kterou je třeba poznamenat, je, že i přes přísnou analýzu je verze Moment stále mírnější. Temporal vyžaduje posun časového pásma na konci řetězce. Měli byste si také uvědomit, že protože používáme navigator.language, bude tento kód spuštěn pouze v prostředí prohlížeče, protože navigátor není definován v prostředí Node.js. Implementace Temporal používá aktuální národní prostředí prohlížeče (navigator.language), takže uživatel automaticky získá časy událostí ve formátu místního času. V národním prostředí en-US je to 5. března 2026, 15:00:00 EST. Pokud je však uživatel například v Londýně, časy událostí budou ve formátu 5. března 2026, 15:00:00 GMT-5. Shrnutí
Akce Moment.js Časová Aktuální čas moment() Temporal.Now.zonedDateTimeISO() Analýza ISO moment(str) Temporal.Instant.from(str) Přidejte čas .add(7, 'dny') (mutuje) .add({ days: 7 }) (nový objekt) Rozdíl .diff(ostatní, 'hodiny') .od(ostatních).hodin Časové pásmo .tz('Zóna/Název') .withTimeZone('Zone/Name')
Na první pohled může být rozdíl mírně odlišný (a v případě Temporal někdy podrobnější a přísnější) syntaxe, ale používání Temporal oproti Moment.js má několik klíčových výhod:
Být explicitnější znamená méně překvapení a nezamýšlených chyb. Moment se může zdát shovívavější, ale zahrnuje „hádání“, což může někdy vést k nesprávným datům. Pokud dáte Temporal něco neplatné, vyhodí chybu. Pokud se kód spustí, víte, že máte platné datum. Moment může přidat významnou velikost balíčku aplikace, zejména pokud používáte balíček moment-timezone. Temporal nic nepřidává (jakmile je odesláno do vašich cílových prohlížečů). Neměnnost vám dává jistotu, že při provádění převodů dat a operací nikdy neztratíte ani nepřepíšete data. Různé reprezentace času (Instant, PlainDateTime, ZonedDateTime) v závislosti na vašich požadavcích, kde Moment je vždy obal kolem časového razítka UTC. Temporal používá Intl API pro formátování data, což znamená, že můžete mít formátování s ohledem na národní prostředí, aniž byste museli explicitně specifikovat tokeny.
Poznámky Na Polyfill Jak již bylo zmíněno dříve, je k dispozici Temporal polyfill distribuovaný jako balíček npm s názvem @js-temporal/polyfill. Pokud chcete používat Temporal dnes, budete potřebovat tuto polyfill pro podporu prohlížečů, jako je Safari, které ještě nedodaly API. Špatnou zprávou je, že vám to zvětší velikost balíčku. Dobrou zprávou je, že stále přidává výrazně méně než okamžik nebo okamžik-časové pásmo. Zde je srovnání velikostí balíčků, jak uvádí Bundlephobia.com, webová stránka, která uvádí informace o velikostech balíčků npm (kliknutím na název každého balíčku zobrazíte analýzu Bundlephobia):
Balíček Minifikováno Minifikováno a gzipováno @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ěl také historicky určité problémy s výkonem týkající se využití paměti a v době psaní tohoto článku se má za to, že je ve stavu alfa. Z tohoto důvodu jej možná nebudete chtít používat ve výrobě, dokud nedosáhne zralejšího stavu. Další dobrou zprávou je, že doufejme, že polyfill nebude potřeba dlouho (pokud samozřejmě nepotřebujete podporovat starší prohlížeče). V době psaní tohoto článku byl Temporal dodáván v prohlížečích Chrome, Edge a Firefox. V Safari ještě není zcela připraven, i když se zdá, že je k dispozici s příznakem běhu v nejnovějším technologickém náhledu.
