JavaScript Temporal API: modernus datos ir laiko valdymas pasaulinei auditorijai

JavaScript `Date` objektas jau seniai kelia nusivylimą programuotojams. Dėl jo kintamumo, nenuoseklios API ir prasto laiko juostų palaikymo atsirado daugybė bibliotekų, tokių kaip Moment.js ir date-fns, kurios užpildė šias spragas. Dabar, su Temporal API, JavaScript siūlo modernų, integruotą sprendimą, skirtą datoms ir laikams tvarkyti su didesniu aiškumu ir tikslumu. Šiame straipsnyje pateikiama išsami Temporal API apžvalga, sutelkiant dėmesį į jo funkcijas, privalumus ir naudojimą įvairiuose tarptautiniuose kontekstuose.

Kas yra Temporal API?

Temporal API yra naujas, globalus JavaScript objektas, sukurtas siekiant išspręsti `Date` objekto trūkumus. Jis suteikia švarią, nekintamą API darbui su datomis, laikais, laiko juostomis ir kalendorių sistemomis. Svarbiausia, kad juo siekiama pavaizduoti datos ir laiko sąvokas taip, kad jos labiau atitiktų realų naudojimą ir lūkesčius, todėl internacionalizacija tampa daug paprastesnė.

Pagrindinės savybės:

Nekintamumas: Temporal objektai yra nekintami, o tai reiškia, kad operacijos, tokios kaip dienų ar mėnesių pridėjimas, grąžina naujus objektus, o ne keičia pradinį. Tai pašalina dažną klaidų šaltinį ir leidžia lengviau suprasti kodą.
Aiški API: Temporal suteikia nuoseklią ir intuityvią API įprastoms datos ir laiko operacijoms.
Laiko juostų palaikymas: Temporal apima tvirtą laiko juostų palaikymą, leidžiantį dirbti su datomis ir laikais skirtingose vietose be senojo `Date` objekto sudėtingumo. Jis naudoja IANA laiko juostų duomenų bazę, užtikrindamas tikslią ir naujausią informaciją.
Kalendorių sistemos: Be Grigaliaus kalendoriaus, Temporal palaiko alternatyvias kalendorių sistemas, atsižvelgdamas į įvairių kultūrų ir regionų poreikius.
Patobulintas tikslumas: Temporal siūlo nanosekundžių tikslumą, išspręsdamas milisekundėmis pagrįsto `Date` objekto apribojimus.

Pagrindiniai Temporal objektai

Temporal API pristato keletą naujų objektų tipų. Štai keletas pagrindinių:

`Temporal.PlainDate`: Atspindi datą (metai, mėnuo, diena) be laiko juostos.
`Temporal.PlainTime`: Atspindi laiką (valanda, minutė, sekundė, milisekundė, mikrosekundė, nanosekundė) be datos ar laiko juostos.
`Temporal.PlainDateTime`: Atspindi datą ir laiką be laiko juostos.
`Temporal.ZonedDateTime`: Atspindi datą ir laiką su konkrečia laiko juosta.
`Temporal.Instant`: Atspindi konkretų laiko momentą, matuojamą nanosekundėmis nuo Unix epochos pradžios (1970 m. sausio 1 d. UTC).
`Temporal.TimeZone`: Atspindi laiko juostą.
`Temporal.Duration`: Atspindi laiko tarpą (pvz., 2 valandos, 30 minučių).
`Temporal.YearMonth`: Atspindi metus ir mėnesį.
`Temporal.MonthDay`: Atspindi mėnesį ir dieną.

Darbas su datomis

`Temporal.PlainDate` kūrimas

Norėdami sukurti `Temporal.PlainDate`, galite naudoti konstruktorių:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // Metai, mėnuo (1-12), diena
console.log(plainDate.toString()); // Išvestis: 2024-10-27

Taip pat galite naudoti `from` metodą, kuris priima eilutę ISO 8601 formatu:

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

Datos komponentų gavimas

Galite pasiekti atskirus datos komponentus naudodami savybes, tokias kaip `year`, `month` ir `day`:

console.log(plainDate.year); // Išvestis: 2024
console.log(plainDate.month); // Išvestis: 10
console.log(plainDate.day); // Išvestis: 27

Datos aritmetika

Norėdami pridėti arba atimti dienas, savaites, mėnesius ar metus, naudokite `plus` ir `minus` metodus. Šie metodai grąžina naują `Temporal.PlainDate` objektą:

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

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

Datų palyginimas

Galite palyginti datas naudodami `compare` metodą:

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

console.log(Temporal.PlainDate.compare(date1, date2)); // Išvestis: -1 (date1 yra ankstesnė nei date2)

Darbas su laikais

`Temporal.PlainTime` kūrimas

Norėdami sukurti `Temporal.PlainTime`, naudokite konstruktorių:

