M

MLOG

Magyar

Részletes útmutató a JavaScript Temporal API-hoz, egy modern megoldáshoz a dátumok és idők hatékony kezelésére a különböző nemzetközi kontextusokban.

JavaScript Temporal API: Modern dátum- és időkezelés a globális közönség számára

A JavaScript `Date` objektuma régóta frusztráció forrása a fejlesztők számára. Megváltoztathatósága, következetlen API-ja és gyenge időzóna-támogatása számos könyvtár, például a Moment.js és a date-fns létrejöttéhez vezetett, hogy pótolják a hiányosságokat. Most, a Temporal API-val a JavaScript egy modern, beépített megoldást kínál a dátumok és idők kezelésére, javított átláthatósággal és pontossággal. Ez a cikk átfogó áttekintést nyújt a Temporal API-ról, annak funkcióira, előnyeire és a különböző nemzetközi kontextusokban való használatára összpontosítva.

Mi az a Temporal API?

A Temporal API egy új, globális objektum a JavaScriptben, amelyet a `Date` objektum hiányosságainak orvoslására terveztek. Tiszta, megváltoztathatatlan API-t biztosít a dátumokkal, időkkel, időzónákkal és naptárrendszerekkel való munkához. Lényegében arra törekszik, hogy a dátum- és időfogalmakat olyan módon képviselje, amely jobban illeszkedik a valós használathoz és elvárásokhoz, így a nemzetköziesítés sokkal egyszerűbbé válik.

Főbb jellemzők:

Alapvető Temporal objektumok

A Temporal API számos új objektumtípust vezet be. Íme néhány a legfontosabbak közül:

Munkavégzés dátumokkal

`Temporal.PlainDate` létrehozása

Egy `Temporal.PlainDate` objektumot a konstruktorral hozhat létre:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // Év, Hónap (1-12), Nap
console.log(plainDate.toString()); // Kimenet: 2024-10-27

Használhatja a `from` metódust is, amely egy ISO 8601 formátumú sztringet fogad el:

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

Dátumkomponensek lekérdezése

Az egyes dátumkomponenseket olyan tulajdonságokkal érheti el, mint a `year`, `month` és `day`:

console.log(plainDate.year); // Kimenet: 2024
console.log(plainDate.month); // Kimenet: 10
console.log(plainDate.day); // Kimenet: 27

Dátum aritmetika

Napok, hetek, hónapok vagy évek hozzáadásához vagy kivonásához használja a `plus` és `minus` metódusokat. Ezek a metódusok egy új `Temporal.PlainDate` objektumot adnak vissza:

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

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

Dátumok összehasonlítása

A dátumokat a `compare` metódussal hasonlíthatja össze:

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

console.log(Temporal.PlainDate.compare(date1, date2)); // Kimenet: -1 (a date1 korábbi, mint a date2)

Munkavégzés időkkel

`Temporal.PlainTime` létrehozása

Egy `Temporal.PlainTime` objektumot a konstruktorral hozhat létre:

const plainTime = new Temporal.PlainTime(10, 30, 0); // Óra, Perc, Másodperc
console.log(plainTime.toString()); // Kimenet: 10:30:00

Vagy használja a `from` metódust egy ISO 8601 formátumú idő sztringgel:

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

Időkomponensek lekérdezése

console.log(plainTime.hour); // Kimenet: 10
console.log(plainTime.minute); // Kimenet: 30
console.log(plainTime.second); // Kimenet: 0

Idő aritmetika

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

Munkavégzés dátummal és idővel együtt

`Temporal.PlainDateTime` létrehozása

Létrehozhat egy `Temporal.PlainDateTime` objektumot közvetlenül, vagy egy `Temporal.PlainDate` és egy `Temporal.PlainTime` kombinálásával:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
console.log(plainDateTime.toString()); // Kimenet: 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()); // Kimenet: 2024-10-27T10:30:00

Időzónák

Az időzónák helyes kezelése kulcsfontosságú a különböző helyszíneken tartózkodó felhasználókkal foglalkozó alkalmazások számára. A Temporal API robusztus időzóna-támogatást nyújt a `Temporal.ZonedDateTime` és `Temporal.TimeZone` objektumokon keresztül.

`Temporal.ZonedDateTime` létrehozása

