Gandrīz jebkura veida lietojumprogramma, kas rakstīta JavaScript, zināmā mērā darbojas ar laikiem vai datumiem. Sākumā tas aprobežojās ar iebūvēto Date API. Šajā API ir iekļauta pamata funkcionalitāte, taču tās iespējas ir diezgan ierobežotas. Trešo pušu bibliotēkas, piemēram, Moment.js, un vēlāk iebūvētās API, piemēram, Intl API un jaunā Temporal API, nodrošina daudz lielāku elastību darbam ar laikiem un datumiem. The Rise and Fall Of Moment.js Moment.js ir JavaScript bibliotēka ar jaudīgām utilītprogrammām darbam ar laikiem un datumiem. Tas ietver trūkstošos funkcijas no pamata datuma API, piemēram, laika joslu manipulācijas, un padara daudzas izplatītas darbības vienkāršākas. Moment ietver arī datuma un laika formatēšanas funkcijas. Tā kļuva par plaši izmantotu bibliotēku daudzās dažādās lietojumprogrammās. Tomēr arī Momentam bija sava daļa problēmu. Tā ir liela bibliotēka, un tā var ievērojami palielināt lietojumprogrammas komplekta lielumu. Tā kā bibliotēka neatbalsta koku kratīšanu (mūsdienu komplektētāju funkcija, kas var noņemt neizmantotās bibliotēku daļas), ir iekļauta visa Moment bibliotēka, pat ja izmantojat tikai vienu vai divas tās funkcijas. Vēl viena Moment problēma ir fakts, ka tā izveidotie objekti ir mainīgi. Noteiktu funkciju izsaukšana Moment objektā rada blakusparādības un maina šī objekta vērtību. Tas var izraisīt neparedzētu uzvedību vai kļūdas. 2020. gadā Moment uzturētāji nolēma bibliotēku pārslēgt uzturēšanas režīmā. Jaunu funkciju izstrāde netiek veikta, un uzturētāji iesaka to neizmantot jauniem projektiem. Ir arī citas JavaScript datumu bibliotēkas, piemēram, date-fns, taču pilsētā ir jauns atskaņotājs — API, kas ir iebūvēts tieši JavaScript: Temporal. Tas ir jauns standarts, kas aizpilda sākotnējā Date API caurumus, kā arī atrisina dažus ierobežojumus, kas atrodami Moment un citās bibliotēkās. Kas ir pagaidu? Temporal ir jauna laika un datuma API, kas tiek pievienota ECMAScript standartam, kas definē mūsdienu JavaScript. No 2026. gada marta6 tas ir sasniedzis TC39 procesa 4. posmu (komiteja, kas pārrauga JavaScript valodas priekšlikumus un papildinājumus), un tas tiks iekļauts nākamajā ECMAScript specifikācijas versijā. Tas jau ir ieviests vairākās pārlūkprogrammās: Chrome 144+ un Firefox 139+, drīzumā gaidāms arī Safari. Poliaizpilde ir pieejama arī neatbalstītām pārlūkprogrammām un Node.js. Temporal API izveido objektus, kas parasti atspoguļo laika mirkļus. Tie var būt pilna laika un datuma zīmogi noteiktā laika joslā, vai arī tie var būt vispārējs “sienas pulksteņa” laika gadījums bez laika joslas vai datuma informācijas. Dažas no galvenajām Temporal funkcijām ietver:
Laiki ar datumiem vai bez tiem. Pagaidu objekts var attēlot noteiktu laiku noteiktā datumā vai laiku bez datuma informācijas. Var attēlot arī konkrētu datumu bez laika. Laika joslu atbalsts. Laika objekti pilnībā apzinās laika joslu, un tos var pārveidot dažādās laika joslās. Moment atbalsta arī laika joslas, taču tam ir nepieciešama papildu momenta laika joslu bibliotēka. Nemainība. Kad pagaidu objekts ir izveidots, to nevar mainīt. Laika aritmētika vai laika joslu konvertēšana nemaina pamatā esošo objektu. Tā vietā tie ģenerē jaunu pagaidu objektu. Uz 1 balstīta indeksācija. Datuma API (kā arī Moment) bieži sastopams kļūdu avots ir tas, ka mēneši nav indeksēti. Tas nozīmē, ka janvāris ir 0. mēnesis, nevis 1. mēnesis, kā mēs visi saprotam dzīvē. Temporal to novērš, izmantojot indeksēšanu, kuras pamatā ir 1 — janvāris ir 1. mēnesis. Tas ir iebūvēts pārlūkprogrammā. Tā kā Temporal ir API pašā pārlūkprogrammā, tas neko nepievieno jūsu lietojumprogrammas komplekta lielumam.
Ir arī svarīgi ņemt vērā, ka Date API nepazūd. Lai gan Temporal aizstāj šo API, tā netiek noņemta vai novecojusi. Daudzas lietojumprogrammas sabojātos, ja pārlūkprogrammas pēkšņi noņemtu datuma API. Tomēr paturiet prātā, ka Moment tagad tiek uzskatīts par mantotu projektu uzturēšanas režīmā. Pārējā rakstā mēs apskatīsim dažas “receptes” uz momentu balstīta koda migrēšanai uz jauno Temporal API. Sāksim pārstrukturēšanu! Datuma un laika objektu izveide Pirms mēs varam manipulēt ar datumiem un laikiem, mums ir jāizveido objekti, kas tos attēlo. Lai izveidotu momenta objektu, kas attēlo pašreizējo datumu un laiku, izmantojiet momenta funkciju. const tagad = moments(); console.log(tagad); // Mirklis<2026-02-18T21:26:29-05:00>
Tagad šo objektu var formatēt vai manipulēt pēc vajadzības.
// konvertēt uz UTC //brīdinājums: Tas maina Moment objektu un ievieto to UTC režīmā! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// izdrukājiet formatētu virkni — ņemiet vērā, ka pašlaik tiek izmantots UTC laiks console.log(now.format('MM/DD/GGGG hh:mm:ss a')); // 19.02.2026 02:27:07
Galvenais, kas jāatceras par Moment, ir tas, ka Moment objekts vienmēr ietver informāciju par laiku un datumu. Ja jums ir jāstrādā tikai ar laika informāciju, tas parasti ir labi, taču tas var izraisīt neparedzētu rīcību tādās situācijās kā vasaras laiks vai garie gadi, kad datums var ietekmēt laika aprēķinus. Temporal ir elastīgāks. Varat izveidot objektu, kas attēlo pašreizējo datumu un laiku, izveidojot objektu Temporal.Instant. Tas ir laika punkts, ko nosaka laiks kopš “laika” (1970. gada 1. janvāra pusnakts UTC). Temporal var atsaukties uz šo momentu laikā ar nanosekundes līmeņa precizitāti. const now = Temporal.Now.instant();
// skatīt neapstrādātas nanosekundes kopš laikmeta konsole.log(tagad.epochNanosekundes); // 1771466342612000000n
// formāts UTC console.log(tagad.toString()); // 2026-02-19T01:55:27.844Z
// formāts noteiktai laika joslai console.log(now.toString({ laika josla: 'Amerika/Ņujorka' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant objektus var izveidot arī noteiktam laikam un datumam, izmantojot no statisko metodi.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatējiet tūlītējo ziņu vietējā laika joslā. Ņemiet vērā, ka tas tikai kontrolē // formatējums - tas nematē objektu, kā to dara moment.utc. console.log(myInstant.toString({ laika josla: 'Amerika/Ņujorka' })); // 2026-02-18T21:10:00-05:00
Varat arī izveidot cita veida pagaidu objektus, tostarp:
Temporal.PlainDate: datums bez laika informācijas. Temporal.PlainTime: laiks bez datuma informācijas. Temporal.ZonedDateTime: datums un laiks noteiktā laika joslā.
Katrai no tām ir no metode, kuru var izsaukt ar objektu, kas norāda datumu un/vai laiku, vai datuma virkni parsēšanai. // Tikai randiņš const today = Temporal.PlainDate.from({ gads: 2026, mēnesis: 2, // ņemiet vērā, ka februārim mēs izmantojam 2 diena: 18 }); console.log(šodien.toString()); // 2026-02-18
// Tikai laiks const lunchTime = Temporal.PlainTime.from({ stunda: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Datums un laiks ASV austrumu laika joslā const dueAt = Temporal.ZonedDateTime.from({ laika josla: Amerika/Ņujorka, gads: 2026, mēnesis: 3, diena: 1, stunda: 12, minūte: 0, otrais: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/Ņujorka]
Parsēšana Mēs esam aplūkojuši datuma un laika informācijas programmatisku izveidi. Tagad apskatīsim parsēšanu. Parsēšana ir viena joma, kurā Moment ir elastīgāka nekā iebūvētā Temporal API. Varat parsēt datuma virkni, nododot to momenta funkcijai. Izmantojot vienu argumentu, Moment sagaida ISO datuma virkni, taču varat izmantot alternatīvus formātus, ja sniedzat otru argumentu, kas norāda izmantoto datuma formātu.
const isoDate = moments('2026-02-21T09:00:00'); const formattedDatums = moments('21/26 9:00:00', 'M/D/GG h:mm:ss');
konsole.log(isoDate); // Mirklis<2026-02-21T09:00:00-05:00>
konsole.log(formatētsDatums); // Mirklis<2026-02-21T09:00:00-05:00>
Vecākajās versijās Moment vislabāk varētu parsēt jebkuru patvaļīgi formatētu datuma virkni. Tas var novest pie neparedzamiem rezultātiem. Piemēram, vai 02-03-2026 ir 2. februāris vai 3. marts? Šī iemesla dēļ jaunākās Moment versijās tiek parādīts pamanāms nolietojuma brīdinājums, ja tas tiek izsaukts bez ISO formatētas datuma virknes (ja vien nav norādīts arī otrais arguments ar vēlamo formātu). Temporal parsēs tikai īpaši formatētu datuma virkni. Virknei jābūt saderīgai ar ISO 8601 formātu vai tā paplašinājumu RFC 9557. Ja neatbilstoša datuma virkne tiek nodota metodei no, Temporal parādīs RangeError.
// RFC 9557 datuma virknes izmantošana const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Amerika/Ņujorka]'); console.log(myDate.toString({ laika josla: 'Amerika/Ņujorka' })); // 2026-02-21T09:00:00-05:00
// Izmantojot nezināmu datuma virkni const otherDate = Temporal.Instant.from('21/26 9:00:00'); // RangeError: Temporal error: nederīga rakstzīme, analizējot gada vērtību.
Precīzas datuma virknes prasības ir atkarīgas no tā, kāda veida pagaidu objektu jūs veidojat. Iepriekš minētajā piemērā Temporal.Instant ir nepieciešams pilns ISO8601 vai RFC 9557 datuma virkne, kas norāda datumu un laiku ar laika joslas nobīdi, taču varat arī izveidot PlainDate vai PlainTime objektus, izmantojot tikai datuma formāta apakškopu. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myLaiks.toString()); // 09:00:00
Ņemiet vērā, ka šīm virknēm joprojām ir jāatbilst paredzētajam formātam, pretējā gadījumā tiks parādīta kļūda.
// Izmantojot neatbilstošas laika virknes. Tie visi radīs RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profesionāla padoms. Strādājiet ar virknēm, kas nav ISO standarta, jo Temporal prioritāte ir uzticamība, tāpēc tas nemēģinās uzminēt virknes formātu, piemēram, 02-01-2026. Ja jūsu datu avotā tiek izmantotas šādas virknes, pirms mēģināt to izmantot ar Temporal, jums būs jāveic virknes manipulācijas, lai pārkārtotu vērtības ISO virknē, piemēram, 2026-02-01.
Formatēšana Kad jums ir Moment vai Temporal objekts, iespējams, kādā brīdī vēlēsities to pārveidot par formatētu virkni. Šis ir gadījums, kad Moment ir nedaudz kodolīgāks. Jūs izsaucat objekta formāta metodi, izmantojot marķieru virkni, kas apraksta vēlamo datuma formātu. const date = moments();
console.log(date.format('MM/DD/GGGG')); // 22.02.2026
console.log(date.format('MMMM Do GGGG, h:mm:ss a')); // 2026. gada 22. februāris, 20:18:30
No otras puses, lai izmantotu Temporal, jums ir jābūt daudz runīgākam. Temporālajiem objektiem, piemēram, Instant, ir metode toLocaleString, kas pieņem dažādas formatēšanas opcijas, kas norādītas kā objekta rekvizīti.
const date = Temporal.Now.instant();
// bez argumentiem mēs iegūsim pašreizējās lokalizācijas noklusējuma formātu console.log(date.toLocaleString()); // 22.02.2026., 20:23:36 (pieņemot, ka lokalizācija ir en-US)
// nododiet formatēšanas opcijas, lai ģenerētu pielāgota formāta virkni console.log(date.toLocaleString('lv-US', { mēnesis: "garš", diena: "ciparu", gads: "ciparu", stunda: "2 cipari", minūte: "2 cipari" })); // 2026. gada 22. februāris, 20:23
// formāta virknē nododiet tikai vajadzīgos laukus console.log(date.toLocaleString('lv-US', { mēnesis: 'īss', diena: "ciparu" })); // 22. februāris
Laika datuma formatēšana faktiski izmanto Intl.DateTimeFormat API (kas jau ir viegli pieejama mūsdienu pārlūkprogrammās) zem pārsega. Tas nozīmē, ka varat izveidot atkārtoti lietojamu DateTimeFormat objektu ar savām pielāgotajām formatēšanas opcijām un pēc tam nodot Temporal objektus tā formatēšanas metodei. Šī iemesla dēļ tas neatbalsta pielāgotus datuma formātus, piemēram, Moment. Ja jums ir nepieciešams kaut kas līdzīgs 2026. gada 1. ceturksnim vai citam specializētam formatējumam, jums var būt nepieciešams pielāgots datuma formatēšanas kods vai trešās puses bibliotēka. const formatter = new Intl.DateTimeFormat('en-US', { mēnesis: "2 cipari", diena: "2 cipari", gads: "ciparu" });
const date = Temporal.Now.instant(); console.log(formatētājs.formāts(datums)); // 22.02.2026
Moment formatēšanas pilnvaras ir vienkāršāk rakstīt, taču tās nav piemērotas lokalizācijai. Formāts virknē “cietā koda”, piemēram, mēneša/dienas secībā. Konfigurācijas objekta izmantošanas priekšrocība, kā to dara Temporal, ir tāda, ka tas automātiski pielāgosies jebkurai noteiktai lokalizācijai un izmantos pareizo formātu. const date = Temporal.Now.instant();
const formatOptions = { mēnesis: "ciparu", diena: "ciparu", gads: "ciparu" };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.02.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Datumu aprēķini Daudzās lietojumprogrammās jums būs jāveic daži aprēķini datumā. Iespējams, vēlēsities pievienot vai atņemt laika vienības (dienas, stundas, sekundes utt.). Piemēram, ja jums ir pašreizējais datums, iespējams, vēlēsities lietotājam parādīt datumu pēc 1 nedēļas. Momenta objektiem ir tādas metodes kā saskaitīšana un atņemšana, kas veic šīs darbības. Šīs funkcijas ņem vērtību un vienību, piemēram: add(7, 'dienas'). Tomēr viena ļoti svarīga atšķirība starp Moment un Temporal ir tā, ka, veicot šos datuma aprēķinus, tiek modificēts pamatā esošais objekts un tiek zaudēta tā sākotnējā vērtība. const tagad = moments();
console.log(tagad); // Mirklis<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dienas'); console.log(nextWeek); // Mirklis<2026-03-03T20:08:36-05:00>
// Gotcha - sākotnējais objekts tika mutēts console.log(tagad); // Mirklis<2026-03-03T20:08:36-05:00>
Lai nepazaudētu sākotnējo datumu, varat izsaukt Moment objekta klonu, lai izveidotu kopiju. const tagad= moments(); const nextWeek = now.clone().add(7, 'dienas');
console.log(tagad); // Mirklis<2026-02-24T20:12:55-05:00>
console.log(nextWeek); // Mirklis<2026-03-03T20:12:55-05:00>
No otras puses, pagaidu objekti ir nemainīgi. Kad esat izveidojis objektu, piemēram, Instant, PlainDate un tā tālāk, šī objekta vērtība nekad nemainīsies. Temporālajiem objektiem ir arī saskaitīšanas un atņemšanas metodes. Temporal ir nedaudz izvēlīgs attiecībā uz to, kuras laika vienības var pievienot kādiem objektu veidiem. Piemēram, dinamiskajai meklēšanai nevar pievienot dienas:
const now = Temporal.Now.instant(); const nextWeek = now.add({dienas: 7}); // RangeError: Temporal error: lielākā vienība nevar būt datuma vienība
Tas ir tāpēc, ka tūlītējie objekti attēlo noteiktu laika punktu UTC un ir kalendāra agnostiski. Tā kā dienas garums var mainīties atkarībā no laika joslas noteikumiem, piemēram, vasaras laika, šis aprēķins nav pieejams mirklī. Tomēr šo darbību varat veikt ar cita veida objektiem, piemēram, PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
const nextWeek = now.add({dienas: 7});
// Ņemiet vērā, ka sākotnējais PlainDateTime paliek nemainīgs console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Varat arī aprēķināt, cik daudz laika ir starp diviem momenta vai laika objektiem. Izmantojot Moment diff funkciju, jums ir jānorāda precizitātes vienība, pretējā gadījumā tā atgriezīs starpību milisekundēs. const date1 = moments('2026-02-21T09:00:00'); const date2 = moments('2026-02-22T10:30:00');
konsole.log(datums2.diff(datums1)); // 91800000
console.log(datums2.diff(datums1, 'dienas')); // 1
Lai to izdarītu ar pagaidu objektu, varat nodot citu pagaidu objektu tā metodēm līdz vai kopš. Tas atgriež objektu Temporal.Duration, kas satur informāciju par laika starpību. Objektam Ilgums ir rekvizīti katram atšķirības komponentam, kā arī var ģenerēt ISO 8601 ilguma virkni, kas atspoguļo laika starpību.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largeUnit norāda lielāko attēlojamo laika vienību // ilguma aprēķinā const diff = datums2.no (datums1, { lielākā Vienība: 'diena' });
console.log(diff.days); // 1
konsole.log(diff.hours); // 1
konsole.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 ilguma virkne: 1 diena, 1 stunda, 30 minūtes)
Datumu un laiku salīdzināšana Gan Moment, gan Temporal ļauj salīdzināt datumus un laikus, lai noteiktu, kurš ir pirms otra, taču API izmanto dažādas pieejas. Moment nodrošina tādas metodes kā isBefore, isAfter un isSame, lai salīdzinātu divus Moment objektus. const date1 = moments('2026-02-21T09:00:00'); const date2 = moments('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // taisnība
Temporal izmanto statisku salīdzināšanas metodi, lai veiktu divu viena veida objektu salīdzināšanu. Tas atgriež -1, ja pirmais datums ir pirms otrā, 0, ja tie ir vienādi, vai 1, ja pirmais datums ir pēc otrā. Šis piemērs parāda, kā salīdzināt divus PlainDate objektus. Abiem Temporal.PlainDate.compare argumentiem ir jābūt PlainDate objektiem.
const date1 = Temporal.PlainDate.from({ gads: 2026, mēnesis: 2, diena: 24 }); const date2 = Temporal.PlainDate.from({ gads: 2026, mēnesis: 3, diena: 24 });
// datums1 ir pirms datuma2, tāpēc -1 console.log(Temporal.PlainDate.comare(datums1, date2));
// Kļūda, ja mēģinām salīdzināt divus dažāda veida objektus console.log(Temporal.PlainDate.compare(datums1, Temporal.Now.instant())); // TypeError: Temporal error: Nederīgi PlainDate lauki.
Tas jo īpaši atvieglo laika objektu masīva kārtošanu hronoloģiski. // Temporal.PlainDate objektu masīvs const datumi = [ ... ];
// izmantojiet Temporal.PlainDate.compare kā salīdzinājuma funkciju dates.sort(Temporal.PlainDate.salīdzināt);
Laika joslu konvertēšana Galvenā Moment bibliotēka neatbalsta laika joslu konvertēšanu. Ja jums ir nepieciešama šī funkcionalitāte, jums ir jāinstalē arī moment-timezone pakotne. Šo iepakojumu nevar satricināt, un tāpēc tas var ievērojami palielināt jūsu komplekta izmēru. Kad esat instalējis momenta laika joslu, varat pārveidot Moment objektus dažādās laika joslās, izmantojot tz metodi. Tāpat kā ar citām Moment operācijām, tas maina pamatā esošoobjektu. // Pieņemot ASV austrumu laiku const tagad = moments(); console.log(tagad); // Mirklis<2026-02-28T20:08:20-05:00>
// Konvertēt uz Klusā okeāna laiku. // Sākotnējais Austrumu laiks ir zaudēts. now.tz('Amerika/Losandžela'); console.log(tagad); // Mirklis<2026-02-28T17:08:20-08:00>
Laika joslas funkcionalitāte ir iebūvēta Temporal API, izmantojot objektu Temporal.ZonedDateTime. Šajos objektos ir ietverta metode withTimeZone, kas atgriež jaunu ZonedDateTime, kas attēlo to pašu laika brīdi, bet norādītajā laika joslā. // Atkal, pieņemot ASV austrumu laiku const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.2.2026., 20:12:02 EST
// Konvertēt uz Klusā okeāna laiku const nowPacific = now.withTimeZone('Amerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28.02.2026., 17:12:02 PST
// Sākotnējais objekts paliek nemainīgs console.log(now.toLocaleString()); // 28.2.2026., 20:12:02 EST
Piezīme. Formatētās vērtības, ko atgriež toLocaleString, ir, kā norāda nosaukums, ir atkarīgas no lokalizācijas. Koda paraugs tika izstrādāts ASV lokalizācijā, tāpēc formāts ir šāds: 28.02.2026., 17:12:02 PST. Citā vietā tas var atšķirties. Piemēram, en-GB lokalizācijā jūs iegūtu kaut ko līdzīgu 28/2/2026, 17:12:02 GMT-8. Reālas pasaules pārstrukturēšana Pieņemsim, ka mēs veidojam lietotni notikumu plānošanai laika joslās. Daļa no šīs lietotnes ir funkcija getEventTimes, kas izmanto ISO 8601 virkni, kas attēlo notikuma laiku un datumu, vietējo laika joslu un mērķa laika joslu. Funkcija izveido formatētas laika un datuma virknes notikumam abās laika joslās. Ja funkcijai tiek dota ievades virkne, kas nav derīga laika/datuma virkne, tiks parādīta kļūda. Lūk, sākotnējā ieviešana, izmantojot Moment (arī ir jāizmanto momenta laika joslas pakotne).
importēt brīdi no 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, GGGG, h:mm:ss a z';
// 1. Izveidojiet sākuma brīdi lietotāja laika joslā const notikuma laiks = moment.tz( ievades virkne, moment.ISO_8601, // Sagaidiet ISO 8601 virkni taisnība, // Stingra parsēšana userTimeZone );
// Izmetiet kļūdu, ja ievades virkne nenorādīja derīgu datumu if (!eventTime.isValid()) { throw new Error('Nederīga datuma/laika ievade'); }
// 2. Aprēķiniet mērķa laiku // KRITISKI: mums ir jāklonē, pretējā gadījumā "notikuma laiks" mainās uz visiem laikiem! const mērķa laiks = notikuma laiks.clone().tz(mērķa laika josla);
return { lokālais: eventTime.format(timeFormat), mērķis: targetTime.format(timeFormat), }; }
const grafiks = getEventTimes( “2026-03-05T15:00-05:00”, "Amerika/Ņujorka", "Eiropa/Londona", );
console.log(grafiks.local); // 2026. gada 5. marts, 15:00:00 EST
konsole.log(grafiks.mērķis); // 2026. gada 5. marts, 20:00:00 pēc GMT
Šajā piemērā mēs izmantojam paredzamo datuma formātu ISO 8601, kas ir lietderīgi iebūvēts Momentā. Mēs izmantojam arī stingru parsēšanu, kas nozīmē, ka Moment nemēģinās uzminēt, izmantojot datuma virkni, kas neatbilst formātam. Ja tiek nodota datuma virkne, kas nav ISO, tiks parādīts nederīgs datuma objekts, un mēs radīsim kļūdu. Īslaicīga ieviešana izskatās līdzīgi, taču tai ir dažas būtiskas atšķirības.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Parsējiet ievadi tieši dinamiskajā meklēšanā un pēc tam izveidojiet // ZonedDateTime lietotāja zonā. const instant = Temporal.Instant.from(inputString); const notikuma laiks = instant.toZonedDateTimeISO(lietotāja laika josla);
// 2. Konvertējiet uz mērķa zonu // Tas automātiski atgriež JAUNS objekts; "EventTime" ir drošs. const mērķaLaiks = notikuma laiks.arLaikaZona(mērķaLaikaZona);
// 3. Formatējiet, izmantojot Intl (iebūvēts) const opcijas = { gads: "ciparu", mēnesis: 'īss', diena: "ciparu", stunda: "ciparu", minūte: "2 cipari", otrais: "2 cipari", timeZoneName: 'īss' };
return { lokālais: eventTime.toLocaleString(navigator.language, opcijas), mērķis: targetTime.toLocaleString(navigator.language, opcijas) }; }
const grafiks = getEventTimes( “2026-03-05T15:00-05:00”, "Amerika/Ņujorka", "Eiropa/Londona", );
console.log(grafiks.local); // 2026. gada 5. marts, 15:00:00 EST
konsole.log(grafiks.mērķis); // 2026. gada 5. marts, 20:00:00 GMT
Izmantojot Moment, mums ir skaidri jānorāda formāta virkne iegūtajām datumu virknēm. Neatkarīgi no lietotāja atrašanās vietas vai lokalizācijas notikumu laiki vienmēr tiks formatēti kā 2026. gada 5. marts, plkst. 3:00:00.pm EST. Turklāt mums nav skaidri jāizsaka izņēmums. Ja vietnei Temporal.Instant.from tiek nodota nederīga virkne, Temporal mums piemēros izņēmumu. Viena lieta, kas jāņem vērā, ir tāda, ka pat ar stingru parsēšanu Moment versija joprojām ir saudzīgāka. Temporal prasa laika joslas nobīdi virknes beigās. Ņemiet vērā arī to, ka, tā kā mēs izmantojam navigator.language, šis kods darbosies tikai pārlūkprogrammas vidē, jo Navigators nav definēts Node.js vidē. Īslaicīgā ieviešana izmanto pārlūkprogrammas pašreizējo lokalizāciju (navigator.language), tāpēc lietotājs automātiski iegūs notikumu laikus, kas formatēti viņu vietējā laika formātā. ASV lokalizācijā tas ir 2026. gada 5. marts, 15:00:00 pēc austrumu laika. Tomēr, ja lietotājs atrodas, piemēram, Londonā, notikumu laiki tiks formatēti kā 2026. gada 5. marts, 15:00:00 GMT-5. Kopsavilkums
Darbība Moment.js Pagaidu Pašreizējais laiks brīdis () Temporal.Now.zonedDateTimeISO() ISO parsēšana moments (str) Temporal.Instant.from(str) Pievienojiet laiku .add(7, 'dienas') (mutācijas) .add({ dienas: 7 }) (jauns objekts) Atšķirība .diff(cits, 'stundas') .kopš(cits).stundas Laika josla .tz('Zona/nosaukums') .withTimeZone('Zona/nosaukums')
No pirmā acu uzmetiena atšķirība var būt nedaudz atšķirīga (un Temporal gadījumā dažreiz daudz detalizētāka un stingrāka), taču Temporal izmantošanai salīdzinājumā ar Moment.js ir vairākas galvenās priekšrocības:
Precīzāks saturs nozīmē mazāk pārsteigumu un neparedzētu kļūdu. Brīdis var šķist saudzīgāks, taču tas ietver "minējumus", kas dažkārt var izraisīt nepareizus datumus. Ja piešķirat Temporal kaut ko nederīgu, tas rada kļūdu. Ja kods darbojas, jūs zināt, ka jums ir derīgs datums. Moment var ievērojami palielināt lietojumprogrammas komplektu, it īpaši, ja izmantojat momenta laika joslas pakotni. Temporal neko nepievieno (kad tas ir nosūtīts jūsu mērķa pārlūkprogrammās). Nemainība sniedz jums pārliecību, ka, veicot datu pārveidošanu un darbības, jūs nekad nezaudēsit vai nepārrakstīsit datus. Dažādi laika attēlojumi (Instant, PlainDateTime, ZonedDateTime) atkarībā no jūsu prasībām, kur Moment vienmēr ir UTC laika zīmoga iesaiņojums. Temporal datuma formatēšanai izmanto Intl API, kas nozīmē, ka varat izmantot lokalizāciju zinošu formatējumu, nepārprotami nenorādot pilnvaras.
Piezīmes par Polyfill Kā minēts iepriekš, ir pieejams Temporal polyfill, kas tiek izplatīts kā npm pakotne ar nosaukumu @js-temporal/polyfill. Ja vēlaties izmantot Temporal šodien, jums būs nepieciešams šis polimērs, lai atbalstītu tādas pārlūkprogrammas kā Safari, kurām API vēl nav piegādāta. Sliktās ziņas ir tādas, ka tas palielinās jūsu komplekta izmēru. Labā ziņa ir tā, ka tā joprojām pievieno ievērojami mazāk nekā mirkļa vai brīža laika josla. Tālāk ir sniegts komplektu izmēru salīdzinājums, ko ziņoja Bundlephobia.com — vietne, kas sniedz informāciju par npm pakotņu izmēriem (noklikšķiniet uz katras pakotnes nosaukuma, lai skatītu Bundlephobia analīzi):
Iepakojums Samazināts Samazināta un gzipped @js-temporal/polyfill 154,1 kB 44,1 kB brīdis 294,4 kB 75,4 kB mirklis-laika josla 1 MB 114,2 kB
Aizpildījumam vēsturiski ir bijušas arī dažas veiktspējas problēmas saistībā ar atmiņas lietojumu, un rakstīšanas laikā tika uzskatīts, ka tas ir alfa stāvoklī. Šī iemesla dēļ jūs, iespējams, nevēlaties to izmantot ražošanā, kamēr tas nav sasniedzis nobriedušāku stāvokli. Vēl viena labā ziņa ir tā, ka, cerams, polifilis nebūs vajadzīgs daudz ilgāk (ja vien jums, protams, nav jāatbalsta vecākas pārlūkprogrammas). Rakstīšanas laikā Temporal tika piegādāts pārlūkprogrammās Chrome, Edge un Firefox. Tas vēl nav pilnībā gatavs pārlūkprogrammai Safari, lai gan šķiet, ka tas ir pieejams ar izpildlaika karogu jaunākajā tehnoloģiju priekšskatījumā.
