M

MLOG

Slovenčina

Podrobný sprievodca JavaScript Temporal API, moderným riešením pre efektívne spracovanie dátumov a časov v rôznych medzinárodných kontextoch.

JavaScript Temporal API: Moderné spracovanie dátumu a času pre globálne publikum

Objekt `Date` v JavaScripte bol dlho zdrojom frustrácie pre vývojárov. Jeho meniteľnosť, nekonzistentné API a slabá podpora časových pásiem viedli k vzniku mnohých knižníc ako Moment.js a date-fns, ktoré tieto medzery vypĺňali. Teraz, s Temporal API, JavaScript ponúka moderné, vstavané riešenie pre spracovanie dátumov a časov s vylepšenou prehľadnosťou a presnosťou. Tento článok poskytuje komplexný prehľad Temporal API so zameraním na jeho funkcie, výhody a použitie v rôznych medzinárodných kontextoch.

Čo je Temporal API?

Temporal API je nový, globálny objekt v JavaScripte navrhnutý tak, aby riešil nedostatky objektu `Date`. Poskytuje čisté, nemenné API pre prácu s dátumami, časmi, časovými pásmami a kalendárnymi systémami. Kľúčové je, že sa snaží reprezentovať koncepty dátumu a času spôsobom, ktorý je bližší reálnemu používaniu a očakávaniam, čo výrazne zjednodušuje internacionalizáciu.

Kľúčové vlastnosti:

Základné objekty Temporal

Temporal API predstavuje niekoľko nových typov objektov. Tu sú niektoré z tých hlavných:

Práca s dátumami

Vytvorenie `Temporal.PlainDate`

Na vytvorenie `Temporal.PlainDate` môžete použiť konštruktor:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // Rok, Mesiac (1-12), Deň
console.log(plainDate.toString()); // Výstup: 2024-10-27

Môžete tiež použiť metódu `from`, ktorá prijíma reťazec vo formáte ISO 8601:

const plainDateFromString = Temporal.PlainDate.from('2024-10-27');
console.log(plainDateFromString.toString()); // Výstup: 2024-10-27

Získanie zložiek dátumu

K jednotlivým zložkám dátumu môžete pristupovať pomocou vlastností ako `year`, `month` a `day`:

console.log(plainDate.year); // Výstup: 2024
console.log(plainDate.month); // Výstup: 10
console.log(plainDate.day); // Výstup: 27

Aritmetika s dátumami

Na pridanie alebo odčítanie dní, týždňov, mesiacov alebo rokov použite metódy `plus` a `minus`. Tieto metódy vracajú nový objekt `Temporal.PlainDate`:

const nextWeek = plainDate.plus({ days: 7 });
console.log(nextWeek.toString()); // Výstup: 2024-11-03

const lastMonth = plainDate.minus({ months: 1 });
console.log(lastMonth.toString()); // Výstup: 2024-09-27

Porovnávanie dátumov

Dátumy môžete porovnávať pomocou metódy `compare`:

const date1 = new Temporal.PlainDate(2024, 10, 27);
const date2 = new Temporal.PlainDate(2024, 11, 15);

console.log(Temporal.PlainDate.compare(date1, date2)); // Výstup: -1 (date1 je skôr ako date2)

Práca s časmi

Vytvorenie `Temporal.PlainTime`

Na vytvorenie `Temporal.PlainTime` použite konštruktor:

const plainTime = new Temporal.PlainTime(10, 30, 0); // Hodina, Minúta, Sekunda
console.log(plainTime.toString()); // Výstup: 10:30:00

Alebo použite metódu `from` s časovým reťazcom ISO 8601:

const plainTimeFromString = Temporal.PlainTime.from('10:30:00');
console.log(plainTimeFromString.toString()); // Výstup: 10:30:00

Získanie zložiek času

console.log(plainTime.hour); // Výstup: 10
console.log(plainTime.minute); // Výstup: 30
console.log(plainTime.second); // Výstup: 0

Aritmetika s časom

const later = plainTime.plus({ minutes: 15 });
console.log(later.toString()); // Výstup: 10:45:00

Spoločná práca s dátumom a časom

Vytvorenie `Temporal.PlainDateTime`

Môžete vytvoriť `Temporal.PlainDateTime` priamo alebo kombináciou `Temporal.PlainDate` a `Temporal.PlainTime`:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
console.log(plainDateTime.toString()); // Výstup: 2024-10-27T10:30:00