Egy `Temporal.ZonedDateTime` létrehozásához szüksége van egy `Temporal.PlainDateTime`-re és egy időzóna-azonosítóra. Az időzóna-azonosítók az IANA időzóna-adatbázisán alapulnak (pl. `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()); // Kimenet: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (Az eltolódás a nyári időszámítási szabályoktól függ)

Alternatív megoldásként létrehozhat `Temporal.ZonedDateTime`-ot egy `Instant`-ból.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // Példa időbélyeg
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // Időzóna, pl. 'America/Los_Angeles'
console.log(zonedDateTimeFromInstant.toString());

Konverzió időzónák között

Egy `Temporal.ZonedDateTime` objektumot a `withTimeZone` metódussal konvertálhat át egy másik időzónába:

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

Munkavégzés időzóna-eltolódásokkal

A `Temporal.TimeZone` objektum `getOffsetStringFor` metódusa megadja az eltolódási sztringet egy adott `Temporal.Instant`-hoz:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // Kimenet: -07:00 (A nyári időszámítási szabályoktól függően)

A pontos számításokhoz elengedhetetlen a helyes IANA időzóna-azonosítók használata. Ezeket az azonosítókat rendszeresen karbantartják és frissítik, hogy tükrözzék a nyári időszámítás és az időzóna-határok változásait.

Időtartamok (Durations)

A `Temporal.Duration` objektum egy időtartamot képvisel. Használható dátumokhoz és időpontokhoz való hozzáadáshoz vagy kivonáshoz.

`Temporal.Duration` létrehozása

Egy `Temporal.Duration` objektumot a konstruktorral hozhat létre, megadva az éveket, hónapokat, napokat, órákat, perceket, másodperceket, milliszekundumokat, mikroszekundumokat és nanoszekundumokat:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // Évek, Hónapok, Napok, Órák, Percek, Másodpercek, Milliszekundumok, Mikroszekundumok, Nanoszekundumok
console.log(duration.toString()); // Kimenet: P1Y2M3DT4H5M6.007008009S

Vagy egy ISO 8601 időtartam sztring használatával:

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

Időtartamok hozzáadása dátumokhoz és időpontokhoz

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

Vegye figyelembe, hogy a hónapokat vagy éveket tartalmazó időtartamok hozzáadása a dátumokhoz gondos mérlegelést igényel, mivel a hónapok vagy évek napjainak száma változó lehet.

Naptárrendszerek

A Temporal API a Gergely-naptáron túl más naptárrendszereket is támogat. Ez kulcsfontosságú azon alkalmazások számára, amelyeknek különböző kulturális kontextusokban kell dátumokat kezelniük. Bár a támogatás még fejlődik, alapot nyújt a jövőbeli bővítéshez.

Alternatív naptárak használata

Egy adott naptár használatához megadhatja azt a Temporal objektumok létrehozásakor:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // A konkrét kimenet a megvalósítástól és formázástól függően változhat. A cikk írásakor sok környezetben polyfillt igényel.

Fontos: A nem Gergely-naptári naptárak támogatása polyfilleket vagy speciális böngésző-/környezeti támogatást igényelhet. A legfrissebb információkért ellenőrizze a Temporal API dokumentációját és a böngészőkompatibilitási táblázatokat.

Dátumok és idők formázása

Míg a Temporal API a dátum- és időmanipulációra összpontosít, a formázást általában az `Intl.DateTimeFormat` objektum kezeli, amely a Internationalization API része. A Temporal objektumok zökkenőmentesen működnek együtt az `Intl.DateTimeFormat`-tal.

Az `Intl.DateTimeFormat` használata

Így formázhat egy `Temporal.PlainDate`-et az `Intl.DateTimeFormat` segítségével:

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)); // Kimenet: October 27, 2024

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

Testreszabhatja a formázási opciókat az igényeinek megfelelően. Az `Intl.DateTimeFormat` első argumentuma a lokalizáció (locale), amely meghatározza a formázáshoz használt nyelvet és regionális konvenciókat. Különböző lokalizációk (pl. 'en-US', 'de-DE', 'fr-FR', 'ja-JP') használata különböző kimeneti formátumokat eredményez.

`Temporal.ZonedDateTime` formázása

A `Temporal.ZonedDateTime` formázása hasonló, de az időzóna-információkat is belefoglalhatja a kimenetbe:

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)); // Kimenet: October 27, 2024, 10:30 AM PDT (Az időzóna rövidítése a nyári időszámítási szabályoktól függ)

Nemzetköziesítési legjobb gyakorlatok

Amikor globális kontextusban dolgozik dátumokkal és időkkel, tartsa szem előtt a következő legjobb gyakorlatokat:

A Temporal API és a régi Date objektum összehasonlítása

Íme egy táblázat, amely kiemeli a Temporal API legfontosabb különbségeit és előnyeit a régi `Date` objektumhoz képest:

Jellemző Régi `Date` objektum Temporal API
Megváltoztathatóság Megváltoztatható (módosítja az eredeti objektumot) Megváltoztathatatlan (új objektumokat ad vissza)
Időzóna-támogatás Korlátozott és gyakran problémás Robusztus és pontos, az IANA időzóna-adatbázisán alapul
API Következetlen és nehezen használható Világos, következetes és intuitív
Pontosság Milliszekundum Nanoszekundum
Naptárrendszerek A Gergely-naptárra korlátozódik Támogatja az alternatív naptárrendszereket (fejlődő támogatással)
Nemzetköziesítés Külső könyvtárakat igényel a robusztus nemzetköziesítéshez Beépített támogatás és zökkenőmentes integráció az `Intl.DateTimeFormat`-tal

Böngészőtámogatás és Polyfillek

Mivel viszonylag új API-ról van szó, a Temporal API böngészőtámogatása még mindig fejlődik. Ellenőrizze a legfrissebb böngészőkompatibilitási táblázatokat (pl. az MDN Web Docs-on), hogy lássa, mely böngészők és környezetek támogatják natívan. Régebbi böngészők vagy natív támogatás nélküli környezetek esetén polyfilleket használhat a Temporal API funkcionalitásának biztosítására. Keressen a weben a "Temporal API polyfill" kifejezésre a megfelelő lehetőségek megtalálásához.

Konklúzió

A JavaScript Temporal API jelentős előrelépést jelent a dátumok és idők kezelésében a JavaScriptben. Megváltoztathatatlansága, világos API-ja, robusztus időzóna-támogatása és naptárrendszer-képességei erőteljes eszközzé teszik a fejlesztők számára, akik olyan alkalmazásokat építenek, amelyeknek pontosan és megbízhatóan kell működniük a dátumokkal és időkkel a különböző nemzetközi kontextusokban. Bár a böngészőtámogatás még fejlődik, a Temporal API előnyei miatt érdemes megtanulni és alkalmazni új projektekben. A Temporal API és a nemzetköziesítési legjobb gyakorlatok alkalmazásával olyan alkalmazásokat hozhat létre, amelyek zökkenőmentes és pontos dátum- és időélményt nyújtanak a felhasználóknak szerte a világon.

További források