JavaScript Temporal API: Moderní zpracování data a času

Manipulace s datem a časem v JavaScriptu byla pro vývojáře historicky zdrojem frustrace. Vestavěný objekt `Date`, ačkoli je funkční, představuje řadu výzev. Je měnitelný (mutable), postrádá robustní podporu časových pásem a má matoucí API. Naštěstí ECMAScript Temporal API, které je v současné době ve 3. fázi návrhu, si klade za cíl zcela změnit způsob, jakým s daty a časy v JavaScriptu pracujeme. Tento komplexní průvodce se ponoří do Temporal API a poskytne jasné pochopení jeho výhod a praktických aplikací pro vývojáře tvořící globální aplikace.

Problém se stávajícím objektem Date

Před prozkoumáním Temporal API je klíčové porozumět omezením stávajícího objektu `Date`. Objekt `Date` je v JavaScriptu primitivní typ, který reprezentuje jediný bod v čase. Trpí však několika nedostatky:

• Mutabilita: Objekt `Date` je měnitelný (mutable), což znamená, že jeho vlastnosti lze přímo měnit. To může vést k neočekávaným vedlejším účinkům a chybám, zejména ve velkých aplikacích.
• Chybějící neměnnost: Vytváření neměnných (immutable) objektů `Date` nebo vytváření nových objektů `Date` při manipulaci s hodnotami data vyžaduje více manuálního úsilí.
• Zmatečné API: API objektu `Date` může být matoucí a náchylné k chybám. Například hodnoty měsíců jsou indexovány od nuly (0 pro leden, 11 pro prosinec), což vede k častým chybám o jedničku.
• Špatná podpora časových pásem: Práce s časovými pásmy je komplikovaná a často vyžaduje externí knihovny. Objekt `Date` se spoléhá na časové pásmo hostitelského systému, což může vést k nekonzistentnímu chování na různých zařízeních a v různých prostředích. Je to obzvláště náročné při podpoře uživatelů v různých časových pásmech po celém světě.
• Problémy s převodem na řetězec: Převod objektů `Date` na řetězce je také problematický, což často vede k nekonzistentnímu formátování a reprezentaci časového pásma. To může ovlivnit výměnu dat.

Tato omezení činila z manipulace s datem a časem pro vývojáře v JavaScriptu po mnoho let přetrvávající bolestivý bod.

Představujeme Temporal API

Temporal API je navrženo tak, aby tyto nedostatky řešilo. Jedná se o nové, moderní a intuitivnější API pro práci s daty a časy v JavaScriptu. Mezi klíčové vlastnosti Temporal API patří:

• Neměnnost: Objekty Temporal jsou neměnné (immutable). Operace na objektu Temporal vždy vrací nový objekt a původní objekt zůstává nezměněn. To podporuje bezpečnější a předvídatelnější kód.
• Jasné a konzistentní API: API je navrženo tak, aby bylo intuitivnější a snadněji použitelné, s důrazem na srozumitelnost a konzistenci. Hodnoty měsíců jsou například indexovány od jedničky, což odpovídá běžným očekáváním.
• Robustní podpora časových pásem: Temporal poskytuje vestavěnou podporu pro časová pásma a přesně zpracovává jejich konverze.
• Typová bezpečnost: API zavádí různé typy pro datum a čas (např. `Temporal.PlainDate`, `Temporal.ZonedDateTime`), což poskytuje lepší typovou bezpečnost a usnadňuje uvažování o vašem kódu.
• Internacionalizace: Navrženo s ohledem na internacionalizaci, Temporal API nabízí podporu pro různé kalendářní systémy a formáty.

Temporal API není přímou náhradou za objekt `Date`. Je to zcela nové API. To vyžaduje přizpůsobení se novým třídám a metodám, které poskytuje. Výhody v podobě zlepšené přesnosti, snazší údržby a konzistentnějšího chování jsou však značné.

Základní typy a koncepty Temporal

Temporal API zavádí několik nových typů pro reprezentaci různých aspektů dat a časů. Porozumění těmto typům je klíčové pro efektivní používání API.

