Næsten enhver form for applikation skrevet i JavaScript fungerer med tidspunkter eller datoer i en eller anden kapacitet. I begyndelsen var dette begrænset til den indbyggede Date API. Denne API indeholder grundlæggende funktionalitet, men er ret begrænset i, hvad den kan. Tredjepartsbiblioteker som Moment.js og senere indbyggede API'er såsom Intl API'er og den nye Temporal API tilføjer meget større fleksibilitet til at arbejde med tidspunkter og datoer. The Rise And Fall Of Moment.js Moment.js er et JavaScript-bibliotek med kraftfulde værktøjer til at arbejde med tidspunkter og datoer. Det inkluderer manglende funktioner fra den grundlæggende Date API, såsom tidszonemanipulation, og gør mange almindelige operationer enklere. Moment indeholder også funktioner til formatering af datoer og tidspunkter. Det blev et meget brugt bibliotek i mange forskellige applikationer. Moment havde dog også sin andel af problemer. Det er et stort bibliotek og kan føje betydeligt til en applikations bundtstørrelse. Fordi biblioteket ikke understøtter trærystning (en funktion i moderne bundtere, der kan fjerne ubrugte dele af biblioteker), er hele Moment-biblioteket inkluderet, selvom du kun bruger en eller to af dets funktioner. Et andet problem med Moment er det faktum, at de objekter, det skaber, er foranderlige. At kalde bestemte funktioner på et Moment-objekt har bivirkninger og muterer værdien af det pågældende objekt. Dette kan føre til uventet adfærd eller fejl. I 2020 besluttede Moments vedligeholdere at sætte biblioteket i vedligeholdelsestilstand. Der foretages ingen udvikling af nye funktioner, og vedligeholderne fraråder at bruge det til nye projekter. Der er andre JavaScript-datobiblioteker, såsom date-fns, men der er en ny spiller i byen, en API indbygget direkte i JavaScript: Temporal. Det er en ny standard, der udfylder hullerne i den originale Date API samt løser nogle af de begrænsninger, der findes i Moment og andre biblioteker. Hvad er tidsmæssigt? Temporal er en ny tid og dato API, der tilføjes til ECMAScript-standarden, som definerer moderne JavaScript. Fra marts 20266 har den nået trin 4 af TC39-processen (den komité, der fører tilsyn med forslag og tilføjelser til JavaScript-sproget), og vil blive inkluderet i den næste version af ECMAScript-specifikationen. Det er allerede blevet implementeret i flere browsere: Chrome 144+ og Firefox 139+, hvor Safari forventes at følge snart. En polyfill er også tilgængelig for ikke-understøttede browsere og Node.js. Temporal API opretter objekter, der generelt repræsenterer øjeblikke i tid. Disse kan være fuldtids- og datostempler i en given tidszone, eller de kan være en generisk forekomst af "vægur"-tid uden nogen tidszone eller datooplysninger. Nogle af hovedfunktionerne i Temporal inkluderer:
Tider med eller uden datoer. Et Temporalt objekt kan repræsentere et bestemt tidspunkt på en bestemt dato eller et tidspunkt uden nogen datoinformation. En bestemt dato, uden et tidspunkt, kan også repræsenteres. Tidszoneunderstøttelse.Tidlige objekter er fuldt tidszonebevidste og kan konverteres på tværs af forskellige tidszoner. Moment understøtter også tidszoner, men det kræver det ekstra øjeblik-tidszone-bibliotek. Uforanderlighed. Når først et Temporalt objekt er oprettet, kan det ikke ændres. Tidsaritmetiske eller tidszonekonverteringer ændrer ikke det underliggende objekt. I stedet genererer de et nyt Temporal-objekt. 1-baseret indeksering. En almindelig kilde til fejl med Date API (såvel som med Moment) er, at måneder er nulindekseret. Det betyder, at januar er måned 0, snarere end måned 1, som vi alle forstår i det virkelige liv. Tidsmæssigt løser dette ved at bruge 1-baseret indeksering - januar er måned 1. Den er indbygget i browseren. Da Temporal er en API i selve browseren, tilføjer den intet til din applikations bundtstørrelse.
Det er også vigtigt at bemærke, at Date API ikke forsvinder. Mens Temporal erstatter denne API, bliver den ikke fjernet eller forældet. Mange applikationer ville gå i stykker, hvis browsere pludselig fjernede Date API. Husk dog også på, at Moment nu betragtes som et legacy-projekt i vedligeholdelsestilstand. I resten af artiklen vil vi se på nogle "opskrifter" til at migrere Moment-baseret kode til den nye Temporal API. Lad os begynde at omstrukturere! Oprettelse af dato- og tidsobjekter Før vi kan manipulere datoer og tidspunkter, skal vi oprette objekter, der repræsenterer dem. For at oprette et øjebliksobjekt, der repræsenterer den aktuelle dato og klokkeslæt, skal du bruge øjebliksfunktionen. const nu = moment(); console.log(nu); // Øjeblik<2026-02-18T21:26:29-05:00>
Dette objekt kan nu formateres eller manipuleres efter behov.
// konverter til UTC //advarsel: Dette muterer Moment-objektet og sætter det i UTC-tilstand! console.log(nu.utc()); // Moment<2026-02-19T02:26:29Z>
// udskriv en formateret streng - bemærk, at den bruger UTC-tiden nu console.log(now.format('MM/DD/ÅÅÅÅ tt:mm:ss a')); // 19/02/2026 02:27:07
Det vigtigste at huske om Moment er, at et Moment-objekt altid indeholder information om tidspunktet og datoen. Hvis du kun skal arbejde med tidsinformation, er det normalt fint, men det kan forårsage uventet adfærd i situationer som sommertid eller skudår, hvor datoen kan have betydning for tidsberegninger. Temporal er mere fleksibel. Du kan oprette et objekt, der repræsenterer den aktuelle dato og klokkeslæt, ved at oprette et Temporal.Instant-objekt. Dette repræsenterer et tidspunkt defineret af tiden siden "epoken" (midnat UTC den 1. januar 1970). Temporal kan referere til dette øjeblik i tid med præcision på nanosekundniveau. const nu = Temporal.Now.instant();
// se rå nanosekunder siden epoken console.log(nu.epochNanosekunder); // 1771466342612000000n
// format for UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format for en bestemt tidszone console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant-objekter kan også oprettes til et bestemt tidspunkt og dato ved at bruge den statiske fra-metode.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formater instant i den lokale tidszone. Bemærk, at dette kun kontrollerer // formateringen - den muterer ikke objektet som moment.utc gør. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Du kan også oprette andre typer af midlertidige objekter, herunder:
Temporal.PlainDate: En dato uden tidsoplysninger. Temporal.PlainTime: Et tidspunkt uden datooplysninger. Temporal.ZonedDateTime: En dato og et klokkeslæt i en bestemt tidszone.
Hver af disse har en fra-metode, der kan kaldes med et objekt, der angiver dato og/eller klokkeslæt, eller en datostreng, der skal parses. // Bare en date const today = Temporal.PlainDate.from({ år: 2026, måned: 2, // bemærk at vi bruger 2 til 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 tid i den østlige tidszone i USA const dueAt = Temporal.ZonedDateTime.from({ tidszone: 'America/New_York', år: 2026, måned: 3, dag: 1, time: 12, minut: 0, sekund: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Parsing Vi har dækket programmatisk oprettelse af oplysninger om dato og klokkeslæt. Lad os nu se på parsing. Parsing er et område, hvor Moment er mere fleksibelt end den indbyggede Temporal API. Du kan parse en datostreng ved at overføre den til momentfunktionen. Med et enkelt argument forventer Moment en ISO-datostreng, men du kan bruge alternative formater, hvis du angiver et andet argument, der angiver datoformatet, der bruges.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // Øjeblik<2026-02-21T09:00:00-05:00>
console.log(formateret dato); // Øjeblik<2026-02-21T09:00:00-05:00>
I ældre versioner ville Moment gøre det bedste gæt at parse enhver vilkårligt formateret datostreng. Dette kan føre til uforudsigelige resultater. Er 02-03-2026 f.eks. 2. februar eller 3. marts? Af denne grund viser nyere versioner af Moment en fremtrædende udfasningsadvarsel, hvis den kaldes uden en ISO-formateret datostreng (medmindre det andet argument med det ønskede format også er givet). Temporal vil kun parse en specifikt formateret datostreng. Strengen skal være kompatibel med ISO 8601-formatet eller dets udvidelse, RFC 9557. Hvis en ikke-kompatibel datostreng overføres til en fra-metode, vil Temporal kaste en RangeError.
// Brug af 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
// Brug af en ukendt datostreng const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Temporal fejl: Ugyldigt tegn under parsing af årsværdi.
De nøjagtige krav til datostrengen afhænger af, hvilken type Temporal-objekt du opretter. I ovenstående eksempel kræver Temporal.Instant en fuld ISO8601 eller RFC 9557 datostreng, der angiver datoen og klokkeslættet med en tidszoneforskydning, men du kan også oprette PlainDate- eller PlainTime-objekter ved hjælp af blot en delmængde af 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
Bemærk, at disse strenge stadig skal overholde det forventede format, ellers vil der blive smidt en fejl.
// Brug af en ikke-kompatibel tidsstrenge. Disse vil alle kaste en RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Professionelt tip: Håndtering af ikke-ISO strengeFordi Temporal prioriterer pålidelighed, vil den ikke forsøge at gætte formatet på en streng som 02-01-2026. Hvis din datakilde bruger sådanne strenge, skal du udføre nogle strengmanipulationer for at omarrangere værdierne til en ISO-streng som 2026-02-01, før du forsøger at bruge den med Temporal.
Formatering Når du har et Moment eller Temporal-objekt, vil du sandsynligvis konvertere det til en formateret streng på et tidspunkt. Dette er et tilfælde, hvor Moment er lidt mere kortfattet. Du kalder objektets formatmetode med en streng af tokens, der beskriver det ønskede datoformat. const dato = øjeblik();
console.log(dato.format('MM/DD/ÅÅÅÅ')); // 22/02/2026
console.log(date.format('MMMM Gør ÅÅÅÅ, h:mm:ss a')); // 22. februar 2026 kl. 20.18.30
På den anden side kræver Temporal, at du er lidt mere udførlig. Temporale objekter, såsom Instant, har en toLocaleString-metode, der accepterer forskellige formateringsindstillinger, der er angivet som egenskaber for et objekt.
const dato = Temporal.Now.instant();
// uden argumenter får vi standardformatet for den aktuelle lokalitet console.log(dato.toLocaleString()); // 22/02/2026, 20:23:36 (forudsat en lokalitet en-US)
// videregive formateringsmuligheder for at generere en brugerdefineret formatstreng console.log(date.toLocaleString('en-US', { måned: 'lang', dag: 'numerisk', år: 'numerisk', time: '2-cifret', minut: '2-cifret' })); // 22. februar 2026 kl. 20.23
// send kun de felter, du ønsker i formatstrengen console.log(date.toLocaleString('en-US', { måned: 'kort', dag: 'numerisk' })); // 22. feb
Temporal datoformatering bruger faktisk Intl.DateTimeFormat API (som allerede er let tilgængelig i moderne browsere) under hætten. Det betyder, at du kan oprette et genanvendeligt DateTimeFormat-objekt med dine tilpassede formateringsindstillinger og derefter overføre Temporal-objekter til dets formatmetode. På grund af dette understøtter den ikke tilpassede datoformater, som Moment gør. Hvis du har brug for noget som 'Q1 2026' eller anden specialiseret formatering, har du muligvis brug for en tilpasset datoformateringskode eller rækkevidde til et tredjepartsbibliotek. const formatter = new Intl.DateTimeFormat('en-US', { måned: '2-cifret', dag: '2-cifret', år: 'numerisk' });
const dato = Temporal.Now.instant(); console.log(formatter.format(dato)); // 22/02/2026
Moments formateringstokens er nemmere at skrive, men de er ikke lokalitetsvenlige. Formatet strenger "hard code" ting som måned/dag ordre. Fordelen ved at bruge et konfigurationsobjekt, som Temporal gør, er, at det automatisk tilpasser sig til enhver given lokalitet og bruger det korrekte format. const dato = Temporal.Now.instant();
const formatOptions = { måned: 'numerisk', dag: 'numerisk', år: 'numerisk' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/2/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Datoberegninger I mange applikationer skal du ende med at udføre nogle beregninger på en dato. Du vil måske tilføje eller trække tidsenheder fra (dage, timer, sekunder osv.). For eksempel, hvis du har den aktuelle dato, vil du måske vise brugeren datoen 1 uge fra nu. Momentobjekter har metoder såsom addering og subtraktion, der udfører disse operationer. Disse funktioner tager en værdi og en enhed, for eksempel: add(7, 'days'). En meget vigtig forskel mellem Moment og Temporal er imidlertid, at når du udfører disse datoberegninger, bliver det underliggende objekt ændret, og dets oprindelige værdi går tabt. const nu = moment();
console.log(nu); // Øjeblik<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dage'); console.log(næste uge); // Øjeblik<2026-03-03T20:08:36-05:00>
// Gotcha - det originale objekt blev muteret console.log(nu); // Øjeblik<2026-03-03T20:08:36-05:00>
For at undgå at miste den oprindelige dato, kan du kalde klon på Moment-objektet for at oprette en kopi. konst nu= øjeblik(); const nextWeek = now.clone().add(7, 'dage');
console.log(nu); // Øjeblik<2026-02-24T20:12:55-05:00>
console.log(næste uge); // Øjeblik<2026-03-03T20:12:55-05:00>
På den anden side er Temporale objekter uforanderlige. Når du har oprettet et objekt som en Instant, PlainDate og så videre, vil værdien af dette objekt aldrig ændre sig. Temporale objekter har også tilføjelses- og subtraktionsmetoder. Temporal er lidt kræsen for hvilke tidsenheder der kan tilføjes til hvilke objekttyper. Du kan f.eks. ikke tilføje dage til et øjeblik:
const nu = Temporal.Now.instant(); const nextWeek = now.add({ dage: 7 }); // RangeError: Temporal fejl: Største enhed kan ikke være en datoenhed
Dette skyldes, at Instant-objekter repræsenterer et bestemt tidspunkt i UTC og er kalenderagnostiske. Fordi længden af en dag kan ændre sig baseret på tidszoneregler såsom sommertid, er denne beregning ikke tilgængelig på et øjeblik. Du kan dog udføre denne handling på andre typer objekter, såsom en PlainDateTime: const nu = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
const nextWeek = now.add({ dage: 7 });
// Bemærk, at den oprindelige PlainDateTime forbliver uændret console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Du kan også beregne, hvor meget tid der er mellem to Moment- eller Temporal-objekter. Med Moments diff-funktion skal du angive en enhed for granularitet, ellers returnerer den forskellen i millisekunder. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(dato2.diff(dato1)); // 91800000
console.log(dato2.diff(dato1, 'dage')); // 1
For at gøre dette med et Temporal-objekt kan du videregive et andet Temporal-objekt til dets indtil eller siden-metoder. Dette returnerer et Temporal.Duration-objekt, der indeholder information om tidsforskellen. Duration-objektet har egenskaber for hver komponent af forskellen og kan også generere en ISO 8601-varighedsstreng, der repræsenterer tidsforskellen.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// størsteEnhed angiver den største tidsenhed, der skal repræsenteres // i varighedsberegningen const diff = dato2.since(dato1, {størsteenhed: 'dag'});
console.log(forskel.dage); // 1
console.log(forskel.timer); // 1
console.log(forskel.minutter); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 varighed streng: 1 dag, 1 time, 30 minutter)
Sammenligning af datoer og tider Moment og Temporal giver dig begge mulighed for at sammenligne datoer og klokkeslæt for at afgøre, hvilke der kommer før den anden, men tage forskellige tilgange med API'en. Moment giver metoder såsom isBefore, isAfter og isSame til at sammenligne to Moment-objekter. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(dato1.isBefore(dato2)); // sandt
Temporal bruger en statisk sammenligningsmetode til at udføre en sammenligning mellem to objekter af samme type. Den returnerer -1, hvis den første dato kommer før den anden, 0, hvis de er ens, eller 1, hvis den første dato kommer efter den anden. Følgende eksempel viser, hvordan man sammenligner to PlainDate-objekter. Begge argumenter til Temporal.PlainDate.compare skal 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));
// Fejl, hvis vi forsøger at sammenligne to objekter af forskellige typer console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Temporal error: Ugyldige PlainDate-felter er angivet.
Dette gør det især nemt at sortere en række af tidsmæssige objekter kronologisk. // En række Temporal.PlainDate-objekter const datoer = [...];
// brug Temporal.PlainDate.compare som komparatorfunktionen dates.sort(Temporal.PlainDate.compare);
Tidszonekonverteringer Det centrale Moment-bibliotek understøtter ikke tidszonekonverteringer. Hvis du har brug for denne funktionalitet, skal du også installere moment-timezone-pakken. Denne pakke kan ikke rystes med træer og kan derfor øge dit bundts størrelse betydeligt. Når du har installeret moment-tidszone, kan du konvertere Moment-objekter til forskellige tidszoner med tz-metoden. Som med andre Moment-operationer, muterer dette det underliggendeobjekt. // Forudsat amerikansk østlig tid const nu = moment(); console.log(nu); // Øjeblik<2026-02-28T20:08:20-05:00>
// Konverter til Stillehavstid. // Den oprindelige østlige tid er tabt. now.tz('America/Los_Angeles'); console.log(nu); // Øjeblik<2026-02-28T17:08:20-08:00>
Tidszonefunktionalitet er indbygget i Temporal API, når du bruger et Temporal.ZonedDateTime-objekt. Disse objekter inkluderer en withTimeZone-metode, der returnerer en ny ZonedDateTime, der repræsenterer det samme tidspunkt, men i den angivne tidszone. // Igen, antaget amerikansk østlig tid const nu = 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(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 PST
// Originalt objekt forbliver uændret console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
Bemærk: De formaterede værdier, der returneres af toLocaleString, er, som navnet antyder, lokalitetsafhængige. Eksempelkoden blev udviklet i en-US landestandard, så formatet er som dette: 28/2/2026, 17:12:02 PST. I en anden lokalitet kan dette være anderledes. For eksempel vil du i en-GB-lokaliteten få noget som 28/2/2026, 17:12:02 GMT-8. En refaktorering i den virkelige verden Antag, at vi bygger en app til at planlægge begivenheder på tværs af tidszoner. En del af denne app er en funktion, getEventTimes, som tager en ISO 8601-streng, der repræsenterer tidspunktet og datoen for begivenheden, en lokal tidszone og en måltidszone. Funktionen opretter formaterede tids- og datostrenge for begivenheden i begge tidszoner. Hvis funktionen får en inputstreng, der ikke er en gyldig tids-/datostreng, vil den give en fejl. Her er den originale implementering ved hjælp af Moment (kræver også brug af moment-timezone-pakken).
importer øjeblik fra 'moment-timezone';
funktion getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, ÅÅÅÅ, h:mm:ss a z';
// 1. Opret det første øjeblik i brugerens tidszone const eventTime = moment.tz( inputString, moment.ISO_8601, // Forvent en ISO 8601-streng sand, // Streng parsing brugerTimeZone );
// Smid en fejl, hvis inputString ikke repræsenterede en gyldig dato if (!eventTime.isValid()) { throw new Error('Ugyldig dato/tidsindtastning'); }
// 2. Beregn måltiden // KRITISK: Vi skal klone, ellers ændres 'eventTime' for altid! 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(planlægning.lokal); // 5. marts 2026, 15:00:00 EST
console.log(plan.mål); // 5. marts 2026, 20:00:00 GMT
I dette eksempel bruger vi et forventet datoformat på ISO 8601, som er nyttigt indbygget i Moment. Vi bruger også streng parsing, hvilket betyder, at Moment ikke vil forsøge at gætte med en datostreng, der ikke matcher formatet. Hvis en ikke-ISO-datostreng sendes, vil det resultere i et ugyldigt datoobjekt, og vi sender en fejl. Temporal-implementeringen ligner, men har et par vigtige forskelle.
funktion getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Parse input direkte til et øjeblik, og opret derefter // en ZonedDateTime i brugerens zone. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(brugerTimeZone);
// 2. Konverter til målzonen // Dette returnerer automatisk et NYT objekt; 'eventTime' er sikker. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatér ved hjælp af Intl (indbygget) const muligheder = { år: 'numerisk', måned: 'kort', dag: 'numerisk', time: 'numerisk', minut: '2-cifret', sekund: '2-cifret', timeZoneName: 'short' };
returnere { local: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, optioner) }; }
const plan = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/London', );
console.log(planlægning.lokal); // 5. marts 2026, 15:00:00 EST
console.log(plan.mål); // 5. marts 2026, 20:00:00 GMT
Med Moment skal vi udtrykkeligt angive en formatstreng for de resulterende datostrenge. Uanset brugerens placering eller lokalitet vil begivenhedstiderne altid være formateret som 5. marts 2026, 3:00:00kl. EST. Vi behøver heller ikke udtrykkeligt at kaste en undtagelse. Hvis en ugyldig streng sendes til Temporal.Instant.from, vil Temporal kaste undtagelsen for os. En ting at bemærke er, at selv med streng parsing er Moment-versionen stadig mere skånsom. Temporal kræver tidszoneforskydningen i slutningen af strengen. Du skal også bemærke, at da vi bruger navigator.language, vil denne kode kun køre i et browsermiljø, da navigator ikke er defineret i et Node.js-miljø. Temporal-implementeringen bruger browserens aktuelle lokalitet (navigator.language), så brugeren automatisk får hændelsestider formateret i deres lokale tidsformat. I en-USA er dette 5. marts 2026, 15:00:00 EST. Men hvis brugeren for eksempel er i London, vil begivenhedstiderne blive formateret som 5. marts 2026, 15:00:00 GMT-5. Resumé
Handling Moment.js Temporal Aktuel tid øjeblik () Temporal.Now.zonedDateTimeISO() Parsing af ISO øjeblik (str) Temporal.Instant.from(str) Tilføj tid .add(7, 'dage') (muterer) .add({ dage: 7 }) (nyt objekt) Forskel .diff(other, 'timer') .siden(andre).timer Tidszone .tz('Zone/navn') .withTimeZone('Zone/navn')
Ved første øjekast kan forskellen være en smule anderledes (og i tilfælde af Temporal, nogle gange mere udførlig og mere streng) syntaks, men der er flere vigtige fordele ved at bruge Temporal frem for Moment.js:
At være mere eksplicit betyder færre overraskelser og utilsigtede fejl. Moment kan synes at være mere skånsomt, men det involverer "gætværk", som nogle gange kan resultere i forkerte datoer. Hvis du giver Temporal noget ugyldigt, giver det en fejl. Hvis koden kører, ved du, at du har en gyldig dato. Moment kan tilføje betydelig størrelse til applikationens bundt, især hvis du bruger moment-timezone-pakken. Temporal tilføjer intet (når den først er afsendt i dine målbrowsere). Uforanderlighed giver dig tillid til, at du aldrig vil miste eller overskrive data, når du udfører datokonverteringer og -operationer. Forskellige repræsentationer af tid (Instant, PlainDateTime, ZonedDateTime) afhængigt af dine krav, hvor Moment altid er en indpakning omkring et UTC-tidsstempel. Temporal bruger Intl API'erne til datoformatering, hvilket betyder, at du kan have lokalitetsbevidst formatering uden eksplicit at skulle angive tokens.
Noter om Polyfill Som tidligere nævnt er der en Temporal polyfill tilgængelig, distribueret som en npm-pakke ved navn @js-temporal/polyfill. Hvis du vil bruge Temporal i dag, skal du bruge denne polyfill til at understøtte browsere som Safari, der endnu ikke har sendt API'en. Den dårlige nyhed med dette er, at det vil øge din bundtstørrelse. Den gode nyhed er, at den stadig tilføjer væsentligt mindre end øjeblik eller øjebliks-tidszone. Her er en sammenligning af bundlestørrelserne som rapporteret af Bundlephobia.com, et websted, der præsenterer information om npm-pakkestørrelser (klik på hvert pakkenavn for at se Bundlephobia-analysen):
Pakke Formindsket Minimeret og gzippet @js-temporal/polyfill 154,1 kB 44,1 kB øjeblik 294,4 kB 75,4 kB øjeblik-tidszone 1 MB 114,2 kB
Polyfill har også historisk haft nogle præstationsproblemer omkring hukommelsesbrug, og i skrivende stund anses det for at være i en alfatilstand. På grund af dette vil du måske ikke bruge det i produktionen, før det når en mere moden tilstand. Den anden gode nyhed er, at polyfill forhåbentlig ikke vil være nødvendigt meget længere (medmindre du skal understøtte ældre browsere, selvfølgelig). I skrivende stund er Temporal afsendt i Chrome, Edge og Firefox. Det er ikke helt klar i Safari endnu, selvom det ser ud til at være tilgængeligt med et runtime-flag på den seneste Technology Preview.
