Mae bron unrhyw fath o gais a ysgrifennwyd yn JavaScript yn gweithio gydag amseroedd neu ddyddiadau i ryw raddau. Yn y dechrau, roedd hyn wedi'i gyfyngu i'r API Dyddiad adeiledig. Mae'r API hwn yn cynnwys ymarferoldeb sylfaenol, ond mae'n eithaf cyfyngedig o ran yr hyn y gall ei wneud. Mae llyfrgelloedd trydydd parti fel Moment.js, ac APIs adeiledig yn ddiweddarach fel yr APIs Intl a'r API Temporal newydd, yn ychwanegu llawer mwy o hyblygrwydd at weithio gydag amseroedd a dyddiadau. Cynnydd A Chwymp Moment.js Mae Moment.js yn llyfrgell JavaScript gyda chyfleustodau pwerus ar gyfer gweithio gydag amseroedd a dyddiadau. Mae'n cynnwys nodweddion coll o'r API Dyddiad sylfaenol, megis trin parth amser, ac mae'n gwneud llawer o weithrediadau cyffredin yn symlach. Mae moment hefyd yn cynnwys swyddogaethau ar gyfer fformatio dyddiadau ac amseroedd. Daeth yn llyfrgell a ddefnyddir yn eang mewn llawer o wahanol gymwysiadau. Fodd bynnag, roedd gan Moment ei siâr o faterion hefyd. Mae'n llyfrgell fawr, a gall ychwanegu'n sylweddol at faint bwndel cais. Gan nad yw'r llyfrgell yn cefnogi ysgwyd coed (nodwedd o fwndeli modern a all gael gwared ar rannau nas defnyddir o lyfrgelloedd), mae'r llyfrgell Moment gyfan wedi'i chynnwys hyd yn oed os mai dim ond un neu ddau o'i swyddogaethau rydych chi'n eu defnyddio. Mater arall gyda Moment yw'r ffaith bod y gwrthrychau y mae'n eu creu yn fudadwy. Mae galw swyddogaethau penodol ar wrthrych Moment yn cael sgîl-effeithiau ac yn treiglo gwerth y gwrthrych hwnnw. Gall hyn arwain at ymddygiad annisgwyl neu fygiau. Yn 2020, penderfynodd cynhalwyr Moment roi'r llyfrgell yn y modd cynnal a chadw. Nid oes unrhyw ddatblygiad nodwedd newydd yn cael ei wneud, ac mae'r cynhalwyr yn argymell peidio â'i ddefnyddio ar gyfer prosiectau newydd. Mae yna lyfrgelloedd dyddiad JavaScript eraill, fel date-fns, ond mae chwaraewr newydd yn y dref, API sydd wedi'i ymgorffori'n uniongyrchol yn JavaScript: Temporal. Mae'n safon newydd sy'n llenwi tyllau'r API Dyddiad gwreiddiol yn ogystal â datrys rhai o'r cyfyngiadau a geir yn Moment a llyfrgelloedd eraill. Beth Yw Amserol? Mae Temporal yn API amser a dyddiad newydd sy'n cael ei ychwanegu at safon ECMAScript, sy'n diffinio JavaScript modern. O fis Mawrth 20266, mae wedi cyrraedd Cam 4 o’r broses TC39 (y pwyllgor sy’n goruchwylio cynigion ac ychwanegiadau i’r iaith JavaScript), a bydd yn cael ei gynnwys yn fersiwn nesaf y fanyleb ECMAScript. Mae eisoes wedi'i weithredu mewn sawl porwr: Chrome 144+ a Firefox 139+, a disgwylir i Safari ddilyn yn fuan. Mae polyfill hefyd ar gael ar gyfer porwyr nad ydynt yn cael eu cynnal a Node.js. Mae'r API Temporal yn creu gwrthrychau sydd, yn gyffredinol, yn cynrychioli eiliadau mewn amser. Gall y rhain fod yn stampiau amser llawn a dyddiad mewn parth amser penodol, neu gallant fod yn enghraifft generig o amser “cloc wal” heb unrhyw wybodaeth parth amser na dyddiad. Mae rhai o brif nodweddion Temporal yn cynnwys:
Amseroedd gyda dyddiadau neu hebddynt. Gall gwrthrych dros dro gynrychioli amser penodol ar ddyddiad penodol, neu amser heb unrhyw wybodaeth dyddiad. Gellir cynrychioli dyddiad penodol, heb amser, hefyd. Parth amser gwrthrychau support.Temporal yn gwbl ymwybodol parth amser a gellir eu trosi ar draws parthau amser gwahanol. Mae moment yn cefnogi parthau amser hefyd, ond mae angen y llyfrgell parth amser eiliad ychwanegol. Immutability.Once gwrthrych Temporal yn cael ei greu, ni ellir ei newid. Nid yw trawsnewidiadau rhifyddeg amser neu gylchfa amser yn addasu'r gwrthrych gwaelodol. Yn lle hynny, maent yn cynhyrchu gwrthrych Amserol newydd. Mynegeio 1-seiliedig.Ffynhonnell gyffredin o fygiau gyda'r API Dyddiad (yn ogystal â Moment) yw bod misoedd wedi'u mynegeio sero. Mae hyn yn golygu mai mis Ionawr yw mis 0, yn hytrach na mis 1 fel y deallwn i gyd mewn bywyd go iawn. Mae dros dro yn trwsio hyn trwy ddefnyddio mynegeio ar sail 1 - Ionawr yw mis 1. Mae wedi'i ymgorffori yn y porwr. Gan fod Temporal yn API yn y porwr ei hun, nid yw'n ychwanegu dim at faint bwndel eich cais.
Mae hefyd yn bwysig nodi nad yw'r API Dyddiad yn diflannu. Tra bod Temporal yn disodli'r API hwn, nid yw'n cael ei ddileu na'i ddiystyru. Byddai llawer o gymwysiadau yn torri pe bai porwyr yn tynnu'r API Dyddiad yn sydyn. Fodd bynnag, cofiwch hefyd fod Moment bellach yn cael ei ystyried yn brosiect etifeddiaeth yn y modd cynnal a chadw. Yng ngweddill yr erthygl, byddwn yn edrych ar rai “ryseitiau” ar gyfer mudo cod ar sail Moment i'r API Temporal newydd. Gadewch i ni ddechrau ailffactorio! Creu Gwrthrychau Dyddiad Ac Amser Cyn i ni allu trin dyddiadau ac amseroedd, mae'n rhaid i ni greu gwrthrychau sy'n eu cynrychioli. I greu gwrthrych Moment sy'n cynrychioli'r dyddiad a'r amser cyfredol, defnyddiwch y ffwythiant moment. const nawr = moment(); consol.log(nawr); // Munud<2026-02-18T21:26:29-05:00>
Bellach gellir fformatio neu drin y gwrthrych hwn yn ôl yr angen.
// trosi i UTC //rhybudd: Mae hyn yn treiglo'r gwrthrych Moment ac yn ei roi yn y modd UTC! consol.log(now.utc()); // Munud<2026-02-19T02:26:29Z>
// print a formated string - noder ei fod yn defnyddio'r amser UTC nawr consol.log(now.format('MM/DD/BBBB hh:mm:ss a')); // 02/19/2026 02:27:07 yb
Y peth allweddol i'w gofio am Moment yw bod gwrthrych Moment bob amser yn cynnwys gwybodaeth am yr amser a'r dyddiad. Os mai dim ond gyda gwybodaeth amser y mae angen i chi weithio, mae hyn fel arfer yn iawn, ond gall achosi ymddygiad annisgwyl mewn sefyllfaoedd fel Amser Arbed Golau Dydd neu flynyddoedd naid, lle gall y dyddiad gael effaith ar gyfrifiadau amser. Mae dros dro yn fwy hyblyg. Gallwch greu gwrthrych sy'n cynrychioli'r dyddiad a'r amser cyfredol trwy greu gwrthrych Temporal.Instant. Mae hyn yn cynrychioli pwynt mewn amser a ddiffinnir gan yr amser ers “yr epoc” (canol nos UTC ar Ionawr 1, 1970). Gall Temporal gyfeirio at yr amrantiad hwn mewn amser gyda thrachywiredd lefel nanosecond. const now = Temporal.Now.instant();
// gweler nanoseconds amrwd ers yr epoc consol.log(now.epochNanoseconds); // 1771466342612000000n
// fformat ar gyfer UTC consol.log(now.toString()); // 2026-02-19T01:55:27.844Z
// fformat ar gyfer parth amser penodol consol.log(now.toString({ timeZone: 'America/New_York'})); // 2026-02-18T20:56:57.905-05:00
Gall gwrthrychau Temporal.Instant hefyd gael eu creu ar gyfer amser a dyddiad penodol trwy ddefnyddio'r dull o statig.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Fformatiwch yr amrantiad yn y parth amser lleol. Sylwch mai dim ond rheolaethau y mae hyn // y fformatio - nid yw'n treiglo'r gwrthrych fel y mae moment.utc yn ei wneud. consol.log(myInstant.toString({ timeZone: 'America/New_York'})); // 2026-02-18T21:10:00-05:00
Gallwch hefyd greu mathau eraill o wrthrychau Amserol, gan gynnwys:
Temporal.PlainDate: Dyddiad heb unrhyw wybodaeth amser. Temporal.PlainTime: Amser heb unrhyw wybodaeth dyddiad. Temporal.ZonedDateTime: Dyddiad ac amser mewn parth amser penodol.
Mae gan bob un o'r rhain ddull o y gellir ei alw gyda gwrthrych sy'n nodi'r dyddiad a/neu'r amser, neu linyn dyddiad i'w ddosrannu. // Dim ond dyddiad const heddiw = Temporal.PlainDate.from({ blwyddyn: 2026, mis: 2, // nodyn rydym yn defnyddio 2 ar gyfer Chwefror dydd: 18 }); consol.log(today.toString()); // 2026-02-18
// Dim ond amser const lunchTime = Temporal.PlainTime.from({ awr: 12 }); consol.log(LingTime.toString()); // 12:00:00
// Dyddiad ac amser ym mharth amser dwyreiniol yr UD const dueAt = Temporal.ZonedDateTime.from({ Parth Amser: 'America/New_York', blwyddyn: 2026, mis: 3, diwrnod: 1, awr: 12, munud: 0, ail: 0 }); consol.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Dosrannu Rydym wedi ymdrin â chreu rhaglen o wybodaeth dyddiad ac amser. Nawr, gadewch i ni edrych ar ddosrannu. Mae dosrannu yn un maes lle mae Moment yn fwy hyblyg na'r API Temporal adeiledig. Gallwch ddosrannu llinyn dyddiad trwy ei drosglwyddo i'r swyddogaeth moment. Gydag un ddadl, mae Moment yn disgwyl llinyn dyddiad ISO, ond gallwch ddefnyddio fformatau amgen os byddwch yn darparu ail ddadl yn nodi'r fformat dyddiad a ddefnyddir.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
consol.log(isoDate); // Munud<2026-02-21T09:00:00-05:00>
consol.log(formattedDate); // Munud<2026-02-21T09:00:00-05:00>
Mewn fersiynau hŷn, byddai Moment yn ddyfaliad gorau i ddosrannu unrhyw linyn dyddiad sydd wedi'i fformatio'n fympwyol. Gallai hyn arwain at ganlyniadau anrhagweladwy. Er enghraifft, ai 02-03-2026 yw 2 Chwefror neu 3 Mawrth? Am y rheswm hwn, mae fersiynau mwy newydd o Moment yn dangos rhybudd dibrisiad amlwg os caiff ei alw heb linyn dyddiad fformat ISO (oni bai bod yr ail ddadl gyda'r fformat a ddymunir hefyd yn cael ei rhoi). Bydd Temporal ond yn dosrannu llinyn dyddiad wedi'i fformatio'n benodol. Rhaid i'r llinyn gydymffurfio â fformat ISO 8601 neu ei estyniad, RFC 9557. Os caiff llinyn dyddiad nad yw'n cydymffurfio ei drosglwyddo i ddull o, bydd Temporal yn taflu RangeError.
// Gan ddefnyddio llinyn dyddiad RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); consol.log(myDate.toString({ timeZone: 'America/New_York'})); // 2026-02-21T09:00:00-05:00
// Gan ddefnyddio llinyn dyddiad anhysbys const otherDate = Temporal.Instant.from( '2/21/26 9:00:00'); // RangeError: Gwall amser: Nod annilys wrth ddosrannu gwerth blwyddyn.
Mae union ofynion y llinyn dyddiad yn dibynnu ar ba fath o wrthrych Temporal rydych chi'n ei greu. Yn yr enghraifft uchod, mae angen ISO llawn ar Temporal.InstantLlinyn dyddiad 8601 neu RFC 9557 yn nodi'r dyddiad a'r amser gyda gwrthbwyso parth amser, ond gallwch hefyd greu gwrthrychau PlainDate neu PlainTime gan ddefnyddio dim ond is-set o'r fformat dyddiad. const myDate = Temporal.PlainDate.from('2026-02-21'); consol.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00); consol.log(myTime.toString()); // 09:00:00
Sylwch fod yn rhaid i'r llinynnau hyn barhau i gydymffurfio â'r fformat disgwyliedig, neu bydd gwall yn cael ei daflu.
// Defnyddio llinynnau amser nad ydynt yn cydymffurfio. Bydd y rhain i gyd yn taflu RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Awgrym da: Ymdrin â llinynnau nad ydynt yn ISO Oherwydd bod Temporal yn blaenoriaethu dibynadwyedd, ni fydd yn ceisio dyfalu fformat llinyn fel 02-01-2026. Os yw'ch ffynhonnell ddata yn defnyddio llinynnau o'r fath, bydd angen i chi wneud rhywfaint o drin llinynnau i aildrefnu'r gwerthoedd yn llinyn ISO fel 2026-02-01 cyn ceisio ei ddefnyddio gyda Temporal.
Fformatio Unwaith y bydd gennych wrthrych Moment neu Temporal, mae'n debyg y byddwch am ei drosi i linyn wedi'i fformatio ar ryw adeg. Mae hwn yn enghraifft lle mae Moment ychydig yn fwy braw. Rydych chi'n galw dull fformat y gwrthrych gyda chyfres o docynnau sy'n disgrifio'r fformat dyddiad dymunol. const date = moment();
consol.log(date.format('MM/DD/BBBB')); // 02/22/2026
consol.log(date.format('MMMM Gwnewch BBBB, h:mm:ss a')); // Chwefror 22, 2026, 8:18:30 y.h
Ar y llaw arall, mae Temporal yn gofyn i chi fod ychydig yn fwy gair. Mae gan wrthrychau dros dro, megis Instant, ddull toLocaleString sy'n derbyn opsiynau fformatio amrywiol a nodir fel priodweddau gwrthrych.
dyddiad const = Temporal.Now.instant();
// heb unrhyw ddadleuon, byddwn yn cael y fformat rhagosodedig ar gyfer y locale presennol consol.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (gan dybio locale o en-US)
// pasio opsiynau fformatio i gynhyrchu llinyn fformat arferiad consol.log(date.toLocaleString('en-US', { mis: 'hir', diwrnod: 'numeric', blwyddyn: 'rhifol', awr: '2-digid', munud: '2-digid' })); // Chwefror 22, 2026 am 8:23 PM
// dim ond pasio'r meysydd rydych chi eu heisiau yn y llinyn fformat consol.log(date.toLocaleString('en-US', { mis: 'byr', diwrnod: 'numeric' })); // Chwe 22
Mae fformatio dyddiad dros dro mewn gwirionedd yn defnyddio'r API Intl.DateTimeFormat (sydd eisoes ar gael yn rhwydd mewn porwyr modern) o dan y cwfl. Mae hynny'n golygu y gallwch chi greu gwrthrych DateTimeFormat y gellir ei ailddefnyddio gyda'ch opsiynau fformatio arferol, yna pasio gwrthrychau Temporal i'w ddull fformat. Oherwydd hyn, nid yw'n cefnogi fformatau dyddiad arferol fel y mae Moment yn ei wneud. Os oes angen rhywbeth fel 'Q1 2026' neu fformatio arbenigol arall arnoch, efallai y bydd angen cod fformatio dyddiad wedi'i deilwra arnoch chi neu gyrhaeddiad ar gyfer llyfrgell trydydd parti. const formatter = Intl.DateTimeFormat newydd('en-US', { mis: '2-digid', diwrnod: '2-digid', blwyddyn: 'rhifol' });
dyddiad const = Temporal.Now.instant(); consol.log(formatter.format(date)); // 02/22/2026
Mae tocynnau fformatio Moment yn symlach i'w hysgrifennu, ond nid ydynt yn gyfeillgar i'r ardal leol. Mae'r fformat yn llinynnau “cod caled” pethau fel trefn mis / dydd. Mantais defnyddio gwrthrych cyfluniad, fel Temporal, yw y bydd yn addasu'n awtomatig i unrhyw leoliad penodol ac yn defnyddio'r fformat cywir. dyddiad const = Temporal.Now.instant();
const formatOptions = { mis: 'rhifol', diwrnod: 'numeric', blwyddyn: 'rhifol' };
consol.log(date.toLocaleString('en-US', formatOptions)); // 2/22/2026
consol.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Cyfrifiadau dyddiad Mewn llawer o gymwysiadau, bydd angen i chi wneud rhai cyfrifiadau ar ddyddiad. Efallai y byddwch am adio neu dynnu unedau amser (diwrnodau, oriau, eiliadau, ac ati). Er enghraifft, os oes gennych y dyddiad cyfredol, efallai y byddwch am ddangos y dyddiad 1 wythnos o nawr i'r defnyddiwr. Mae gan wrthrychau moment ddulliau megis adio a thynnu sy'n cyflawni'r gweithrediadau hyn. Mae'r swyddogaethau hyn yn cymryd gwerth ac uned, er enghraifft: ychwanegu(7, 'diwrnod'). Un gwahaniaeth pwysig iawn rhwng Moment ac Amserol, fodd bynnag, yw bod y gwrthrych gwaelodol yn cael ei addasu wrth wneud y cyfrifiadau dyddiad hyn a cholli ei werth gwreiddiol. const nawr = moment();
consol.log(nawr); // Munud<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); consol.log(Wythnos nesaf); // Munud<2026-03-03T20:08:36-05:00>
// Gotcha - treiglwyd y gwrthrych gwreiddiol consol.log(nawr); // Munud<2026-03-03T20:08:36-05:00>
Er mwyn osgoi colli'r dyddiad gwreiddiol, gallwch ffonio clonio ar y gwrthrych Moment i greu copi. const nawr= moment(); const nextWeek = now.clone().add(7, 'days');
consol.log(nawr); // Munud<2026-02-24T20:12:55-05:00>
consol.log(Wythnos nesaf); // Munud<2026-03-03T20:12:55-05:00>
Ar y llaw arall, mae gwrthrychau Tymhorol yn ddigyfnewid. Unwaith y byddwch wedi creu gwrthrych fel Instant, PlainDate, ac yn y blaen, ni fydd gwerth y gwrthrych hwnnw byth yn newid. Mae gan wrthrychau dros dro ddulliau adio a thynnu hefyd. Mae dros dro ychydig yn bigog ynghylch pa unedau amser y gellir eu hychwanegu at ba fathau o wrthrychau. Er enghraifft, ni allwch ychwanegu dyddiau at Instant:
const now = Temporal.Now.instant(); const nextWeek = now.add({ diwrnod: 7 }); // RangeError: Gwall amser: Ni all yr uned fwyaf fod yn uned ddyddiad
Mae hyn oherwydd bod gwrthrychau Instant yn cynrychioli pwynt amser penodol yn UTC ac yn agnostig calendr. Oherwydd y gall hyd diwrnod newid yn seiliedig ar reolau parth amser fel Amser Arbed Golau Dydd, nid yw'r cyfrifiad hwn ar gael ar Instant. Fodd bynnag, gallwch chi gyflawni'r llawdriniaeth hon ar fathau eraill o wrthrychau, fel PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); consol.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({ diwrnod: 7 });
// Sylwch nad yw'r PlainDateTime gwreiddiol wedi newid consol.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
consol.log(Wythnos nesaf.toLocaleString()); // 3/3/2026, 8:23:59 PM
Gallwch hefyd gyfrifo faint o amser sydd rhwng dau wrthrych Moment neu Dros Dro. Gyda swyddogaeth diff Moment, mae angen i chi ddarparu uned ar gyfer ronynnedd, fel arall bydd yn dychwelyd y gwahaniaeth mewn milieiliadau. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
consol.log(date2.diff(date1)); // 91800000
consol.log(date2.diff(date1, 'days')); // 1
I wneud hyn gyda gwrthrych Temporal, gallwch chi basio gwrthrych Temporal arall i'w ddulliau tan neu ers hynny. Mae hwn yn dychwelyd gwrthrych Temporal.Duration sy'n cynnwys gwybodaeth am y gwahaniaeth amser. Mae gan y gwrthrych Hyd briodweddau ar gyfer pob cydran o'r gwahaniaeth, a gall hefyd gynhyrchu llinyn hyd ISO 8601 sy'n cynrychioli'r gwahaniaeth amser.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
//mostUnit yn pennu'r uned amser fwyaf i'w chynrychioli // yn y cyfrifiad hyd const diff = date2.since(date1, { largestUnit: 'day' });
consol.log(diff.days); // 1
consol.log(diff.hours); // 1
consol.log(diff.minutes); // 30
consol.log(diff.toString()); // P1DT1H30M // (Llinyn hyd ISO 8601: 1 diwrnod, 1 awr, 30 munud)
Cymharu Dyddiadau Ac Amserau Mae Moment a Temporal ill dau yn gadael i chi gymharu dyddiadau ac amseroedd i benderfynu pa un sy'n dod cyn y llall, ond cymryd ymagweddau gwahanol gyda'r API. Mae Moment yn darparu dulliau fel isBefore, isAfter, ac isSame i gymharu dau wrthrych Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
consol.log(date1.isBefore(date2)); // wir
Mae Tempor yn defnyddio dull cymharu statig i berfformio cymhariaeth rhwng dau wrthrych o'r un math. Mae'n dychwelyd -1 os daw'r dyddiad cyntaf cyn yr ail, 0 os yw'n hafal, neu 1 os daw'r dyddiad cyntaf ar ôl yr ail. Mae'r enghraifft ganlynol yn dangos sut i gymharu dau wrthrych PlainDate. Rhaid i'r ddwy ddadl i Temporal.PlainDate.compare fod yn wrthrychau PlainDate.
const date1 = Temporal.PlainDate.from({ blwyddyn: 2026, mis: 2, diwrnod: 24 }); const date2 = Temporal.PlainDate.from({ blwyddyn: 2026, mis: 3, diwrnod: 24 });
// dyddiad1 yn dod cyn dyddiad2, felly -1 consol.log(Temporal.PlainDate.compare(dyddiad1, dyddiad2));
// Gwall os ceisiwn gymharu dau wrthrych o wahanol fathau consol.log(Temporal.PlainDate.compare(dyddiad1, Temporal.Now.instant())); // TypeError: Temporal error: Darparwyd meysydd PlainDate annilys.
Yn benodol, mae hyn yn ei gwneud hi'n hawdd didoli amrywiaeth o wrthrychau Amserol yn gronolegol. // Amrywiaeth o wrthrychau Temporal.PlainDate dyddiadau const = [ ... ];
// defnyddio Temporal.PlainDate.compare fel y swyddogaeth cymharydd dyddiadau.sort(Temporal.PlainDate.compare);
Trosiadau Parth Amser Nid yw'r llyfrgell Moment graidd yn cefnogi trawsnewidiadau parth amser. Os oes angen y swyddogaeth hon arnoch, mae angen i chi hefyd osod y pecyn moment-timezone. Nid yw'r pecyn hwn yn gallu ysgwyd coed, ac felly gall ychwanegu'n sylweddol at faint eich bwndel. Unwaith y byddwch wedi gosod moment-timezone, gallwch drosi gwrthrychau Moment i wahanol barthau amser gyda'r dull tz. Fel gyda gweithrediadau Moment eraill, mae hyn yn treiglo'r gwaelodolgwrthrych. // Gan dybio amser Dwyrain yr Unol Daleithiau const nawr = moment(); consol.log(nawr); // Munud<2026-02-28T20:08:20-05:00>
// Trosi i amser Pacific. // Mae amser gwreiddiol y Dwyrain yn cael ei golli. now.tz('America/Los_Angeles'); consol.log(nawr); // Munud<2026-02-28T17:08:20-08:00>
Mae ymarferoldeb parth amser wedi'i ymgorffori yn yr API Temporal wrth ddefnyddio gwrthrych Temporal.ZonedDateTime. Mae'r gwrthrychau hyn yn cynnwys dull withTimeZone sy'n dychwelyd ZonedDateTime newydd sy'n cynrychioli'r un foment mewn amser, ond yn y parth amser penodedig. // Eto, gan dybio amser Dwyrain yr Unol Daleithiau const now = Temporal.Now.zonedDateTimeISO(); consol.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// Trosi i amser Pacific const nowPacific = now.withTimeZone('America/Los_Angeles'); consol.log(now Pacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// Gwrthrych gwreiddiol yn aros heb ei newid consol.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
Nodyn: Mae'r gwerthoedd wedi'u fformatio a ddychwelwyd gan toLocaleString, fel y mae'r enw'n awgrymu, yn ddibynnol ar locale. Datblygwyd y cod sampl yn y locale en-US, felly mae'r fformat fel hyn: 2/28/2026, 5:12:02 PM PST. Mewn locale arall, gall hyn fod yn wahanol. Er enghraifft, yn y locale en-GB, byddech chi'n cael rhywbeth fel 28/2/2026, 17:12:02 GMT-8. A Refactoring Byd Go iawn Tybiwch ein bod yn adeiladu ap ar gyfer amserlennu digwyddiadau ar draws parthau amser. Rhan o'r app hwn yw swyddogaeth, getEventTimes, sy'n cymryd llinyn ISO 8601 sy'n cynrychioli amser a dyddiad y digwyddiad, parth amser lleol, a pharth amser targed. Mae'r swyddogaeth yn creu llinynnau amser a dyddiad wedi'u fformatio ar gyfer y digwyddiad yn y ddau barth amser. Os rhoddir llinyn mewnbwn i'r swyddogaeth nad yw'n llinyn amser/dyddiad dilys, bydd yn taflu gwall. Dyma'r gweithrediad gwreiddiol, gan ddefnyddio Moment (hefyd yn gofyn am ddefnyddio'r pecyn moment-timezone).
mewnforio moment o 'moment-timezone';
swyddogaeth getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, BBBB, h:mm:ss a z';
// 1. Creu'r foment gychwynnol ym mharth amser y defnyddiwr const eventTime = moment.tz( llinyn mewnbwn, moment.ISO_8601, // Disgwyliwch llinyn ISO 8601 gwir, // Strict parsing userTimeZone );
// Taflwch gwall os nad oedd y mewnbwnString yn cynrychioli dyddiad dilys os (!eventTime.isValid()) { taflu Gwall newydd ('Mewnbwn dyddiad/amser annilys'); }
// 2. Cyfrifwch yr amser targed // CRITIGOL: Rhaid clonio, neu mae 'digwyddiadTime' yn newid am byth! const targetTime = eventTime.clone().tz(targetTimeZone);
dychwelyd { lleol: eventTime.format(timeFormat), targed: targetTime.format(timeFormat), }; }
amserlen const = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_Efrog', 'Ewrop/Llundain', );
consol.log(schedule.local); // Mawrth 5, 2026, 3:00:00 pm EST
consol.log(schedule.target); // Mawrth 5, 2026, 8:00:00 pm GMT
Yn yr enghraifft hon, rydym yn defnyddio fformat dyddiad disgwyliedig o ISO 8601, sydd wedi'i ymgorffori'n ddefnyddiol yn Moment. Rydym hefyd yn defnyddio dosrannu llym, sy'n golygu na fydd Moment yn ceisio dyfalu gyda llinyn dyddiad nad yw'n cyd-fynd â'r fformat. Os caiff llinyn dyddiad nad yw'n ISO ei basio, bydd yn arwain at wrthrych dyddiad annilys, a byddwn yn taflu gwall. Mae'r gweithrediad Dros Dro yn edrych yn debyg, ond mae ganddo ychydig o wahaniaethau allweddol.
swyddogaeth getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Dosrannu'r mewnbwn yn syth i mewn i Instant, yna creu // a ZonedDateTime ym mharth y defnyddiwr. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Trosi i'r parth targed // Mae hyn yn dychwelyd gwrthrych NEWYDD yn awtomatig; mae 'EventTime' yn ddiogel. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Fformat gan ddefnyddio Intl (adeiledig) opsiynau const = { blwyddyn: 'rhifol', mis: 'byr', diwrnod: 'numeric', awr: 'numeric', munud: '2-digid', ail: '2-digid', Enw Parth Amser: 'byr' };
dychwelyd { lleol: eventTime.toLocaleString(navigator.language, opsiynau), targed: targetTime.toLocaleString(llywiwr.iaith, opsiynau) }; }
amserlen const = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_Efrog', 'Ewrop/Llundain', );
consol.log(schedule.local); // Mawrth 5, 2026, 3:00:00 PM EST
consol.log(schedule.target); // Mawrth 5, 2026, 8:00:00 PM GMT
Gyda Moment, mae'n rhaid i ni nodi'n benodol llinyn fformat ar gyfer y llinynnau dyddiad canlyniadol. Waeth beth fo lleoliad neu leoliad y defnyddiwr, bydd amseroedd y digwyddiad bob amser yn cael eu fformatio fel 5 Mawrth, 2026, 3:00:00pm EST. Hefyd, nid oes yn rhaid i ni daflu eithriad yn benodol. Os trosglwyddir llinyn annilys i Temporal.Instant.from, bydd Temporal yn taflu'r eithriad i ni. Un peth i'w nodi yw hyd yn oed gyda dosrannu llym, mae'r fersiwn Moment yn dal yn fwy trugarog. Dros dro mae angen gwrthbwyso'r parth amser ar ddiwedd y llinyn. Dylech hefyd nodi, gan ein bod yn defnyddio navigator.language, mai dim ond mewn amgylchedd porwr y bydd y cod hwn yn rhedeg, gan nad yw llywiwr wedi'i ddiffinio mewn amgylchedd Node.js. Mae gweithrediad Temporal yn defnyddio locale cyfredol y porwr (navigator.language), felly bydd y defnyddiwr yn cael amseroedd digwyddiadau wedi'u fformatio yn eu fformat amser lleol yn awtomatig. Yn y locale en-UDA, dyma 5 Mawrth, 2026, 3:00:00 pm EST. Fodd bynnag, os yw'r defnyddiwr yn Llundain, er enghraifft, bydd amseroedd y digwyddiad yn cael eu fformatio fel 5 Mawrth 2026, 15:00:00 GMT-5. Crynodeb
Gweithred Moment.js Tymhorol Amser presennol eiliad () Temporal.Now.zonedDateTimeISO() Dosrannu ISO moment(str) Temporal.Instant.from(str) Ychwanegu amser .add(7, 'diwrnod') (yn treiglo) .add({ diwrnod: 7 }) (gwrthrych newydd) Gwahaniaeth .diff(arall, 'oriau') .ers (eraill).oriau Cylchfa amser .tz('Parth/Enw') .withTimeZone('Parth/Enw')
Ar yr olwg gyntaf, gall y gwahaniaeth fod ychydig yn wahanol (ac yn achos cystrawen Temporal, weithiau'n fwy llafar ac yn fwy llym), ond mae sawl mantais allweddol i ddefnyddio Temporal over Moment.js:
Mae bod yn fwy eglur yn golygu llai o bethau annisgwyl a bygiau anfwriadol. Efallai y bydd eiliad yn ymddangos yn fwy trugarog, ond mae'n golygu “dyfalu,” a all weithiau arwain at ddyddiadau anghywir. Os byddwch yn rhoi rhywbeth annilys Temporal, mae'n taflu gwall. Os yw'r cod yn rhedeg, rydych chi'n gwybod bod gennych chi ddyddiad dilys. Gall eiliad ychwanegu maint sylweddol at fwndel y rhaglen, yn enwedig os ydych chi'n defnyddio'r pecyn cylchfa amser moment. Nid yw Temporal yn ychwanegu dim (ar ôl iddo gael ei gludo i'ch porwyr targed). Mae immutability yn rhoi'r hyder i chi na fyddwch byth yn colli nac yn trosysgrifo data wrth gyflawni trawsnewidiadau dyddiad a gweithrediadau. Cynrychioliadau gwahanol o amser (Instant, PlainDateTime, ZonedDateTime) yn dibynnu ar eich gofynion, lle mae Moment bob amser yn ddeunydd lapio o amgylch stamp amser UTC. Mae Temporal yn defnyddio'r APIs Intl ar gyfer fformatio dyddiad, sy'n golygu y gallwch gael fformatio sy'n ymwybodol o locale heb orfod nodi tocynnau yn benodol.
Nodiadau Ar Y Polyfill Fel y soniwyd yn gynharach, mae polyfill dros dro ar gael, wedi'i ddosbarthu fel pecyn npm o'r enw @js-temporal/polyfill. Os ydych chi am ddefnyddio Temporal heddiw, bydd angen y polyfill hwn arnoch i gefnogi porwyr fel Safari nad ydyn nhw wedi anfon yr API eto. Y newyddion drwg gyda hyn yw y bydd yn ychwanegu at faint eich bwndel. Y newyddion da yw ei fod yn dal i ychwanegu cryn dipyn yn llai na pharth amser moment neu moment. Dyma gymhariaeth o'r meintiau bwndel fel yr adroddwyd gan Bundlephobia.com, gwefan sy'n cyflwyno gwybodaeth am feintiau pecyn npm (cliciwch ar enw pob pecyn i weld y dadansoddiad Bundlephobia):
Pecyn Miniog Wedi'i leihau a gzipped @js-temporal/polyfill 154.1 kB 44.1 kB moment 294.4 kB 75.4 kB moment-timezone 1 MB 114.2 kB
Yn hanesyddol, mae'r polyfill hefyd wedi cael rhai problemau perfformiad yn ymwneud â defnydd cof, ac ar adeg ysgrifennu, ystyrir ei fod mewn cyflwr alffa. Oherwydd hyn, efallai na fyddwch am ei ddefnyddio wrth gynhyrchu nes iddo gyrraedd cyflwr mwy aeddfed. Y newyddion da arall yw, gobeithio na fydd angen y polyfill llawer hirach (oni bai bod angen i chi gefnogi porwyr hŷn, wrth gwrs). Ar adeg ysgrifennu, mae Temporal wedi anfon yn Chrome, Edge, a Firefox. Nid yw'n hollol barod yn Safari eto, er ei bod yn ymddangos ei fod ar gael gyda baner amser rhedeg ar y Rhagolwg Technoleg diweddaraf.