1. `Temporal.Instant`

Představuje jediný bod v čase, nezávislý na jakémkoli časovém pásmu nebo kalendáři. Je to v podstatě počet nanosekund od unixové epochy (1. ledna 1970, 00:00:00 UTC).

            
const now = Temporal.Instant.now()
console.log(now.toString()); // e.g., 2024-02-29T15:30:00.123456789Z

            

              
                Copy
              
            
          

To je užitečné pro vysoce přesná měření času nebo logování událostí, které musí být konzistentně interpretovány napříč různými časovými pásmy.

2. `Temporal.ZonedDateTime`

Představuje konkrétní bod v čase spolu s informacemi o časovém pásmu a kalendáři. Tento typ je nezbytný pro práci s daty a časy s plným povědomím o časových pásmech.

            
const nowInUTC = Temporal.Now.zonedDateTime('UTC');
console.log(nowInUTC.toString()); // e.g., 2024-02-29T15:30:00.123456789Z[UTC]

const nowInNewYork = Temporal.Now.zonedDateTime('America/New_York');
console.log(nowInNewYork.toString()); // e.g., 2024-02-29T10:30:00.123456789-05:00[America/New_York]

            

              
                Copy
              
            
          

Třída `Temporal.Now` poskytuje pohodlné metody pro získání aktuálního data a času v různých časových pásmech. Tento typ je neocenitelný pro jakoukoli aplikaci, která pracuje s časovými pásmy, plánováním nebo polohou uživatele.

3. `Temporal.PlainDate`

Představuje datum bez času nebo časového pásma. To je užitečné pro reprezentaci pouze kalendářních dat.

            
const today = Temporal.Now.plainDateISO()
console.log(today.toString()); // e.g., 2024-02-29

            

              
                Copy
              
            
          

Je to podobné objektu `Date`, ale předvídatelnější. Hodí se pro narozeniny, výročí a další události, které nezávisí na čase.

4. `Temporal.PlainTime`

Představuje denní dobu bez data nebo časového pásma. Ideální pro reprezentaci časové části události.

            
const nowTime = Temporal.Now.plainTimeISO()
console.log(nowTime.toString()); // e.g., 15:30:00.123456789

            

              
                Copy
              
            
          

Užitečné pro věci jako definování otevírací doby podniku.

5. `Temporal.PlainDateTime`

Představuje datum a čas bez informací o časovém pásmu. Je to podobné objektu `Date` bez informací o časovém pásmu.

            
const nowDateTime = Temporal.Now.plainDateTimeISO()
console.log(nowDateTime.toString()); // e.g., 2024-02-29T15:30:00.123456789

            

              
                Copy
              
            
          

Vhodné, když potřebujete reprezentovat datum i čas bez časového pásma.

6. `Temporal.PlainMonthDay`

Představuje měsíc a den bez roku.

            
const february29th = Temporal.PlainMonthDay.from({ month: 2, day: 29 });
console.log(february29th.toString()); // --02-29

            

              
                Copy
              
            
          

Užitečné pro reprezentaci věcí jako je konkrétní den v roce, například narozeniny nebo svátek.

7. `Temporal.PlainYearMonth`

Představuje rok a měsíc bez dne.

            
const yearMonth = Temporal.PlainYearMonth.from({ year: 2024, month: 2 });
console.log(yearMonth.toString()); // 2024-02

            

              
                Copy
              
            
          

Pomáhá při reprezentaci finančních výkazních období nebo měsíců v harmonogramu.

8. `Temporal.Duration`

Představuje časový úsek, jako jsou 3 dny, 2 hodiny a 30 minut. Nemá konkrétní bod v čase.

            
const duration = Temporal.Duration.from({ days: 3, hours: 2, minutes: 30 });
console.log(duration.toString()); // P3DT02H30M

            

              
                Copy
              
            
          

Dobré pro výpočet času mezi událostmi. To je nezbytné pro funkce, které se zabývají trváním událostí, jako je délka letu nebo čas schůzky.

