Beveik bet kokia programa, parašyta „JavaScript“, tam tikra prasme veikia su laiku ar datomis. Iš pradžių tai apsiribojo integruota datos API. Ši API apima pagrindines funkcijas, tačiau jos galimybės yra gana ribotos. Trečiųjų šalių bibliotekos, pvz., Moment.js, ir vėliau integruotos API, pvz., Intl API ir naujoji laikino API, suteikia daug daugiau lankstumo dirbant su laiku ir datomis. The Rise and Fall Of Moment.js Moment.js yra „JavaScript“ biblioteka su galingomis priemonėmis, skirtomis dirbti su laiku ir datomis. Į jį įtrauktos trūkstamos pagrindinės datos API funkcijos, pvz., manipuliavimas laiko juosta, ir daugelis įprastų operacijų tampa paprastesnės. Moment taip pat yra datos ir laiko formatavimo funkcijos. Ji tapo plačiai naudojama biblioteka įvairiose programose. Tačiau „Moment“ taip pat turėjo problemų. Tai didelė biblioteka ir gali žymiai padidinti programos paketo dydį. Kadangi biblioteka nepalaiko medžio drebėjimo (šiuolaikinių rinktuvų funkcija, galinti pašalinti nenaudojamas bibliotekų dalis), įtraukiama visa „Moment“ biblioteka, net jei naudojate tik vieną ar dvi jos funkcijas. Kita „Moment“ problema yra tai, kad jo sukurti objektai yra keičiami. Tam tikrų „Moment“ objekto funkcijų iškvietimas turi šalutinį poveikį ir pakeičia to objekto vertę. Tai gali sukelti netikėtą elgesį ar klaidas. 2020 metais „Moment“ prižiūrėtojai nusprendė biblioteką įjungti priežiūros režimu. Naujos funkcijos nekuriamos, o prižiūrėtojai nerekomenduoja jų naudoti naujiems projektams. Yra ir kitų „JavaScript“ datų bibliotekų, pvz., „data-fns“, tačiau mieste yra naujas grotuvas – API, tiesiogiai integruota į „JavaScript“: „Temoral“. Tai naujas standartas, kuris užpildo pradinės datos API skyles, taip pat išsprendžia kai kuriuos apribojimus, esančius „Moment“ ir kitose bibliotekose. Kas yra Laikinas? Temporal yra nauja laiko ir datos API, pridedama prie ECMAScript standarto, kuris apibrėžia šiuolaikinį JavaScript. 2026 m. kovo mėn.6 jis pasiekė 4 TC39 proceso etapą (komitetas, kuris prižiūri JavaScript kalbos pasiūlymus ir papildymus) ir bus įtrauktas į kitą ECMAScript specifikacijos versiją. Jis jau įdiegtas keliose naršyklėse: „Chrome 144+“ ir „Firefox 139+“, o „Safari“ netrukus pasirodys. Polifill taip pat galimas nepalaikomoms naršyklėms ir Node.js. Laikinoji API sukuria objektus, kurie paprastai atspindi laiko momentus. Tai gali būti viso laiko ir datos antspaudai tam tikroje laiko juostoje arba gali būti bendras „sieninio laikrodžio“ laiko pavyzdys be jokios laiko juostos ar datos informacijos. Kai kurios pagrindinės Temporal funkcijos:
Laikai su datomis arba be jų. Laikinasis objektas gali rodyti konkretų laiką konkrečioje datoje arba laiką be jokios datos informacijos. Taip pat gali būti nurodyta konkreti data be laiko. Laiko juostos palaikymas. Laikini objektai visiškai žino laiko juostą ir gali būti konvertuojami į skirtingas laiko juostas. „Moment“ taip pat palaiko laiko juostas, tačiau tam reikia papildomos momento laiko juostos bibliotekos. Nekintamumas. Sukūrus laikinąjį objektą, jo pakeisti negalima. Laiko aritmetika arba laiko juostos konvertavimas nekeičia pagrindinio objekto. Vietoj to jie sukuria naują laikinį objektą. 1 pagrindu pagrįstas indeksavimas. Dažnas datos API (taip pat ir „Moment“) klaidų šaltinis yra tai, kad mėnesiai nėra indeksuojami. Tai reiškia, kad sausis yra 0 mėnuo, o ne 1 mėnuo, kaip mes visi suprantame realiame gyvenime. „Temoral“ tai išsprendžia naudojant 1 pagrįstą indeksavimą – sausis yra 1 mėnuo. Jis integruotas į naršyklę. Kadangi Temporal yra API pačioje naršyklėje, ji nieko neprideda prie programos paketo dydžio.
Taip pat svarbu pažymėti, kad datos API neišnyks. Nors „Temoral“ pakeičia šią API, ji nėra pašalinama ar nebenaudojama. Daugelis programų sugestų, jei naršyklės staiga pašalintų datos API. Tačiau taip pat atminkite, kad „Moment“ dabar yra laikomas senu projektu priežiūros režimu. Likusioje straipsnio dalyje apžvelgsime keletą „receptų“, kaip perkelti akimirksnį kodą į naują laikinąją API. Pradėkime pertvarkyti! Datos ir laiko objektų kūrimas Kad galėtume manipuliuoti datomis ir laikais, turime sukurti juos reprezentuojančius objektus. Norėdami sukurti momentinį objektą, vaizduojantį dabartinę datą ir laiką, naudokite momento funkciją. const dabar = momentas (); console.log(dabar); // Akimirka<2026-02-18T21:26:29-05:00>
Dabar šį objektą galima suformatuoti arba manipuliuoti pagal poreikį.
// konvertuoti į UTC //įspėjimas: tai pakeičia momento objektą ir perkelia jį į UTC režimą! console.log(now.utc()); // Akimirka<2026-02-19T02:26:29Z>
// atspausdinti suformatuotą eilutę – atkreipkite dėmesį, kad dabar naudojamas UTC laikas console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 2026-02-19 02:27:07 val
Svarbiausias dalykas, kurį reikia atsiminti apie momentą, yra tai, kad momento objektas visada apima informaciją apie laiką ir datą. Jei reikia dirbti tik su laiko informacija, tai paprastai yra gerai, tačiau tai gali sukelti netikėtą elgesį tokiose situacijose kaip vasaros laikas arba keliamieji metai, kai data gali turėti įtakos laiko skaičiavimams. Laikinas yra lankstesnis. Galite sukurti objektą, vaizduojantį dabartinę datą ir laiką, sukurdami objektą Temporal.Instant. Tai yra laiko momentas, apibrėžtas nuo „epochos“ (1970 m. sausio 1 d. vidurnakčio UTC). „Temporal“ gali nurodyti šią akimirką nanosekundės tikslumu. const now = Laikinas.Dabar.instant();
// žr. neapdorotas nanosekundes nuo epochos console.log(dabar.epochNanosekundės); // 1771466342612000000n
// UTC formatas console.log(dabar.toString()); // 2026-02-19T01:55:27.844Z
// tam tikros laiko juostos formatas console.log(now.toString({ laiko juosta: 'Amerika/Niujorkas' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Momentiniai objektai taip pat gali būti sukurti tam tikram laikui ir datai naudojant statinį metodą.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatuokite akimirksnį pagal vietinę laiko juostą. Atminkite, kad tai tik valdo // formatavimas – jis nekeičia objekto, kaip daro moment.utc. console.log(myInstant.toString({ laiko juosta: 'Amerika/Niujorkas' })); // 2026-02-18T21:10:00-05:00
Taip pat galite kurti kitų tipų laikinuosius objektus, įskaitant:
Temporal.PlainDate: data be laiko informacijos. Temporal.PlainTime: laikas be datos informacijos. Temporal.ZonedDateTime: data ir laikas konkrečioje laiko juostoje.
Kiekvienas iš jų turi iš metodą, kurį galima iškviesti naudojant objektą, nurodantį datą ir (arba) laiką, arba analizuojamą datos eilutę. // Tiesiog pasimatymas const today = Temporal.PlainDate.from({ metai: 2026 m. mėnuo: 2, // atkreipkite dėmesį, kad vasario mėnesį naudojame 2 diena: 18 }); console.log(today.toString()); // 2026-02-18
// Tiesiog laikas const lunchTime = Temporal.PlainTime.from({ valanda: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Data ir laikas JAV Rytų laiko juostoje const dueAt = Temporal.ZonedDateTime.from({ laiko juosta: „Amerika/Niujorkas“, metai: 2026 m. mėnuo: 3, diena: 1, valanda: 12 val. minutė: 0, antras: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/Niujorkas]
Analizuojama Mes aptarėme programinį datos ir laiko informacijos kūrimą. Dabar pažiūrėkime į analizę. Analizavimas yra viena sritis, kurioje „Moment“ yra lankstesnė nei įmontuota „Temoral“ API. Galite išanalizuoti datos eilutę, perduodami ją momento funkcijai. Naudojant vieną argumentą, „Moment“ tikisi ISO datos eilutės, tačiau galite naudoti alternatyvius formatus, jei pateikiate antrą argumentą, nurodantį naudojamą datos formatą.
const isoDate = momentas ('2026-02-21T09:00:00'); const formattedData = momentas ('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // Akimirka<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Akimirka<2026-02-21T09:00:00-05:00>
Senesnėse versijose „Moment“ geriausiai spėtų išanalizuoti bet kokią savavališkai suformatuotą datos eilutę. Tai gali sukelti nenuspėjamų rezultatų. Pavyzdžiui, 2026-03-02 vasario 2 ar kovo 3 d.? Dėl šios priežasties naujesnėse „Moment“ versijose rodomas ryškus įspėjimas apie naudojimo nutraukimą, jei jis iškviečiamas be ISO formato datos eilutės (nebent taip pat pateikiamas antrasis argumentas norimu formatu). Temporal analizuos tik specialiai suformatuotą datos eilutę. Eilutė turi atitikti ISO 8601 formatą arba jo plėtinį RFC 9557. Jei neatitinkanti datos eilutė perduodama metodui from, Temporal parodys RangeError.
// Naudojant RFC 9557 datos eilutę const myDate = Laikinoji.Instant.from('2026-02-21T09:00:00-05:00[Amerika/Niujorkas]'); console.log(myDate.toString({ laiko juosta: 'Amerika/Niujorkas' })); // 2026-02-21T09:00:00-05:00
// Naudojant nežinomą datos eilutę const otherDate = Laikinas.Momentinis.from('2/21/26 9:00:00'); // RangeError: Laikinoji klaida: Netinkamas simbolis analizuojant metų vertę.
Tikslūs datos eilutės reikalavimai priklauso nuo to, kokio tipo laikinąjį objektą kuriate. Aukščiau pateiktame pavyzdyje Temporal.Instant reikalingas visas ISO8601 arba RFC 9557 datos eilutė, nurodanti datą ir laiką su laiko juostos poslinkiu, bet taip pat galite sukurti „PlainDate“ arba „PlainTime“ objektus naudodami tik datos formato poaibį. const myDate = Laikinas.PaprastasData.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(manoLaikas.toString()); // 09:00:00
Atminkite, kad šios eilutės vis tiek turi atitikti numatytą formatą, priešingu atveju bus pateikta klaida.
// Naudojant neatitinkančias laiko eilutes. Visa tai sukels RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profesionalo patarimas: tvarkykite ne ISO eilutes, nes „Temoral“ teikia pirmenybę patikimumui, todėl jis nebandys atspėti tokios eilutės formato, kaip 2026-01-02. Jei jūsų duomenų šaltinis naudoja tokias eilutes, prieš bandydami ją naudoti su Temporal, turėsite atlikti tam tikrą manipuliavimą eilute, kad pertvarkytumėte reikšmes į ISO eilutę, pvz., 2026-02-01.
Formatavimas Kai turėsite momentinį arba laikinį objektą, tikriausiai norėsite jį konvertuoti į suformatuotą eilutę. Tai atvejis, kai akimirka yra šiek tiek trumpesnė. Objekto formato metodą iškviečiate naudodami žetonų eilutę, apibūdinančią norimą datos formatą. const data = momentas ();
console.log(data.format('MM/DD/YYYY')); // 2026-02-22
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 2026 m. vasario 22 d., 20:18:30
Kita vertus, „Temoral“ reikalauja, kad būtumėte šiek tiek išsamesni. Laikinieji objektai, pvz., Intuityvioji paieška, turi toLocaleString metodą, kuris priima įvairias formatavimo parinktis, nurodytas kaip objekto ypatybės.
const data = Laikinas.Dabar.instant();
// be argumentų gausime numatytąjį dabartinės lokalės formatą console.log(date.toLocaleString()); // 2026-02-22, 20:23:36 (darant prielaidą, kad lokalė yra en-US)
// perduoti formatavimo parinktis, kad sugeneruotumėte pasirinktinio formato eilutę console.log(date.toLocaleString('en-US', { mėnuo: „ilgas“, diena: "skaičiai", metai: „skaitinis“, valanda: „2 skaitmenų“, minutė: '2 skaitmenų' })); // 2026 m. vasario 22 d., 20:23
// formato eilutėje perduokite tik norimus laukus console.log(date.toLocaleString('en-US', { mėnuo: "trumpas", diena: "skaičiai" })); // Vasario 22 d
Laikinam datos formatavimui iš tikrųjų naudojama Intl.DateTimeFormat API (kuri jau lengvai pasiekiama šiuolaikinėse naršyklėse) po gaubtu. Tai reiškia, kad galite sukurti pakartotinai naudojamą DateTimeFormat objektą naudodami pasirinktines formatavimo parinktis, tada perduoti laikinus objektus jo formatavimo metodui. Dėl šios priežasties jis nepalaiko pasirinktinių datos formatų, kaip tai daro „Moment“. Jei jums reikia tokio dalyko kaip „2026 m. I ketvirtis“ ar kito specializuoto formatavimo, gali prireikti tinkinto datos formatavimo kodo arba kreiptis į trečiosios šalies biblioteką. const formater = new Intl.DateTimeFormat('en-US', { mėnuo: '2 skaitmenys', diena: '2 skaitmenys', metai: 'skaitinis' });
const data = Laikinas.Dabar.instant(); console.log(formateris.format(data)); // 2026-02-22
„Moment“ formatavimo prieigos raktus rašyti paprasčiau, tačiau jie nėra pritaikyti lokaliai. Formato eilutės „kietasis kodas“ pateikia tokius dalykus kaip mėnesio / dienos tvarka. Konfigūracijos objekto naudojimo pranašumas, kaip tai daro Temporal, yra tas, kad jis automatiškai prisitaikys prie bet kurios konkrečios lokalės ir naudos tinkamą formatą. const data = Laikinas.Dabar.instant();
const formatOptions = { mėnuo: „skaitinis“, diena: "skaičiai", metai: 'skaitinis' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2026-02-22
console.log(date.toLocaleString('en-GB', formatOptions)); // 2026-02-22
Datos skaičiavimai Daugelyje programų turėsite atlikti tam tikrus skaičiavimus datą. Galbūt norėsite pridėti arba atimti laiko vienetus (dienas, valandas, sekundes ir kt.). Pavyzdžiui, jei turite dabartinę datą, galbūt norėsite vartotojui parodyti datą po 1 savaitės nuo dabar. Momentiniai objektai turi tokius metodus kaip sudėtis ir atimti, kurie atlieka šias operacijas. Šios funkcijos turi reikšmę ir vienetą, pavyzdžiui: add(7, 'days'). Tačiau vienas labai svarbus skirtumas tarp „Moment“ ir „Temporal“ yra tas, kad atliekant šiuos datos skaičiavimus, pagrindinis objektas yra modifikuojamas ir prarandama pradinė jo vertė. const dabar = momentas ();
console.log(dabar); // Akimirka<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dienos'); console.log(nextWeek); // Akimirka<2026-03-03T20:08:36-05:00>
// Gotcha – pradinis objektas buvo mutavęs console.log(dabar); // Akimirka<2026-03-03T20:08:36-05:00>
Kad neprarastumėte pradinės datos, galite iškviesti Moment objekto kloną ir sukurti kopiją. const dabar= momentas(); const nextWeek = now.clone().add(7, 'dienos');
console.log(dabar); // Akimirka<2026-02-24T20:12:55-05:00>
console.log(nextWeek); // Akimirka<2026-03-03T20:12:55-05:00>
Kita vertus, laikinieji objektai yra nekintantys. Sukūrus objektą, pvz., Instant, PlainDate ir pan., to objekto vertė niekada nepasikeis. Laikinieji objektai taip pat turi pridėjimo ir atėmimo metodus. Temporal yra šiek tiek išrankus, kokius laiko vienetus galima pridėti prie kokių tipų objektų. Pavyzdžiui, negalite pridėti dienų prie Intuityviosios paieškos:
const now = Laikinas.Dabar.instant(); const nextWeek = now.add({ dienų: 7 }); // RangeError: Laikinoji klaida: didžiausias vienetas negali būti datos vienetas
Taip yra todėl, kad momentiniai objektai nurodo konkretų laiko momentą UTC ir yra kalendoriniai agnostiniai. Kadangi dienos trukmė gali keistis atsižvelgiant į laiko juostos taisykles, pvz., vasaros laiką, šis skaičiavimas negalimas naudojant Instant. Tačiau šią operaciją galite atlikti su kitų tipų objektais, pvz., PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2026-02-24, 20:23:59
const nextWeek = now.add({ dienų: 7 });
// Atminkite, kad pradinis PlainDateTime lieka nepakitęs console.log(now.toLocaleString()); // 2026-02-24, 20:23:59
console.log(nextWeek.toLocaleString()); // 2026-03-03, 20:23:59
Taip pat galite apskaičiuoti, kiek laiko yra tarp dviejų momentinių arba laikinų objektų. Naudodami „Moment“ skirtumo funkciją, turite pateikti detalumo vienetą, kitaip jis grąžins skirtumą milisekundėmis. const date1 = momentas ('2026-02-21T09:00:00'); const date2 = momentas ('2026-02-22T10:30:00');
console.log(data2.diff(data1)); // 91800000
console.log(data2.diff(data1, 'dienos')); // 1
Norėdami tai padaryti su laikinuoju objektu, galite perduoti kitą laikinąjį objektą jo metodams iki arba nuo. Tai grąžina objektą Temporal.Duration, kuriame yra informacija apie laiko skirtumą. Trukmės objektas turi kiekvieno skirtumo komponento ypatybes, taip pat gali sugeneruoti ISO 8601 trukmės eilutę, atspindinčią laiko skirtumą.
const date1 = Laikinas.PaprastasDateTime.from('2026-02-21T09:00:00'); const date2 = Laikinas.PaprastasDateLaikas.from('2026-02-22T10:30:00');
// Didžiausias vienetas nurodo didžiausią laiko vienetą // trukmės skaičiavime const diff = data2.nuo(data1, { didžiausias Vienetas: 'diena' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 trukmės eilutė: 1 diena, 1 valanda, 30 minučių)
Datų ir laikų palyginimas „Moment“ ir „Temoral“ leidžia palyginti datas ir laikus, kad nustatytumėte, kuris yra pirmesnis už kitą, tačiau taikant skirtingus API metodus. „Moment“ pateikia tokius metodus kaip „isBefore“, „isAfter“ ir „isSame“, kad būtų galima palyginti du „Moment“ objektus. const date1 = momentas ('2026-02-21T09:00:00'); const date2 = momentas ('2026-02-22T10:30:00');
console.log(data1.isBefore(data2)); // tiesa
„Temporal“ naudoja statinio palyginimo metodą, kad palygintų du to paties tipo objektus. Grąžina -1, jei pirmoji data yra prieš antrąją, 0, jei jie yra lygūs, arba 1, jei pirmoji data ateina po antrosios. Šiame pavyzdyje parodyta, kaip palyginti du „PlainDate“ objektus. Abu Temporal.PlainDate.compare argumentai turi būti PlainDate objektai.
const date1 = Temporal.PlainDate.from({ metai: 2026, mėnuo: 2, diena: 24 }); const date2 = Laikinoji.PaprastaDate.from({ metai: 2026, mėnuo: 3, diena: 24 });
// data1 yra anksčiau nei data2, taigi -1 console.log(Temporal.PlainDate.palyginti(data1, data2));
// Klaida, jei bandome palyginti du skirtingų tipų objektus console.log(Temporal.PlainDate.palyginti(data1, Laikinas.Dabar.instant())); // Tipo klaida: Laikinoji klaida: pateikti neteisingi „PlainDate“ laukai.
Visų pirma, tai leidžia lengvai rūšiuoti laikinų objektų masyvą chronologiškai. // Temporal.PlainDate objektų masyvas const datos = [ ... ];
// naudokite Temporal.PlainDate.compare kaip lyginamąją funkciją datos.rūšiuoti(Temporal.PlainDate.palyginti);
Laiko juostos konversijos Pagrindinė „Moment“ biblioteka nepalaiko laiko juostų konvertavimo. Jei jums reikia šios funkcijos, taip pat turite įdiegti moment-timezone paketą. Šis paketas nėra purtomas medžiui, todėl gali žymiai padidinti jūsų ryšulio dydį. Įdiegę momento laiko juostą, galite konvertuoti momentinius objektus į skirtingas laiko juostas naudodami tz metodą. Kaip ir kitose „Moment“ operacijose, tai keičia pagrindinį veiksnįobjektas. // Darant prielaidą, kad JAV Rytų laikas const dabar = momentas (); console.log(dabar); // Akimirka<2026-02-28T20:08:20-05:00>
// Konvertuoti į Ramiojo vandenyno laiką. // Pradinis Rytų laikas prarastas. now.tz('Amerika/Los_Angelas'); console.log(dabar); // Akimirka<2026-02-28T17:08:20-08:00>
Laiko juostos funkcionalumas yra integruotas į Temporal API, kai naudojamas Temporal.ZonedDateTime objektas. Šie objektai apima withTimeZone metodą, kuris grąžina naują ZonedDateTime, atspindintį tą patį laiko momentą, bet nurodytą laiko juostą. // Vėlgi, darant prielaidą JAV Rytų laiku const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2026-02-28, 20:12:02 EST
// Konvertuoti į Ramiojo vandenyno laiką const nowPacific = now.withTimeZone('Amerika/Los_Angelas'); console.log(nowPacific.toLocaleString()); // 2026-02-28, 17:12:02 PST
// Originalus objektas lieka nepakitęs console.log(now.toLocaleString()); // 2026-02-28, 20:12:02 EST
Pastaba: Formatuotos reikšmės, kurias grąžina toLocaleString, priklauso nuo lokalės, kaip rodo pavadinimas. Pavyzdinis kodas buvo sukurtas en-US lokale, todėl formatas yra toks: 2026-02-28, 17:12:02 PST. Kitoje vietovėje tai gali skirtis. Pavyzdžiui, en-GB lokale gausite kažką panašaus į 28/2/2026, 17:12:02 GMT-8. Realaus pasaulio pertvarkymas Tarkime, kad kuriame programą, skirtą įvykiams planuoti įvairiose laiko juostose. Dalis šios programos yra funkcija getEventTimes, kuri paima ISO 8601 eilutę, nurodant įvykio laiką ir datą, vietinę laiko juostą ir tikslinę laiko juostą. Funkcija sukuria formatuotas įvykio laiko ir datos eilutes abiejose laiko juostose. Jei funkcijai pateikiama įvesties eilutė, kuri nėra tinkama laiko / datos eilutė, ji išmes klaidą. Štai originalus įgyvendinimas naudojant „Moment“ (taip pat reikia naudoti momento laiko juostos paketą).
importuoti momentą iš 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMMM D, YYYY, h:mm:ss a z';
// 1. Sukurkite pradinį momentą vartotojo laiko juostoje const eventTime = moment.tz( inputString, moment.ISO_8601, // Tikėtis ISO 8601 eilutės tiesa, // Griežtas analizavimas userTimeZone );
// Įveskite klaidą, jei inputString neatspindi tinkamos datos if (!eventTime.isValid()) { throw new Error('Netinkama datos/laiko įvestis'); }
// 2. Apskaičiuokite tikslinį laiką // KRITIŠKA: turime klonuoti, kitaip „įvykio laikas“ pasikeis amžinai! const targetTime = eventTime.clone().tz(targetTimeZone);
return { vietinis: eventTime.format(timeFormat), tikslas: targetTime.format(timeFormat), }; }
const tvarkaraštis = getEventTimes( „2026-03-05T15:00-05:00“, „Amerika/Niujorkas“, „Europa/Londonas“, );
console.log(schedule.local); // 2026 m. kovo 5 d., 15:00:00 EST
console.log(schedule.target); // 2026 m. kovo 5 d., 20:00 val. GMT
Šiame pavyzdyje naudojame numatomą datos formatą ISO 8601, kuris yra naudingai integruotas į „Moment“. Taip pat naudojame griežtą analizę, o tai reiškia, kad „Moment“ nebandys atspėti naudodama datos eilutę, kuri neatitinka formato. Jei perduodama ne ISO datos eilutė, datos objektas bus netinkamas ir mes įvesime klaidą. Laikinasis diegimas atrodo panašiai, tačiau turi keletą pagrindinių skirtumų.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Išnagrinėkite įvestį tiesiai į Intuityviąją paiešką, tada sukurkite // „ZonedDateTime“ vartotojo zonoje. const instant = Laikinoji.Instant.from(inputString); const įvykioLaikas = momentinis.toZonedDateTimeISO(userTimeZone);
// 2. Konvertuoti į tikslinę zoną // Tai automatiškai grąžina NAUJĄ objektą; „EventTime“ yra saugus. const targetTime = įvykioLaikas.withTimeZone(targetTimeZone);
// 3. Formatuokite naudojant „Intl“ (įtaisyta) const parinktys = { metai: „skaitinis“, mėnuo: "trumpas", diena: "skaičiai", valanda: 'skaitmeninis', minutė: '2 skaitmenys', antrasis: „2 skaitmenų“, timeZoneName: 'short' };
return { vietinis: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, options) }; }
const tvarkaraštis = getEventTimes( „2026-03-05T15:00-05:00“, „Amerika/Niujorkas“, „Europa/Londonas“, );
console.log(schedule.local); // 2026 m. kovo 5 d., 15:00:00 EST
console.log(schedule.target); // 2026 m. kovo 5 d., 20:00 PM GMT
Naudodami „Moment“, turime aiškiai nurodyti gaunamų datos eilučių formato eilutę. Neatsižvelgiant į naudotojo vietą ar lokalę, įvykių laikas visada bus suformatuotas kaip 2026 m. kovo 5 d., 3:00:00pm EST. Be to, mes neturime aiškiai nurodyti išimties. Jei į Temporal.Instant.from perduodama neteisinga eilutė, Temporal padarys mums išimtį. Reikia atkreipti dėmesį į tai, kad net ir griežtai analizuojant „Moment“ versija vis tiek yra švelnesnė. Laikas reikalauja laiko juostos poslinkio eilutės pabaigoje. Taip pat turėtumėte atkreipti dėmesį, kad kadangi mes naudojame navigator.language, šis kodas veiks tik naršyklės aplinkoje, nes Node.js aplinkoje navigatorius neapibrėžtas. Laikinasis diegimas naudoja dabartinę naršyklės lokalę (navigator.language), todėl vartotojas automatiškai gaus įvykių laiką, suformatuotą vietinio laiko formatu. JAV vietovėje tai yra 2026 m. kovo 5 d., 15.00 val. EST. Tačiau jei naudotojas, pavyzdžiui, yra Londone, įvykių laikas bus suformatuotas kaip 2026 m. kovo 5 d., 15:00:00 GMT-5. Santrauka
Veiksmas Moment.js Laikinas Dabartinis laikas akimirka () Temporal.Now.zonedDateTimeISO() Analizuojamas ISO momentas (str) Laikinas.Momentinis.nuo(str) Pridėti laiką .add(7, 'dienos') (mutatuoja) .add({ dienų: 7 }) (naujas objektas) Skirtumas .diff(kita, 'valandos') .nuo(kitos).valandos Laiko juosta .tz('Zona/pavadinimas') .withTimeZone('Zona/pavadinimas')
Iš pirmo žvilgsnio skirtumas gali būti šiek tiek kitoks (o Temporal atveju kartais konkretesnė ir griežtesnė) sintaksė, tačiau naudojant Temporal, palyginti su Moment.js, yra keletas pagrindinių pranašumų:
Aiškesnis reiškia mažiau netikėtumų ir nenumatytų klaidų. Akimirka gali atrodyti švelnesnė, tačiau ji apima „spėliojimą“, dėl kurio kartais gali būti neteisingos datos. Jei nurodysite „Temporal“ ką nors netinkamo, jis išmes klaidą. Jei kodas veikia, žinote, kad turite galiojančią datą. Akimirka gali gerokai padidinti programos paketą, ypač jei naudojate momento laiko juostos paketą. „Temoral“ nieko neprideda (kai jis bus išsiųstas jūsų tikslinėse naršyklėse). Nekintamumas suteikia jums pasitikėjimo, kad niekada neprarasite ir neperrašysite duomenų, kai atliksite datų konvertavimą ir operacijas. Skirtingi laiko atvaizdai (Instant, PlainDateTime, ZonedDateTime), atsižvelgiant į jūsų poreikius, kur momentas visada yra UTC laiko žyma. „Temoral“ naudoja tarptautines API datos formatavimui, o tai reiškia, kad galite turėti formatavimą atsižvelgiant į lokalę, nenurodydami prieigos raktų.
Pastabos apie „Polyfill“. Kaip minėta anksčiau, yra laikinas polifilis, platinamas kaip npm paketas, pavadintas @js-temporal/polyfill. Jei norite naudoti „Temoral“ šiandien, jums reikės šio daugialypės dėmės, kad palaikytumėte tokias naršykles kaip „Safari“, kurios dar nepateikė API. Blogos naujienos yra tai, kad tai padidins jūsų paketo dydį. Geros naujienos yra tai, kad ji vis tiek prideda žymiai mažiau nei momento ar momento laiko juosta. Čia pateikiamas paketų dydžių palyginimas, kurį pranešė Bundlephobia.com, svetainė, kurioje pateikiama informacija apie npm paketų dydžius (spustelėkite kiekvieno paketo pavadinimą, kad pamatytumėte Bundlephobia analizę):
Paketas Sumažintas Sumažintas ir gzipuotas @js-temporal/polyfill 154,1 kB 44,1 kB akimirka 294,4 kB 75,4 kB momentas-laiko juosta 1 MB 114,2 kB
Polifill istoriškai taip pat turėjo tam tikrų našumo problemų, susijusių su atminties naudojimu, ir rašymo metu ji buvo laikoma alfa būsena. Dėl šios priežasties galbūt nenorėsite jo naudoti gamyboje, kol jis nepasieks brandesnės būsenos. Kita gera žinia yra ta, kad tikimės, kad polifilo nebereikės daug ilgiau (žinoma, nebent jums reikės palaikyti senesnes naršykles). Rašymo metu „Temoral“ buvo pristatyta „Chrome“, „Edge“ ir „Firefox“. Jis dar nėra visiškai paruoštas „Safari“, nors atrodo, kad jį galima įsigyti su vykdymo laiko vėliava naujausioje technologijų peržiūroje.