const plainTime = new Temporal.PlainTime(10, 30, 0); // Valanda, minutė, sekundė
console.log(plainTime.toString()); // Išvestis: 10:30:00

Arba naudokite `from` metodą su ISO 8601 laiko eilute:

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

Laiko komponentų gavimas

console.log(plainTime.hour); // Išvestis: 10
console.log(plainTime.minute); // Išvestis: 30
console.log(plainTime.second); // Išvestis: 0

Laiko aritmetika

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

Darbas su data ir laiku kartu

`Temporal.PlainDateTime` kūrimas

Galite sukurti `Temporal.PlainDateTime` tiesiogiai arba sujungdami `Temporal.PlainDate` ir `Temporal.PlainTime`:

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

Laiko juostos

Teisingas laiko juostų valdymas yra labai svarbus programoms, dirbančioms su vartotojais skirtingose vietose. Temporal API suteikia tvirtą laiko juostų palaikymą per `Temporal.ZonedDateTime` ir `Temporal.TimeZone` objektus.

`Temporal.ZonedDateTime` kūrimas

Norint sukurti `Temporal.ZonedDateTime`, jums reikės `Temporal.PlainDateTime` ir laiko juostos identifikatoriaus. Laiko juostų identifikatoriai yra pagrįsti IANA laiko juostų duomenų baze (pvz., `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()); // Išvestis: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (Poslinkis priklausys nuo vasaros laiko taisyklių)

Arba sukurkite `Temporal.ZonedDateTime` iš `Instant`.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // Laiko žymos pavyzdys
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // Laiko juosta, pvz., 'America/Los_Angeles'
console.log(zonedDateTimeFromInstant.toString());

Konvertavimas tarp laiko juostų

Galite konvertuoti `Temporal.ZonedDateTime` į kitą laiko juostą naudodami `withTimeZone` metodą:

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

Darbas su laiko juostų poslinkiais

`Temporal.TimeZone` objekto `getOffsetStringFor` metodas pateikia poslinkio eilutę nurodytam `Temporal.Instant`:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // Išvestis: -07:00 (Priklausomai nuo vasaros laiko taisyklių)

Norint atlikti tikslius skaičiavimus, būtina naudoti teisingus IANA laiko juostų identifikatorius. Šie identifikatoriai yra nuolat prižiūrimi ir atnaujinami, kad atspindėtų vasaros laiko ir laiko juostų ribų pokyčius.

Trukmės

`Temporal.Duration` objektas atspindi laiko tarpą. Jis gali būti naudojamas pridedant prie datų ir laikų arba atimant iš jų.

`Temporal.Duration` kūrimas

Galite sukurti `Temporal.Duration` naudodami konstruktorių, nurodydami metus, mėnesius, dienas, valandas, minutes, sekundes, milisekundes, mikrosekundes ir nanosekundes:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // Metai, mėnesiai, dienos, valandos, minutės, sekundės, milisekundės, mikrosekundės, nanosekundės
console.log(duration.toString()); // Išvestis: P1Y2M3DT4H5M6.007008009S

Arba naudojant ISO 8601 trukmės eilutę:

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

Trukmių pridėjimas prie datų ir laikų

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

Atkreipkite dėmesį, kad pridedant trukmes, apimančias mėnesius ar metus, prie datų reikia atidžiai apsvarstyti, nes dienų skaičius mėnesyje ar metais gali skirtis.

Kalendorių sistemos

Temporal API palaiko skirtingas kalendorių sistemas, ne tik Grigaliaus kalendorių. Tai labai svarbu programoms, kurioms reikia tvarkyti datas įvairiuose kultūriniuose kontekstuose. Nors palaikymas vis dar tobulinamas, jis suteikia pagrindą ateities plėtrai.

Alternatyvių kalendorių naudojimas

Norėdami naudoti konkretų kalendorių, galite jį nurodyti kurdami Temporal objektus:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // Konkreti išvestis gali skirtis priklausomai nuo įgyvendinimo ir formatavimo. Šio rašymo metu daugelyje aplinkų reikalauja polyfill.

Svarbu: Ne Grigaliaus kalendorių palaikymui gali prireikti „polyfills“ arba specifinio naršyklės/aplinkos palaikymo. Naujausią informaciją rasite Temporal API dokumentacijoje ir naršyklių suderinamumo lentelėse.

Datų ir laikų formatavimas

Nors Temporal API daugiausia dėmesio skiria datų ir laiko manipuliavimui, formatavimą paprastai tvarko `Intl.DateTimeFormat` objektas, kuris yra Internacionalizacijos API dalis. Temporal objektai sklandžiai veikia su `Intl.DateTimeFormat`.

`Intl.DateTimeFormat` naudojimas

Štai kaip formatuoti `Temporal.PlainDate` naudojant `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)); // Išvestis: October 27, 2024

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