9. `Temporal.TimeZone`

Představuje časové pásmo. Použijte ho k převodu dat a časů mezi časovými pásmy.

            
const timeZone = Temporal.TimeZone.from('America/Los_Angeles');
console.log(timeZone.id); // America/Los_Angeles

            

              
                Copy
              
            
          

Toto je základní stavební kámen pro práci s časovými pásmy, klíčový v globálních aplikacích.

10. `Temporal.Calendar`

Představuje kalendářní systém (např. gregoriánský, ISO, japonský). To vám umožňuje pracovat s daty v různých kalendářních systémech.

            
const isoCalendar = Temporal.Calendar.from('iso8601');
console.log(isoCalendar.toString()); // ISO8601

            

              
                Copy
              
            
          

Nezbytné pro aplikace, které potřebují podporovat uživatele z různých kultur a regionů.

Práce s časovými pásmy

Práce s časovými pásmy je jednou z klíčových silných stránek Temporal API. Poskytuje mnohem spolehlivější a uživatelsky přívětivější způsob práce s časovými pásmy ve srovnání s vestavěným objektem `Date`.

Vytváření objektů `ZonedDateTime`

Objekty `ZonedDateTime` můžete vytvářet z různých zdrojů, včetně:

• Aktuálního času v konkrétním časovém pásmu: `Temporal.Now.zonedDateTime('America/Los_Angeles')`
• Existujícího `Instant` a `TimeZone`: `Temporal.Instant.from('2024-02-29T15:30:00Z').toZonedDateTime(Temporal.TimeZone.from('America/New_York'))`

            
const instant = Temporal.Instant.from('2024-02-29T15:30:00Z');
const timeZone = Temporal.TimeZone.from('America/Los_Angeles');
const zonedDateTime = instant.toZonedDateTime(timeZone);
console.log(zonedDateTime.toString()); // e.g., 2024-02-29T07:30:00-08:00[America/Los_Angeles]

            

              
                Copy
              
            
          

Převod časových pásem

Metoda `toZonedDateTime` umožňuje převést objekt `ZonedDateTime` do jiného časového pásma.

            
const newYorkTime = Temporal.Now.zonedDateTime('America/New_York');
const londonTime = newYorkTime.toZonedDateTime(Temporal.TimeZone.from('Europe/London'));
console.log(londonTime.toString()); // e.g., 2024-02-29T12:30:00+00:00[Europe/London]

            

              
                Copy
              
            
          

To je zvláště užitečné při práci s událostmi nebo schůzkami naplánovanými v různých časových pásmech.

Zpracování přechodů časových pásem

Temporal API automaticky zpracovává přechody na letní čas (DST). Tím je zajištěna přesnost při provádění časových převodů mezi časovými pásmy.

            
const berlinTime = Temporal.Now.zonedDateTime('Europe/Berlin');
console.log(berlinTime.toString());

// Assuming DST changes at 02:00:00 on the given date in Europe/Berlin:

const nextDay = berlinTime.add(Temporal.Duration.from({ days: 1 }));
console.log(nextDay.toString()); // Example: Time might 'jump' or 'skip' an hour depending on DST.

            

              
                Copy
              
            
          

Aritmetika s datem a časem

Provádění výpočtů s daty a časy je základním požadavkem v mnoha aplikacích. Temporal API poskytuje metody pro sčítání, odčítání a porovnávání hodnot data a času čistým a efektivním způsobem.

Sčítání a odčítání časových úseků

Pomocí metod `add()` a `subtract()` můžete k různým typům Temporal přidávat nebo od nich odečítat objekty `Duration`.

            
const plainDate = Temporal.PlainDate.from('2024-02-29');
const duration = Temporal.Duration.from({ days: 10 });
const futureDate = plainDate.add(duration);
console.log(futureDate.toString()); // 2024-03-10

const dateTime = Temporal.PlainDateTime.from('2024-02-29T10:00:00');
const durationHours = Temporal.Duration.from({ hours: 3 });
const futureDateTime = dateTime.add(durationHours);
console.log(futureDateTime.toString()); // 2024-02-29T13:00:00

            

              
                Copy
              
            
          