const date = new Temporal.PlainDate(2024, 10, 27);
const time = new Temporal.PlainTime(10, 30, 0);
const combinedDateTime = date.toPlainDateTime(time);
console.log(combinedDateTime.toString()); // Výstup: 2024-10-27T10:30:00

Časové pásma

Správne zaobchádzanie s časovými pásmami je kľúčové pre aplikácie, ktoré pracujú s používateľmi na rôznych miestach. Temporal API poskytuje robustnú podporu časových pásiem prostredníctvom objektov `Temporal.ZonedDateTime` a `Temporal.TimeZone`.

Vytvorenie `Temporal.ZonedDateTime`

Na vytvorenie `Temporal.ZonedDateTime` potrebujete `Temporal.PlainDateTime` a identifikátor časového pásma. Identifikátory časových pásiem sú založené na databáze časových pásiem IANA (napr. `America/Los_Angeles`, `Europe/London`, `Asia/Tokyo`).

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);
console.log(zonedDateTime.toString()); // Výstup: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (Odchýlka bude závisieť od pravidiel letného času)

Alternatívne, vytvorte `Temporal.ZonedDateTime` z objektu `Instant`.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // Príklad časovej pečiatky
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // Časové pásmo ako 'America/Los_Angeles'
console.log(zonedDateTimeFromInstant.toString());

Konverzia medzi časovými pásmami

Môžete konvertovať `Temporal.ZonedDateTime` do iného časového pásma pomocou metódy `withTimeZone`:

const newTimeZone = 'Europe/London';
const zonedDateTimeInLondon = zonedDateTime.withTimeZone(newTimeZone);
console.log(zonedDateTimeInLondon.toString()); // Výstup: 2024-10-27T18:30:00+01:00[Europe/London]

Práca s odchýlkami časových pásiem

Metóda `getOffsetStringFor` objektu `Temporal.TimeZone` poskytuje reťazec odchýlky pre daný `Temporal.Instant`:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // Výstup: -07:00 (V závislosti od pravidiel letného času)

Pre presné výpočty je nevyhnutné používať správne identifikátory časových pásiem IANA. Tieto identifikátory sú pravidelne udržiavané a aktualizované, aby odrážali zmeny v letnom čase a hraniciach časových pásiem.

Trvanie (Durations)

Objekt `Temporal.Duration` reprezentuje časový úsek. Môže byť použitý na pripočítanie alebo odpočítanie od dátumov a časov.

Vytvorenie `Temporal.Duration`

Môžete vytvoriť `Temporal.Duration` pomocou konštruktora, kde špecifikujete roky, mesiace, dni, hodiny, minúty, sekundy, milisekundy, mikrosekundy a nanosekundy:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // Roky, Mesiace, Dni, Hodiny, Minúty, Sekundy, Milisekundy, Mikrosekundy, Nanosekundy
console.log(duration.toString()); // Výstup: P1Y2M3DT4H5M6.007008009S

Alebo použitím reťazca trvania ISO 8601:

const durationFromString = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(durationFromString.toString()); // Výstup: P1Y2M3DT4H5M6S

Pridávanie trvania k dátumom a časom

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const duration = new Temporal.Duration(0, 0, 7); // 7 dní
const newDate = plainDate.plus(duration);
console.log(newDate.toString()); // Výstup: 2024-11-03

Všimnite si, že pridávanie trvaní, ktoré zahŕňajú mesiace alebo roky, k dátumom vyžaduje opatrnosť, pretože počet dní v mesiaci alebo roku sa môže líšiť.

Kalendárne systémy

Temporal API podporuje rôzne kalendárne systémy okrem gregoriánskeho kalendára. To je kľúčové pre aplikácie, ktoré potrebujú spracovávať dátumy v rôznych kultúrnych kontextoch. Hoci podpora sa stále vyvíja, poskytuje základ pre budúce rozšírenie.

Používanie alternatívnych kalendárov

Ak chcete použiť špecifický kalendár, môžete ho špecifikovať pri vytváraní objektov Temporal:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // Špecifický výstup sa môže líšiť v závislosti od implementácie a formátovania. V čase písania tohto článku vyžaduje v mnohých prostrediach polyfill.