Galite pritaikyti formato parinktis pagal savo poreikius. Pirmasis argumentas `Intl.DateTimeFormat` yra lokalė, kuri nustato formatavimui naudojamą kalbą ir regionines taisykles. Naudojant skirtingas lokales (pvz., 'en-US', 'de-DE', 'fr-FR', 'ja-JP') gaunami skirtingi išvesties formatai.

`Temporal.ZonedDateTime` formatavimas

`Temporal.ZonedDateTime` formatavimas yra panašus, tačiau į išvestį taip pat galite įtraukti informaciją apie laiko juostą:

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)); // Išvestis: October 27, 2024, 10:30 AM PDT (Laiko juostos santrumpa priklauso nuo vasaros laiko taisyklių)

Geriausios internacionalizacijos praktikos

Dirbdami su datomis ir laikais pasauliniame kontekste, atsižvelkite į šias geriausias praktikas:

Naudokite IANA laiko juostų identifikatorius: Visada naudokite IANA laiko juostų identifikatorius (pvz., `America/Los_Angeles`, `Europe/London`), kad laiko juostos būtų tvarkomos tiksliai.
Žinokite apie vasaros laiką: Vasaros laikas (DST) gali paveikti laiko juostų poslinkius. Temporal API automatiškai tvarko DST perėjimus.
Naudokite `Intl.DateTimeFormat` formatavimui: Naudokite `Intl.DateTimeFormat` objektą datoms ir laikams formatuoti pagal vartotojo lokalę.
Apsvarstykite kalendorių sistemas: Jei jūsų programa turi palaikyti vartotojus skirtinguose kultūriniuose kontekstuose, apsvarstykite galimybę naudoti alternatyvias kalendorių sistemas.
Saugokite datas ir laikus UTC formatu: Saugant datas ir laikus duomenų bazėje, geriausia praktika yra saugoti juos UTC (Pasauliniu koordinuotuoju laiku), kad išvengtumėte laiko juostų problemų. Vėliau, rodant vartotojui, konvertuokite į vietinį laiką. Temporal suteikia metodus konvertuoti į UTC ir iš jo.
Kruopščiai testuokite: Išbandykite savo programą su skirtingomis laiko juostomis, lokalėmis ir kalendorių sistemomis, kad įsitikintumėte, jog ji veikia teisingai visiems vartotojams.

Temporal API palyginimas su senuoju Date objektu

Štai lentelė, pabrėžianti pagrindinius skirtumus ir Temporal API privalumus, palyginti su senuoju `Date` objektu:

Savybė	Senasis `Date` objektas	Temporal API
Kintamumas	Kintamas (keičia pradinį objektą)	Nekintamas (grąžina naujus objektus)
Laiko juostų palaikymas	Ribotas ir dažnai problemiškas	Tvirtas ir tikslus, pagrįstas IANA laiko juostų duomenų baze
API	Nenuosekli ir sudėtinga naudoti	Aiški, nuosekli ir intuityvi
Tikslumas	Milisekundė	Nanosekundė
Kalendorių sistemos	Apribota Grigaliaus kalendoriumi	Palaiko alternatyvias kalendorių sistemas (su tobulėjančiu palaikymu)
Internacionalizacija	Reikalingos išorinės bibliotekos tvirtai internacionalizacijai	Integruotas palaikymas ir sklandi integracija su `Intl.DateTimeFormat`

Naršyklių palaikymas ir „Polyfills“

Kadangi tai yra gana nauja API, naršyklių palaikymas Temporal API vis dar tobulėja. Patikrinkite naujausias naršyklių suderinamumo lenteles (pvz., MDN Web Docs), kad pamatytumėte, kurios naršyklės ir aplinkos ją palaiko natūraliai. Senesnėms naršyklėms ar aplinkoms be natūralaus palaikymo galite naudoti „polyfills“, kad suteiktumėte Temporal API funkcionalumą. Ieškokite „Temporal API polyfill“ internete, kad rastumėte tinkamas parinktis.

Išvada

JavaScript Temporal API yra reikšmingas žingsnis į priekį tvarkant datas ir laikus JavaScript. Dėl jo nekintamumo, aiškios API, tvirto laiko juostų palaikymo ir kalendorių sistemų galimybių jis tampa galingu įrankiu programuotojams, kuriantiems programas, kurioms reikia tiksliai ir patikimai dirbti su datomis ir laikais įvairiuose tarptautiniuose kontekstuose. Nors naršyklių palaikymas vis dar tobulėja, dėl Temporal API privalumų verta jį išmokti ir pritaikyti naujiems projektams. Pasinaudodami Temporal API ir laikydamiesi geriausių internacionalizacijos praktikų, galite sukurti programas, kurios suteikia sklandžią ir tikslią datos bei laiko patirtį vartotojams visame pasaulyje.

MLOG