To je mimořádně užitečné pro výpočet termínů splatnosti, časů schůzek a dalších časově citlivých událostí.

Výpočet rozdílu mezi daty/časy

Metoda `until()` umožňuje vypočítat dobu trvání mezi dvěma objekty Temporal. Můžete specifikovat časové jednotky, které chcete měřit (např. dny, hodiny, minuty).

            
const startDate = Temporal.PlainDate.from('2024-02-01');
const endDate = Temporal.PlainDate.from('2024-02-29');
const duration = startDate.until(endDate);
console.log(duration.toString()); // P28D

            

              
                Copy
              
            
          

To je užitečné při práci na projektech s termíny. Nebo pro výpočet věku osoby.

Porovnávání dat a časů

Temporal poskytuje pohodlné porovnávací metody, jako jsou `equals()` a `compare()`, pro porovnávání objektů Temporal.

            
const date1 = Temporal.PlainDate.from('2024-02-29');
const date2 = Temporal.PlainDate.from('2024-02-29');
console.log(date1.equals(date2)); // true

const comparisonResult = date1.compare(Temporal.PlainDate.from('2024-03-01'));
console.log(comparisonResult); // -1 (date1 is earlier than the other date)

            

              
                Copy
              
            
          

Formátování data a času

Formátování dat a časů pro zobrazení je nezbytné pro poskytnutí uživatelsky přívětivého zážitku. Temporal API poskytuje vestavěné možnosti formátování.

Použití `toLocaleString()`

Metoda `toLocaleString()` umožňuje formátovat objekty Temporal na základě nastavení specifických pro dané národní prostředí (locale). To je klíčové pro internacionalizaci, přizpůsobení se různým formátům data a času po celém světě.

            
const now = Temporal.Now.zonedDateTime('America/New_York');
console.log(now.toLocaleString('en-US')); // e.g., 2/29/2024, 10:30:00 AM
console.log(now.toLocaleString('fr-FR')); // e.g., 29/02/2024 10:30:00

            

              
                Copy
              
            
          

Řetězec národního prostředí ('en-US', 'fr-FR' atd.) specifikuje jazyk a region pro formátování. To pomáhá prezentovat data a časy způsobem, který je uživatelům z různých zemí známý.

Vlastní formátování s `toString()` a šablonovými literály

Zatímco `toLocaleString()` poskytuje formátování s ohledem na národní prostředí, můžete také použít `toString()` s manipulací s řetězci k vytvoření vlastních formátů data a času.

            
const now = Temporal.Now.plainDateTimeISO()
const formattedDate = `${now.year}-${String(now.month).padStart(2, '0')}-${String(now.day).padStart(2, '0')}`;
console.log(formattedDate); // e.g., 2024-02-29

            

              
                Copy
              
            
          

Tato metoda umožňuje úplnou kontrolu nad výstupem formátování, ale musíte si sami spravovat logiku formátování.

Praktické příklady a případy použití

Temporal API je přínosné v různých reálných scénářích. Zde jsou některé příklady:

1. Plánování a správa událostí

V aplikacích, jako jsou kalendářové aplikace, plánovače schůzek a platformy pro správu událostí, může Temporal API zvládnout plánování schůzek napříč různými časovými pásmy. Představte si globální společnost plánující schůzku. API umožňuje přesné zpracování převodů časových pásem a zabraňuje zmatkům při plánování schůzky mezi týmy na různých kontinentech.

            
const meetingTimeInUTC = Temporal.PlainDateTime.from('2024-03-15T14:00:00');
const londonTZ = Temporal.TimeZone.from('Europe/London');
const newYorkTZ = Temporal.TimeZone.from('America/New_York');
const londonMeeting = meetingTimeInUTC.toZonedDateTime(londonTZ);
const newYorkMeeting = londonMeeting.toZonedDateTime(newYorkTZ);
console.log(`Meeting in London: ${londonMeeting.toLocaleString('en-GB')}`);
console.log(`Meeting in New York: ${newYorkMeeting.toLocaleString('en-US')}`);

            

              
                Copy
              
            
          

