Nesten alle typer applikasjoner skrevet i JavaScript fungerer med tider eller datoer i en eller annen kapasitet. I begynnelsen var dette begrenset til den innebygde Date API. Denne API-en inkluderer grunnleggende funksjonalitet, men er ganske begrenset i hva den kan gjøre. Tredjepartsbiblioteker som Moment.js, og senere innebygde APIer som Intl APIer og den nye Temporal API, gir mye større fleksibilitet til å jobbe med tider og datoer. The Rise And Fall Of Moment.js Moment.js er et JavaScript-bibliotek med kraftige verktøy for å jobbe med tider og datoer. Det inkluderer manglende funksjoner fra det grunnleggende Date API, for eksempel tidssonemanipulasjon, og gjør mange vanlige operasjoner enklere. Moment inkluderer også funksjoner for formatering av datoer og klokkeslett. Det ble et mye brukt bibliotek i mange forskjellige applikasjoner. Moment hadde imidlertid også sin del av problemer. Det er et stort bibliotek, og kan øke en applikasjons pakkestørrelse betydelig. Fordi biblioteket ikke støtter treristing (en funksjon i moderne buntere som kan fjerne ubrukte deler av biblioteker), er hele Moment-biblioteket inkludert selv om du bare bruker én eller to av funksjonene. Et annet problem med Moment er det faktum at objektene den skaper er mutbare. Å kalle visse funksjoner på et Moment-objekt har bivirkninger og muterer verdien til det objektet. Dette kan føre til uventet oppførsel eller feil. I 2020 bestemte vedlikeholderne av Moment seg for å sette biblioteket i vedlikeholdsmodus. Ingen ny funksjonsutvikling blir gjort, og vedlikeholderne anbefaler å ikke bruke den til nye prosjekter. Det finnes andre JavaScript-datobiblioteker, for eksempel date-fns, men det er en ny aktør i byen, en API innebygd direkte i JavaScript: Temporal. Det er en ny standard som fyller ut hullene i den originale Date API, samt løser noen av begrensningene som finnes i Moment og andre biblioteker. Hva er tidsmessig? Temporal er et nytt tids- og dato-API som legges til ECMAScript-standarden, som definerer moderne JavaScript. Fra mars 20266 har den nådd trinn 4 av TC39-prosessen (komiteen som fører tilsyn med forslag og tillegg til JavaScript-språket), og vil bli inkludert i neste versjon av ECMAScript-spesifikasjonen. Den har allerede blitt implementert i flere nettlesere: Chrome 144+ og Firefox 139+, med Safari som forventes å følge snart. En polyfill er også tilgjengelig for ikke-støttede nettlesere og Node.js. Temporal API lager objekter som generelt representerer øyeblikk i tid. Disse kan være heltids- og datostempler i en gitt tidssone, eller de kan være en generisk forekomst av "veggklokke"-tid uten tidssone eller datoinformasjon. Noen av hovedtrekkene til Temporal inkluderer:
Tider med eller uten datoer. Et midlertidig objekt kan representere et bestemt tidspunkt på en bestemt dato, eller et tidspunkt uten datoinformasjon. En bestemt dato, uten klokkeslett, kan også representeres. Tidssonestøtte.Tidlige objekter er fullstendig tidssonebevisste og kan konverteres på tvers av forskjellige tidssoner. Moment støtter tidssoner også, men det krever ekstra øyeblikk-tidssone-bibliotek. Uforanderlighet. Så snart et Temporalt objekt er opprettet, kan det ikke endres. Tidsaritmetikk eller tidssonekonverteringer endrer ikke det underliggende objektet. I stedet genererer de et nytt Temporal-objekt. 1-basert indeksering. En vanlig kilde til feil med Date API (så vel som med Moment) er at måneder er nullindeksert. Dette betyr at januar er måned 0, i stedet for måned 1 som vi alle forstår i det virkelige liv. Temporal fikser dette ved å bruke 1-basert indeksering - januar er måned 1. Den er innebygd i nettleseren. Siden Temporal er et API i selve nettleseren, legger det ingenting til applikasjonens pakkestørrelse.
Det er også viktig å merke seg at Date API ikke forsvinner. Selv om Temporal erstatter denne API-en, blir den ikke fjernet eller avviklet. Mange applikasjoner ville gå i stykker hvis nettlesere plutselig fjernet Date API. Men husk også at Moment nå regnes som et eldre prosjekt i vedlikeholdsmodus. I resten av artikkelen skal vi se på noen "oppskrifter" for å migrere Moment-basert kode til den nye Temporal API. La oss begynne å refaktorere! Opprette dato- og tidsobjekter Før vi kan manipulere datoer og klokkeslett, må vi lage objekter som representerer dem. For å lage et øyeblikksobjekt som representerer gjeldende dato og klokkeslett, bruk øyeblikksfunksjonen. const nå = øyeblikk(); console.log(nå); // Øyeblikk<2026-02-18T21:26:29-05:00>
Dette objektet kan nå formateres eller manipuleres etter behov.
// konverter til UTC //advarsel: Dette muterer Moment-objektet og setter det i UTC-modus! console.log(now.utc()); // Øyeblikk<2026-02-19T02:26:29Z>
// skriv ut en formatert streng - merk at den bruker UTC-tiden nå console.log(now.format('MM/DD/ÅÅÅÅ tt:mm:ss a')); // 19.02.2026 02:27:07
Det viktigste å huske om Moment er at et Moment-objekt alltid inneholder informasjon om klokkeslett og dato. Hvis du kun trenger å jobbe med tidsinformasjon er dette vanligvis greit, men det kan forårsake uventet oppførsel i situasjoner som sommertid eller skuddår, hvor datoen kan ha innvirkning på tidsberegninger. Temporal er mer fleksibel. Du kan opprette et objekt som representerer gjeldende dato og klokkeslett ved å lage et Temporal.Instant-objekt. Dette representerer et tidspunkt definert av tiden siden «epoken» (midnatt UTC 1. januar 1970). Temporal kan referere til dette øyeblikket i tid med presisjon på nanosekundnivå. const now = Temporal.Now.instant();
// se rå nanosekunder siden epoken console.log(nå.epochNanosekunder); // 1771466342612000000n
// format for UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format for en bestemt tidssone console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant-objekter kan også opprettes for en bestemt tid og dato ved å bruke den statiske fra-metoden.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formater øyeblikket i den lokale tidssonen. Merk at dette kun kontrollerer // formateringen - den muterer ikke objektet slik moment.utc gjør. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Du kan også lage andre typer midlertidige objekter, inkludert:
Temporal.PlainDate: En dato uten tidsinformasjon. Temporal.PlainTime: Et tidspunkt uten datoinformasjon. Temporal.ZonedDateTime: En dato og tid i en bestemt tidssone.
Hver av disse har en fra-metode som kan kalles med et objekt som spesifiserer dato og/eller klokkeslett, eller en datostreng som skal analyseres. // Bare en date const today = Temporal.PlainDate.from({ år: 2026, måned: 2, // merk at vi bruker 2 for februar dag: 18 }); console.log(today.toString()); // 2026-02-18
// Bare en gang const lunchTime = Temporal.PlainTime.from({ time: 12 }); console.log(lunchTime.toString()); // 12:00:00
// En dato og klokkeslett i USAs østlige tidssone const dueAt = Temporal.ZonedDateTime.from({ tidssone: 'America/New_York', år: 2026, måned: 3, dag: 1, time: 12, minutt: 0, sekund: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Parsing Vi har dekket programmatisk oppretting av dato- og klokkeslettinformasjon. La oss nå se på parsing. Parsing er et område der Moment er mer fleksibelt enn den innebygde Temporal API. Du kan analysere en datostreng ved å sende den til øyeblikksfunksjonen. Med et enkelt argument forventer Moment en ISO-datostreng, men du kan bruke alternative formater hvis du oppgir et andre argument som spesifiserer datoformatet som brukes.
const isoDate = øyeblikk('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // Øyeblikk<2026-02-21T09:00:00-05:00>
console.log(formatert dato); // Øyeblikk<2026-02-21T09:00:00-05:00>
I eldre versjoner ville Moment gjøre en beste gjetning for å analysere en hvilken som helst vilkårlig formatert datostreng. Dette kan føre til uforutsigbare resultater. Er for eksempel 02-03-2026 2. februar eller 3. mars? Av denne grunn viser nyere versjoner av Moment en fremtredende avskrivningsadvarsel hvis den kalles uten en ISO-formatert datostreng (med mindre det andre argumentet med ønsket format også er gitt). Temporal vil bare analysere en spesifikt formatert datostreng. Strengen må være kompatibel med ISO 8601-formatet eller dets utvidelse, RFC 9557. Hvis en ikke-kompatibel datostreng sendes til en fra-metode, vil Temporal kaste en RangeError.
// Bruke en RFC 9557 datostreng const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Bruke en ukjent datostreng const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Temporal error: Ugyldig tegn under analysering av årsverdi.
De nøyaktige kravene til datostrengen avhenger av hvilken type Temporal-objekt du lager. I eksemplet ovenfor krever Temporal.Instant en full ISO8601 eller RFC 9557 datostreng som spesifiserer dato og klokkeslett med en tidssoneforskyvning, men du kan også lage PlainDate- eller PlainTime-objekter ved å bruke bare et delsett av datoformatet. 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(myTime.toString()); // 09:00:00
Merk at disse strengene fortsatt må samsvare med det forventede formatet, ellers vil det oppstå en feil.
// Bruke en ikke-kompatibel tidsstrenger. Disse vil alle kaste en RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profftips: Håndtering av ikke-ISO-strenger Fordi Temporal prioriterer pålitelighet, vil den ikke prøve å gjette formatet til en streng som 02-01-2026. Hvis datakilden din bruker slike strenger, må du gjøre litt strengmanipulering for å omorganisere verdiene til en ISO-streng som 2026-02-01 før du prøver å bruke den med Temporal.
Formatering Når du har et Moment eller Temporal-objekt, vil du sannsynligvis konvertere det til en formatert streng på et tidspunkt. Dette er et tilfelle der Moment er litt mer kortfattet. Du kaller objektets formatmetode med en streng med tokens som beskriver ønsket datoformat. const dato = øyeblikk();
console.log(dato.format('MM/DD/ÅÅÅÅ')); // 22.02.2026
console.log(date.format('MMMM Gjør ÅÅÅÅ, h:mm:ss a')); // 22. februar 2026, 20:18:30
På den annen side krever Temporal at du er litt mer detaljert. Temporelle objekter, for eksempel Instant, har en toLocaleString-metode som godtar ulike formateringsalternativer spesifisert som egenskaper for et objekt.
const date = Temporal.Now.instant();
// uten argumenter får vi standardformatet for gjeldende lokalitet console.log(dato.toLocaleString()); // 22/2/2026, 20:23:36 (forutsatt at en-USA er lokalisert)
// pass på formateringsalternativer for å generere en egendefinert formatstreng console.log(date.toLocaleString('en-US', { måned: 'lang', dag: 'numerisk', år: 'numerisk', time: '2-sifret', minutt: '2-sifret' })); // 22. februar 2026 kl. 20.23
// send bare feltene du vil ha i formatstrengen console.log(date.toLocaleString('en-US', { måned: 'kort', dag: 'numerisk' })); // 22. februar
Temporal datoformatering bruker faktisk Intl.DateTimeFormat API (som allerede er lett tilgjengelig i moderne nettlesere) under panseret. Det betyr at du kan lage et gjenbrukbart DateTimeFormat-objekt med dine tilpassede formateringsalternativer, og deretter sende Temporal-objekter til formatmetoden. På grunn av dette støtter den ikke tilpassede datoformater som Moment gjør. Hvis du trenger noe som "Q1 2026" eller annen spesialisert formatering, kan det hende du trenger en egendefinert datoformateringskode eller rekkevidde for et tredjepartsbibliotek. const formatter = new Intl.DateTimeFormat('en-US', { måned: '2-sifret', dag: '2-sifret', år: 'numerisk' });
const date = Temporal.Now.instant(); console.log(formatter.format(dato)); // 22.02.2026
Moments formateringstokener er enklere å skrive, men de er ikke lokaliserte. Formatet strenger "hard code" ting som måned/dag rekkefølge. Fordelen med å bruke et konfigurasjonsobjekt, som Temporal gjør, er at det automatisk tilpasser seg en gitt lokalitet og bruker riktig format. const date = Temporal.Now.instant();
const formatOptions = { måned: 'numerisk', dag: 'numerisk', år: 'numerisk' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.02.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22.02.2026
Datoberegninger I mange applikasjoner må du ende opp med å utføre noen beregninger på en dato. Det kan være lurt å legge til eller trekke fra tidsenheter (dager, timer, sekunder osv.). For eksempel, hvis du har gjeldende dato, kan det være lurt å vise brukeren datoen 1 uke fra nå. Momentobjekter har metoder som addisjon og subtrahering som utfører disse operasjonene. Disse funksjonene tar en verdi og en enhet, for eksempel: add(7, 'days'). En veldig viktig forskjell mellom Moment og Temporal er imidlertid at når du utfører disse datoberegningene, blir det underliggende objektet endret og dets opprinnelige verdi går tapt. const nå = øyeblikk();
console.log(nå); // Øyeblikk<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dager'); console.log(neste uke); // Øyeblikk<2026-03-03T20:08:36-05:00>
// Gotcha - det opprinnelige objektet ble mutert console.log(nå); // Øyeblikk<2026-03-03T20:08:36-05:00>
For å unngå å miste den opprinnelige datoen, kan du ringe klone på Moment-objektet for å lage en kopi. konst nå= øyeblikk(); const nextWeek = now.clone().add(7, 'dager');
console.log(nå); // Øyeblikk<2026-02-24T20:12:55-05:00>
console.log(neste uke); // Øyeblikk<2026-03-03T20:12:55-05:00>
På den annen side er midlertidige objekter uforanderlige. Når du har opprettet et objekt som en Instant, PlainDate, og så videre, vil verdien til det objektet aldri endres. Temporelle objekter har også addisjons- og subtraheremetoder. Temporal er litt kresen på hvilke tidsenheter som kan legges til hvilke objekttyper. Du kan for eksempel ikke legge til dager i et øyeblikk:
const now = Temporal.Now.instant(); const nextWeek = now.add({ dager: 7 }); // RangeError: Tidsfeil: Største enhet kan ikke være en datoenhet
Dette er fordi Instant-objekter representerer et spesifikt tidspunkt i UTC og er kalenderagnostiske. Fordi lengden på en dag kan endres basert på tidssoneregler som sommertid, er ikke denne beregningen tilgjengelig på et øyeblikk. Du kan imidlertid utføre denne operasjonen på andre typer objekter, for eksempel en PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
const nextWeek = now.add({ dager: 7 });
// Merk at den opprinnelige PlainDateTime forblir uendret console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
console.log(nesteWeek.toLocaleString()); // 3/3/2026, 20:23:59
Du kan også beregne hvor mye tid det er mellom to Moment- eller Temporal-objekter. Med Moments diff-funksjon må du gi en enhet for granularitet, ellers vil den returnere forskjellen i millisekunder. const date1 = øyeblikk('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(dato2.diff(dato1)); // 91800000
console.log(dato2.diff(dato1, 'dager')); // 1
For å gjøre dette med et Temporal-objekt, kan du sende et annet Temporal-objekt til dets frem til eller siden-metoder. Dette returnerer et Temporal.Duration-objekt som inneholder informasjon om tidsforskjellen. Duration-objektet har egenskaper for hver komponent av forskjellen, og kan også generere en ISO 8601-varighetsstreng som representerer tidsforskjellen.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largerUnit spesifiserer den største tidsenheten som skal representeres // i varighetsberegningen const diff = dato2.since(dato1, { størsteEnhet: 'dag' });
console.log(diff.days); // 1
console.log(diff.timer); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 varighetsstreng: 1 dag, 1 time, 30 minutter)
Sammenligne datoer og tider Både Moment og Temporal lar deg sammenligne datoer og klokkeslett for å finne ut hvilke som kommer før den andre, men ta forskjellige tilnærminger med API. Moment gir metoder som isBefore, isAfter og isSame for å sammenligne to Moment-objekter. const date1 = øyeblikk('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(dato1.isBefore(dato2)); // sant
Temporal bruker en statisk sammenligningsmetode for å utføre en sammenligning mellom to objekter av samme type. Den returnerer -1 hvis den første datoen kommer før den andre, 0 hvis de er like, eller 1 hvis den første datoen kommer etter den andre. Følgende eksempel viser hvordan du sammenligner to PlainDate-objekter. Begge argumentene til Temporal.PlainDate.compare må være PlainDate-objekter.
const date1 = Temporal.PlainDate.from({ år: 2026, måned: 2, dag: 24 }); const date2 = Temporal.PlainDate.from({ år: 2026, måned: 3, dag: 24 });
// dato1 kommer før dato2, så -1 console.log(Temporal.PlainDate.compare(date1, date2));
// Feil hvis vi prøver å sammenligne to objekter av forskjellige typer console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Temporal error: Ugyldige PlainDate-felt er oppgitt.
Spesielt gjør dette det enkelt å sortere en rekke tidsmessige objekter kronologisk. // En rekke Temporal.PlainDate-objekter const datoer = [...];
// bruk Temporal.PlainDate.compare som komparatorfunksjonen dates.sort(Temporal.PlainDate.compare);
Tidssonekonverteringer Kjernen Moment-biblioteket støtter ikke tidssonekonverteringer. Hvis du trenger denne funksjonaliteten, må du også installere moment-timezone-pakken. Denne pakken er ikke treristbar, og kan derfor øke buntstørrelsen din betydelig. Når du har installert øyeblikk-tidssone, kan du konvertere Moment-objekter til forskjellige tidssoner med tz-metoden. Som med andre Moment-operasjoner, muterer dette det underliggendegjenstand. // Forutsatt amerikansk østlig tid const nå = øyeblikk(); console.log(nå); // Øyeblikk<2026-02-28T20:08:20-05:00>
// Konverter til stillehavstid. // Den opprinnelige østlige tiden er tapt. now.tz('America/Los_Angeles'); console.log(nå); // Øyeblikk<2026-02-28T17:08:20-08:00>
Tidssonefunksjonalitet er innebygd i Temporal API når du bruker et Temporal.ZonedDateTime-objekt. Disse objektene inkluderer en withTimeZone-metode som returnerer en ny ZonedDateTime som representerer det samme tidspunktet, men i den angitte tidssonen. // Igjen, forutsatt amerikansk østlig tid const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
// Konverter til stillehavstid const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nåPacific.toLocaleString()); // 28.02.2026, 17:12:02 PST
// Originalobjektet forblir uendret console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
Merk: De formaterte verdiene som returneres av toLocaleString er, som navnet tilsier, lokalitetsavhengige. Eksempelkoden ble utviklet i en-US-lokaliteten, så formatet er slik: 2/28/2026, 17:12:02 PST. I en annen lokalitet kan dette være annerledes. For eksempel, i en-GB-lokale, vil du få noe sånt som 28/2/2026, 17:12:02 GMT-8. En refaktorisering i den virkelige verden Anta at vi bygger en app for å planlegge hendelser på tvers av tidssoner. En del av denne appen er en funksjon, getEventTimes, som tar en ISO 8601-streng som representerer klokkeslett og dato for hendelsen, en lokal tidssone og en måltidssone. Funksjonen lager formaterte tids- og datostrenger for hendelsen i begge tidssonene. Hvis funksjonen får en inndatastreng som ikke er en gyldig klokkeslett/datostreng, vil den gi en feil. Her er den originale implementeringen, ved hjelp av Moment (krever også bruk av øyeblikk-tidssone-pakken).
importer øyeblikk fra 'øyeblikk-tidssone';
funksjon getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, ÅÅÅÅ, h:mm:ss a z';
// 1. Opprett det første øyeblikket i brukerens tidssone const hendelseTid = øyeblikk.tz( inputString, moment.ISO_8601, // Forvent en ISO 8601-streng sant, // Streng analysering userTimeZone );
// Send en feil hvis inputString ikke representerte en gyldig dato if (!eventTime.isValid()) { throw new Error('Ugyldig dato/klokkeslett inndata'); }
// 2. Beregn måltiden // KRITISK: Vi må klone, ellers endres 'eventTime' for alltid! const targetTime = eventTime.clone().tz(targetTimeZone);
returnere { lokal: eventTime.format(timeFormat), mål: targetTime.format(timeFormat), }; }
const plan = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/London', );
console.log(plan.lokal); // 5. mars 2026, 15:00:00 EST
console.log(planlegging.mål); // 5. mars 2026, 20:00:00 GMT
I dette eksemplet bruker vi et forventet datoformat på ISO 8601, som er nyttig innebygd i Moment. Vi bruker også streng parsing, noe som betyr at Moment ikke vil prøve å gjette med en datostreng som ikke samsvarer med formatet. Hvis en ikke-ISO-datostreng passeres, vil det resultere i et ugyldig datoobjekt, og vi sender en feil. Temporal-implementeringen ser lik ut, men har noen få viktige forskjeller.
funksjon getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Parse inndataene direkte til et øyeblikk, og lag deretter // en ZonedDateTime i brukerens sone. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(brukerTimeZone);
// 2. Konverter til målsonen // Dette returnerer automatisk et NYTT objekt; 'eventTime' er trygt. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formater med Intl (innebygd) const alternativer = { år: 'numerisk', måned: 'kort', dag: 'numerisk', time: 'numerisk', minutt: '2-sifret', second: '2-sifret', timeZoneName: 'short' };
returnere { local: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, options) }; }
const plan = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/London', );
console.log(plan.lokal); // 5. mars 2026, 15:00:00 EST
console.log(planlegging.mål); // 5. mars 2026, 20:00:00 GMT
Med Moment må vi eksplisitt spesifisere en formatstreng for de resulterende datostrengene. Uavhengig av brukerens plassering eller lokalitet, vil arrangementstidene alltid være formatert som 5. mars 2026, 3:00:00kl. EST. Dessuten trenger vi ikke eksplisitt å gi et unntak. Hvis en ugyldig streng sendes til Temporal.Instant.from, vil Temporal kaste unntaket for oss. En ting å merke seg er at selv med streng parsing, er Moment-versjonen fortsatt mildere. Temporal krever tidssoneforskyvning på slutten av strengen. Du bør også merke deg at siden vi bruker navigator.language, vil denne koden bare kjøre i et nettlesermiljø, siden navigator ikke er definert i et Node.js-miljø. Temporal-implementeringen bruker nettleserens gjeldende lokalitet (navigator.language), slik at brukeren automatisk får hendelsestider formatert i deres lokale tidsformat. I en-USA er dette 5. mars 2026, 15:00:00 EST. Men hvis brukeren er i London, for eksempel, vil arrangementstidene bli formatert som 5. mars 2026, 15:00:00 GMT-5. Sammendrag
Handling Moment.js Temporal Gjeldende tid øyeblikk () Temporal.Now.zonedDateTimeISO() Parsing ISO øyeblikk(str) Temporal.Instant.from(str) Legg til tid .add(7, 'dager') (muterer) .add({ dager: 7 }) (nytt objekt) Forskjell .diff(annet, 'timer') .siden(andre).timer Tidssone .tz('Sone/navn') .withTimeZone('Sone/navn')
Ved første øyekast kan forskjellen være litt annerledes (og i tilfelle av Temporal, noen ganger mer detaljert og strengere) syntaks, men det er flere viktige fordeler ved å bruke Temporal fremfor Moment.js:
Å være mer eksplisitt betyr færre overraskelser og utilsiktede feil. Moment kan se ut til å være mildere, men det innebærer "gjetting", som noen ganger kan resultere i feil datoer. Hvis du gir Temporal noe ugyldig, gir det en feil. Hvis koden kjører, vet du at du har en gyldig dato. Moment kan legge til betydelig størrelse til applikasjonens pakke, spesielt hvis du bruker øyeblikk-tidssone-pakken. Temporal legger ikke til noe (når den er sendt i målnettleserne). Uforanderlighet gir deg tillit til at du aldri vil miste eller overskrive data når du utfører datokonverteringer og -operasjoner. Ulike representasjoner av tid (Instant, PlainDateTime, ZonedDateTime) avhengig av dine krav, der Moment alltid er en omslag rundt et UTC-tidsstempel. Temporal bruker Intl API-ene for datoformatering, noe som betyr at du kan ha lokalitetsbevisst formatering uten å eksplisitt spesifisere tokens.
Merknader om Polyfill Som nevnt tidligere er det en Temporal polyfill tilgjengelig, distribuert som en npm-pakke kalt @js-temporal/polyfill. Hvis du vil bruke Temporal i dag, trenger du denne polyfillen for å støtte nettlesere som Safari som ikke har sendt API ennå. Den dårlige nyheten med dette er at det vil øke buntstørrelsen din. Den gode nyheten er at den fortsatt legger til betydelig mindre enn øyeblikk eller øyeblikk-tidssone. Her er en sammenligning av pakkestørrelsene som rapportert av Bundlephobia.com, et nettsted som presenterer informasjon om npm-pakkestørrelser (klikk på hvert pakkenavn for å se Bundlephobia-analysen):
Pakke Forminsket Forminsket og gzippet @js-temporal/polyfill 154,1 kB 44,1 kB øyeblikk 294,4 kB 75,4 kB øyeblikk-tidssone 1 MB 114,2 kB
Polyfillen har også historisk hatt noen ytelsesproblemer rundt minnebruk, og i skrivende stund anses den for å være i en alfatilstand. På grunn av dette vil du kanskje ikke bruke den i produksjon før den når en mer moden tilstand. Den andre gode nyheten er at forhåpentligvis ikke polyfill vil være nødvendig mye lenger (med mindre du trenger å støtte eldre nettlesere, selvfølgelig). I skrivende stund har Temporal sendt i Chrome, Edge og Firefox. Den er ikke helt klar i Safari ennå, selv om den ser ut til å være tilgjengelig med et kjøretidsflagg på den nyeste teknologiforhåndsvisningen.