Dôležité: Podpora pre negregoriánske kalendáre môže vyžadovať polyfilly alebo špecifickú podporu prehliadača/prostredia. Skontrolujte najnovšie informácie v dokumentácii Temporal API a v tabuľkách kompatibility prehliadačov.

Formátovanie dátumov a časov

Zatiaľ čo sa Temporal API zameriava na manipuláciu s dátumom a časom, formátovanie je zvyčajne riešené objektom `Intl.DateTimeFormat`, ktorý je súčasťou Internationalization API. Objekty Temporal bezproblémovo spolupracujú s `Intl.DateTimeFormat`.

Použitie `Intl.DateTimeFormat`

Takto sa formátuje `Temporal.PlainDate` pomocou `Intl.DateTimeFormat`:

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatter.format(plainDate)); // Výstup: October 27, 2024

const formatterGerman = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatterGerman.format(plainDate)); // Výstup: 27. Oktober 2024

Možnosti formátovania si môžete prispôsobiť podľa svojich potrieb. Prvý argument pre `Intl.DateTimeFormat` je lokalita (locale), ktorá určuje jazyk a regionálne konvencie použité na formátovanie. Použitie rôznych lokalít (napr. 'en-US', 'de-DE', 'fr-FR', 'ja-JP') vytvára rôzne výstupné formáty.

Formátovanie `Temporal.ZonedDateTime`

Formátovanie `Temporal.ZonedDateTime` je podobné, ale do výstupu môžete zahrnúť aj informácie o časovom pásme:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);

const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric', timeZoneName: 'short' });
console.log(formatter.format(zonedDateTime)); // Výstup: October 27, 2024, 10:30 AM PDT (Skratka časového pásma závisí od pravidiel letného času)

Osvedčené postupy pre internacionalizáciu

Pri práci s dátumami a časmi v globálnom kontexte majte na pamäti nasledujúce osvedčené postupy:

Porovnanie Temporal API so starým objektom Date

Tu je tabuľka, ktorá zdôrazňuje kľúčové rozdiely a výhody Temporal API v porovnaní so starým objektom `Date`:

Vlastnosť Starý objekt `Date` Temporal API
Meniteľnosť Meniteľný (modifikuje pôvodný objekt) Nemenný (vracia nové objekty)
Podpora časových pásiem Obmedzená a často problematická Robustná a presná, založená na databáze časových pásiem IANA
API Nekonzistentné a ťažko použiteľné Prehľadné, konzistentné a intuitívne
Presnosť Milisekunda Nanosekunda
Kalendárne systémy Obmedzené na gregoriánsky Podporuje alternatívne kalendárne systémy (s vyvíjajúcou sa podporou)
Internacionalizácia Vyžaduje externé knižnice pre robustnú internacionalizáciu Vstavaná podpora a bezproblémová integrácia s `Intl.DateTimeFormat`

Podpora v prehliadačoch a Polyfilly

Keďže ide o relatívne nové API, podpora Temporal API v prehliadačoch sa stále vyvíja. Skontrolujte najnovšie tabuľky kompatibility prehliadačov (napr. na MDN Web Docs), aby ste zistili, ktoré prehliadače a prostredia ho podporujú natívne. Pre staršie prehliadače alebo prostredia bez natívnej podpory môžete použiť polyfilly na poskytnutie funkcionality Temporal API. Na webe vyhľadajte „Temporal API polyfill“, aby ste našli vhodné možnosti.

Záver

JavaScript Temporal API predstavuje významný krok vpred v spracovaní dátumov a časov v JavaScripte. Jeho nemennosť, prehľadné API, robustná podpora časových pásiem a možnosti kalendárnych systémov z neho robia mocný nástroj pre vývojárov, ktorí vytvárajú aplikácie, ktoré potrebujú pracovať s dátumami a časmi presne a spoľahlivo v rôznych medzinárodných kontextoch. Hoci podpora v prehliadačoch sa stále vyvíja, výhody Temporal API ho robia hodným učenia a osvojenia pre nové projekty. Prijatím Temporal API a dodržiavaním osvedčených postupov pre internacionalizáciu môžete vytvárať aplikácie, ktoré poskytujú bezproblémový a presný zážitok s dátumom a časom pre používateľov po celom svete.

Ďalšie zdroje

JavaScript Temporal API: Moderné spracovanie dátumu a času pre globálne publikum | MLOG