2. E-commerce a mezinárodní transakce

E-commerce platformy se často potýkají s objednávkami, dodacími lhůtami a propagačními akcemi v různých časových pásmech. Temporal API lze použít k přesnému zobrazení termínů pro objednávky, časů doručení zásilek a dat ukončení propagačních akcí, bez ohledu na polohu uživatele. Například zajištění, aby bleskový výprodej skončil ve správný místní čas pro zákazníky po celém světě.

            
// Suppose the sale ends at midnight UTC
const saleEndTimeUTC = Temporal.PlainDateTime.from('2024-03-01T00:00:00');
const userTimeZone = Temporal.TimeZone.from('America/Los_Angeles');
const saleEndTimeUserTime = saleEndTimeUTC.toZonedDateTime(userTimeZone);
console.log(`Sale ends at: ${saleEndTimeUserTime.toLocaleString('en-US', { timeZone: 'America/Los_Angeles' })}`);

            

              
                Copy
              
            
          

3. Finanční aplikace

Finanční aplikace potřebují přesné informace o čase a datu pro transakce, výkaznictví a výpočty. Neměnnost a zpracování časových pásem v Temporal API mohou pomoci zajistit přesnost finančních záznamů a zabránit poškození dat.

            
const transactionTime = Temporal.Now.zonedDateTime('UTC');
const transactionTimeInLocal = transactionTime.toZonedDateTime(Temporal.TimeZone.from('America/New_York'));
console.log(`Transaction time (UTC): ${transactionTime.toString()}`);
console.log(`Transaction time (New York): ${transactionTimeInLocal.toString()}`);

            

              
                Copy
              
            
          

4. Analýza dat a reporting

Při analýze dat jsou přesné manipulace s datem a časem nezbytné pro filtrování, seskupování a výpočet metrik. Temporal API pomáhá vytvářet spolehlivé analytické nástroje, což je zvláště užitečné při práci s různými časovými pásmy.

            
// Example: Calculate the age of users
const birthDate = Temporal.PlainDate.from('1990-05-10');
const today = Temporal.Now.plainDateISO();
const age = birthDate.until(today).days / 365.25; // Approximate Age
console.log(`Approximate age: ${Math.floor(age)} years`);

            

              
                Copy
              
            
          

5. Logování a auditování

Aplikace, které potřebují udržovat auditní stopy nebo sledovat události, by měly používat Temporal API k ukládání časových značek konzistentním a spolehlivým způsobem, zejména tam, kde se berou v úvahu časová pásma.

            
const eventTime = Temporal.Now.zonedDateTime('UTC');
console.log(`Event logged at: ${eventTime.toString()}`);

            

              
                Copy
              
            
          

Jak začít s Temporal API

Temporal API ještě není ve všech prohlížečích dostupné ve výchozím nastavení. Chcete-li ho použít, máte několik možností:

1. Použití polyfillu

Nejjednodušší způsob, jak začít používat Temporal API, je použít polyfill. Polyfill je kousek kódu, který poskytuje funkcionalitu nového API v prostředích, která ho ještě nativně nepodporují. Primární polyfill, udržovaný týmem Temporal, je k dispozici na npm:

            
npm install @js-temporal/polyfill

            

              
                Copy
              
            
          

Poté ve svém JavaScript kódu musíte polyfill importovat a použít:

            
import '@js-temporal/polyfill';
// Now you can use the Temporal API
const today = Temporal.Now.plainDateISO()
console.log(today.toString());

            

              
                Copy
              
            
          

Tento přístup je nejvíce doporučovaný a umožňuje vám začít používat Temporal API dnes prakticky v jakémkoli JavaScriptovém prostředí.

2. Použití bundleru

Polyfill můžete do svého projektu zahrnout pomocí bundleru jako je Webpack, Parcel nebo Rollup. To zjednodušuje proces zahrnutí polyfillu a jeho závislostí.

3. Čekání na nativní podporu

Temporal API je v současné době ve 3. fázi procesu TC39, což znamená, že je pravděpodobné, že bude v blízké budoucnosti implementováno v prohlížečích a běhových prostředích JavaScriptu. Nativní podporu můžete zkontrolovat na webových stránkách jako je Can I Use, abyste viděli stav podpory v různých prohlížečích a verzích Node.js. Jakmile bude nativní podpora k dispozici, můžete polyfill odstranit a používat API přímo.

Osvědčené postupy pro používání Temporal API

Chcete-li z Temporal API vytěžit maximum a vyhnout se běžným nástrahám, zvažte tyto osvědčené postupy:

• Upřednostňujte neměnnost: Vždy vytvářejte nové objekty Temporal namísto úpravy stávajících. Tím zajistíte, že váš kód bude snazší na pochopení a méně náchylný k chybám.
• Používejte `ZonedDateTime` pro operace s časovými pásmy: Při práci s časovými pásmy vždy používejte objekty `ZonedDateTime`, abyste zajistili přesné převody časových pásem a zpracování letního času.
• Zvolte správný typ: Vyberte vhodný typ Temporal pro vaše potřeby. Například použijte `PlainDate` pro data bez informací o čase nebo časovém pásmu.
• Pečlivě zpracovávejte přechody časových pásem: Buďte si vědomi přechodů na letní čas a plánujte svůj kód odpovídajícím způsobem, zejména při aritmetice s daty.
• Využívejte formátování s ohledem na národní prostředí: Používejte `toLocaleString()` k formátování dat a časů pro prezentaci uživatelům, protože automaticky zpracovává místní formáty data a času.
• Testování: Důkladně testujte logiku data a času, včetně okrajových případů souvisejících s přechody na letní čas a převody časových pásem, abyste odhalili potenciální chyby. Zvažte použití testovací knihovny.
• Používejte konzistentní ID časových pásem: Používejte platná ID časových pásem IANA (např. 'America/New_York', 'Europe/London').
• Zvažte preference uživatelů: Mějte na paměti preference uživatelů ohledně formátů data a času a umožněte uživatelům přizpůsobit zobrazení dat a časů ve vaší aplikaci.

Budoucnost data a času v JavaScriptu

Temporal API představuje významné zlepšení oproti stávajícímu objektu `Date`. Díky svému neměnnému designu, jasnému API, robustnímu zpracování časových pásem a zaměření na internacionalizaci poskytuje mnohem lepší základ pro vytváření spolehlivých a udržitelných aplikací, které fungují globálně. Jak se Temporal API blíží standardizaci a nativní implementaci v prohlížečích a běhových prostředích, mohou se vývojáři těšit na efektivnější a přesnější způsob práce s daty a časy v JavaScriptu.

Přijetí Temporal API výrazně sníží potřebu externích knihoven pro zpracování složitých operací s datem a časem, což zjednoduší vývoj a zlepší výkon aplikací. Umožňuje ekosystému JavaScriptu řešit tyto historické výzvy. Vývojáři by se měli připravit na integraci Temporal API, aby mohli zpracovávat data a časy s mnohem větší lehkostí a přesností, čímž se jejich aplikace stanou robustnějšími a lépe vybavenými pro obsluhu globálního publika.

Závěr

Temporal API je výkonným a nezbytným doplňkem jazyka JavaScript. Přijetím Temporal API mohou vývojáři výrazně zlepšit přesnost, spolehlivost a udržovatelnost svých aplikací. Je zvláště cenné pro vývojáře vytvářející aplikace pro globální publikum, kde je klíčové přesné zpracování časových pásem a internacionalizace. Přijetí Temporal API bude stále důležitější, jak se web bude nadále rozšiřovat a oslovovat globální publikum. Pochopení základních konceptů a osvědčených postupů uvedených v tomto průvodci vám pomůže využít plný potenciál Temporal API a vytvářet robustnější a uživatelsky přívětivější aplikace.