Nästan alla typer av applikationer skrivna i JavaScript fungerar med tider eller datum i viss kapacitet. I början var detta begränsat till det inbyggda Date API. Detta API innehåller grundläggande funktionalitet, men är ganska begränsat i vad det kan göra. Tredjepartsbibliotek som Moment.js, och senare inbyggda API:er som Intl API:erna och det nya Temporal API:et, ger mycket större flexibilitet att arbeta med tider och datum. Uppgång och fall av Moment.js Moment.js är ett JavaScript-bibliotek med kraftfulla verktyg för att arbeta med tider och datum. Det inkluderar saknade funktioner från det grundläggande Date API, såsom tidszonsmanipulation, och gör många vanliga operationer enklare. Moment innehåller även funktioner för att formatera datum och tider. Det blev ett flitigt använt bibliotek i många olika applikationer. Moment hade dock också sin del av emissioner. Det är ett stort bibliotek och kan avsevärt lägga till en applikations paketstorlek. Eftersom biblioteket inte stöder trädskakning (en funktion hos moderna buntare som kan ta bort oanvända delar av bibliotek), ingår hela Moment-biblioteket även om du bara använder en eller två av dess funktioner. Ett annat problem med Moment är det faktum att objekten som det skapar är föränderliga. Att anropa vissa funktioner på ett Moment-objekt har bieffekter och muterar värdet på det objektet. Detta kan leda till oväntat beteende eller buggar. 2020 beslutade underhållarna av Moment att sätta biblioteket i underhållsläge. Ingen utveckling av nya funktioner görs, och underhållarna rekommenderar att de inte används för nya projekt. Det finns andra JavaScript-datumbibliotek, till exempel date-fns, men det finns en ny spelare i stan, ett API inbyggt direkt i JavaScript: Temporal. Det är en ny standard som fyller i hålen i det ursprungliga Date API samt löser några av begränsningarna som finns i Moment och andra bibliotek. Vad är temporärt? Temporal är ett nytt tids- och datum-API som läggs till i ECMAScript-standarden, som definierar modern JavaScript. Från och med mars 20266 har den nått steg 4 av TC39-processen (kommittén som övervakar förslag och tillägg till JavaScript-språket), och kommer att inkluderas i nästa version av ECMAScript-specifikationen. Det har redan implementerats i flera webbläsare: Chrome 144+ och Firefox 139+, med Safari som förväntas följa snart. En polyfill är också tillgänglig för webbläsare och Node.js som inte stöds. Temporal API skapar objekt som i allmänhet representerar ögonblick i tiden. Dessa kan vara heltids- och datumstämplar i en given tidszon, eller så kan de vara en allmän instans av "väggklocka" utan någon tidszon eller datuminformation. Några av huvudfunktionerna i Temporal inkluderar:
Tider med eller utan datum. Ett Temporalt objekt kan representera en specifik tid på ett specifikt datum, eller en tid utan någon datuminformation. Ett specifikt datum, utan tid, kan också representeras. Tidszonsstöd.Temporala objekt är helt tidszonsmedvetna och kan konverteras över olika tidszoner. Moment stöder också tidszoner, men det kräver det extra ögonblick-tidszonbiblioteket. Immutability.När ett Temporal-objekt har skapats kan det inte ändras. Tidsaritmetik eller tidszonsomvandlingar ändrar inte det underliggande objektet. Istället genererar de ett nytt Temporal-objekt. 1-baserad indexering. En vanlig källa till buggar med Date API (liksom med Moment) är att månader är nollindexerade. Det betyder att januari är månad 0, snarare än månad 1 som vi alla förstår i verkligheten. Temporal fixar detta genom att använda 1-baserad indexering - januari är månad 1. Den är inbyggd i webbläsaren. Eftersom Temporal är ett API i själva webbläsaren, tillför det ingenting till din applikations paketstorlek.
Det är också viktigt att notera att Date API inte försvinner. Även om Temporal ersätter detta API, tas det inte bort eller fasas ut. Många applikationer skulle gå sönder om webbläsare plötsligt tog bort Date API. Kom dock också ihåg att Moment nu betraktas som ett äldre projekt i underhållsläge. I resten av artikeln kommer vi att titta på några "recept" för att migrera Moment-baserad kod till det nya Temporal API. Låt oss börja omstrukturera! Skapa datum- och tidsobjekt Innan vi kan manipulera datum och tider måste vi skapa objekt som representerar dem. För att skapa ett ögonblicksobjekt som representerar det aktuella datumet och tiden, använd ögonblicksfunktionen. const nu = moment(); console.log(nu); // Moment<2026-02-18T21:26:29-05:00>
Detta objekt kan nu formateras eller manipuleras efter behov.
// konvertera till UTC //varning: Detta muterar Moment-objektet och sätter det i UTC-läge! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// skriv ut en formaterad sträng - notera att den använder UTC-tiden nu console.log(now.format('MM/DD/ÅÅÅÅ hh:mm:ss a')); // 2026-02-19 02:27:07
Det viktigaste att komma ihåg om Moment är att ett Moment-objekt alltid innehåller information om tid och datum. Om du bara behöver arbeta med tidsinformation går det oftast bra, men det kan orsaka oväntat beteende i situationer som sommartid eller skottår, där datumet kan påverka tidsberäkningar. Temporal är mer flexibelt. Du kan skapa ett objekt som representerar aktuellt datum och tid genom att skapa ett Temporal.Instant-objekt. Detta representerar en tidpunkt som definieras av tiden sedan "epoken" (midnatt UTC den 1 januari 1970). Temporal kan referera till detta ögonblick i tid med precision på nanosekundnivå. const now = Temporal.Now.instant();
// se råa nanosekunder sedan epoken console.log(nu.epochNanosekunder); // 1771466342612000000n
// format för UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format för en viss tidszon console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant-objekt kan också skapas för en specifik tid och datum genom att använda den statiska från-metoden.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatera ögonblicket i den lokala tidszonen. Observera att detta endast styr // formateringen - den muterar inte objektet som moment.utc gör. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Du kan också skapa andra typer av temporära objekt, inklusive:
Temporal.PlainDate: Ett datum utan tidsinformation. Temporal.PlainTime: En tid utan datuminformation. Temporal.ZonedDateTime: Ett datum och en tid i en specifik tidszon.
Var och en av dessa har en från-metod som kan anropas med ett objekt som anger datum och/eller tid, eller en datumsträng att tolka. // Bara en dejt const today = Temporal.PlainDate.from({ år: 2026, månad: 2, // notera att vi använder 2 för februari dag: 18 }); console.log(today.toString()); // 2026-02-18
// Bara en gång const lunchTime = Temporal.PlainTime.from({ timme: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Ett datum och en tid i USA:s östra tidszon const dueAt = Temporal.ZonedDateTime.from({ tidszon: 'America/New_York', år: 2026, månad: 3, dag: 1, timme: 12, minut: 0, andra: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Parsing Vi har tagit upp programmatiskt skapande av datum- och tidsinformation. Låt oss nu titta på analysen. Parsing är ett område där Moment är mer flexibelt än det inbyggda Temporal API. Du kan analysera en datumsträng genom att skicka den till momentfunktionen. Med ett enda argument förväntar Moment sig en ISO-datumsträng, men du kan använda alternativa format om du anger ett andra argument som anger vilket datumformat som används.
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); // Moment<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Moment<2026-02-21T09:00:00-05:00>
I äldre versioner skulle Moment göra en bästa gissning för att analysera valfri godtyckligt formaterad datumsträng. Detta kan leda till oförutsägbara resultat. Är till exempel 2026-03-02 2 februari eller 3 mars? Av denna anledning visar nyare versioner av Moment en framträdande utfasningsvarning om den anropas utan en ISO-formaterad datumsträng (såvida inte det andra argumentet med önskat format också anges). Temporal kommer bara att analysera en specifikt formaterad datumsträng. Strängen måste vara kompatibel med ISO 8601-formatet eller dess tillägg, RFC 9557. Om en icke-kompatibel datumsträng skickas till en från-metod kommer Temporal att kasta ett RangeError.
// Använda en RFC 9557 datumsträng 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
// Använder en okänd datumsträng const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Temporalt fel: Ogiltigt tecken vid analys av årsvärde.
De exakta kraven för datumsträngen beror på vilken typ av Temporal-objekt du skapar. I exemplet ovan kräver Temporal.Instant en fullständig ISO8601 eller RFC 9557 datumsträng som anger datum och tid med en tidszonförskjutning, men du kan också skapa PlainDate- eller PlainTime-objekt med bara en delmängd av datumformatet. 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
Observera att dessa strängar fortfarande måste överensstämma med det förväntade formatet, annars kommer ett fel att visas.
// Använda en icke-kompatibel tidssträng. Dessa kommer alla att kasta ett RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Proffstips: Hantera icke-ISO-strängar Eftersom Temporal prioriterar tillförlitlighet kommer den inte att försöka gissa formatet för en sträng som 02-01-2026. Om din datakälla använder sådana strängar måste du göra lite strängmanipulation för att ordna om värdena till en ISO-sträng som 2026-02-01 innan du försöker använda den med Temporal.
Formatering När du väl har ett Moment eller Temporal-objekt vill du förmodligen konvertera det till en formaterad sträng någon gång. Detta är ett exempel där Moment är lite mer kortfattat. Du anropar objektets formatmetod med en sträng av tokens som beskriver det önskade datumformatet. const date = moment();
console.log(date.format('MM/DD/ÅÅÅÅ')); // 2026-02-22
console.log(date.format('MMMM Gör ÅÅÅÅ, h:mm:ss a')); // 22 februari 2026, 20:18:30
Å andra sidan kräver Temporal att du är lite mer utförlig. Temporala objekt, som Instant, har en toLocaleString-metod som accepterar olika formateringsalternativ som anges som egenskaper för ett objekt.
const date = Temporal.Now.instant();
// utan argument får vi standardformatet för den aktuella lokalen console.log(date.toLocaleString()); // 2026-02-22, 20:23:36 (förutsatt att språket är sv-USA)
// skicka formateringsalternativ för att generera en anpassad formatsträng console.log(date.toLocaleString('en-US', { månad: 'lång', dag: 'numerisk', år: 'numerisk', timme: '2-siffrig', minut: '2-siffrig' })); // 22 februari 2026 kl. 20.23
// skicka bara de fält du vill ha i formatsträngen console.log(date.toLocaleString('en-US', { månad: 'kort', dag: 'numerisk' })); // 22 februari
Temporal datumformatering använder faktiskt Intl.DateTimeFormat API (som redan är lättillgängligt i moderna webbläsare) under huven. Det betyder att du kan skapa ett återanvändbart DateTimeFormat-objekt med dina anpassade formateringsalternativ och sedan skicka Temporal-objekt till dess formatmetod. På grund av detta stöder den inte anpassade datumformat som Moment gör. Om du behöver något som "Q1 2026" eller annan specialiserad formatering, kan du behöva lite anpassad datumformateringskod eller nå ett tredjepartsbibliotek. const formatter = new Intl.DateTimeFormat('en-US', { månad: '2-siffrig', dag: '2-siffrig', år: 'numerisk' });
const date = Temporal.Now.instant(); console.log(formatter.format(datum)); // 2026-02-22
Moments formateringstokens är enklare att skriva, men de är inte lokalvänliga. Formatet stränger "hård kod" saker som månad/dag ordning. Fördelen med att använda ett konfigurationsobjekt, som Temporal gör, är att det automatiskt anpassar sig till en given lokal och använder rätt format. const date = Temporal.Now.instant();
const formatOptions = { månad: 'numerisk', dag: 'numerisk', år: 'numerisk' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2026-02-22
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Datumberäkningar I många applikationer måste du sluta utföra vissa beräkningar på ett datum. Du kanske vill lägga till eller subtrahera tidsenheter (dagar, timmar, sekunder, etc.). Till exempel, om du har det aktuella datumet, kanske du vill visa användaren datumet 1 vecka från nu. Momentobjekt har metoder som addera och subtrahera som utför dessa operationer. Dessa funktioner tar ett värde och en enhet, till exempel: add(7, 'days'). En mycket viktig skillnad mellan Moment och Temporal är dock att när man utför dessa datumberäkningar, ändras det underliggande objektet och dess ursprungliga värde går förlorat. const nu = moment();
console.log(nu); // Moment<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(nästa vecka); // Moment<2026-03-03T20:08:36-05:00>
// Gotcha - det ursprungliga objektet muterades console.log(nu); // Moment<2026-03-03T20:08:36-05:00>
För att undvika att förlora originaldatumet kan du anropa klon på Moment-objektet för att skapa en kopia. konst nu= moment(); const nextWeek = now.clone().add(7, 'days');
console.log(nu); // Moment<2026-02-24T20:12:55-05:00>
console.log(nästa vecka); // Moment<2026-03-03T20:12:55-05:00>
Å andra sidan är Temporala objekt oföränderliga. När du har skapat ett objekt som ett Instant, PlainDate, och så vidare, kommer värdet på det objektet aldrig att ändras. Temporala objekt har också addera och subtrahera metoder. Temporal är lite kräsen med vilka tidsenheter som kan läggas till vilka objekttyper. Du kan till exempel inte lägga till dagar i ett Instant:
const now = Temporal.Now.instant(); const nextWeek = now.add({ dagar: 7 }); // RangeError: Temporalt fel: Största enheten kan inte vara en datumenhet
Detta beror på att Instant-objekt representerar en specifik tidpunkt i UTC och är kalenderagnostiska. Eftersom längden på en dag kan ändras baserat på tidszonsregler som sommartid, är den här beräkningen inte tillgänglig på ett ögonblick. Du kan dock utföra den här operationen på andra typer av objekt, till exempel en PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2026-02-24, 20:23:59
const nextWeek = now.add({ dagar: 7 });
// Observera att den ursprungliga PlainDateTime förblir oförändrad console.log(now.toLocaleString()); // 2026-02-24, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Du kan också beräkna hur lång tid det är mellan två Moment- eller Temporal-objekt. Med Moments diff-funktion måste du tillhandahålla en enhet för granularitet, annars kommer den att returnera skillnaden i millisekunder. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(datum2.diff(datum1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
För att göra detta med ett Temporal-objekt kan du skicka ett annat Temporal-objekt till dess till eller efter metoder. Detta returnerar ett Temporal.Duration-objekt som innehåller information om tidsskillnaden. Objektet Duration har egenskaper för varje komponent i skillnaden och kan även generera en ISO 8601 varaktighetssträng som representerar tidsskillnaden.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largerUnit anger den största tidsenhet som ska representeras // i varaktighetsberäkningen const diff = datum2.since(datum1, { störstaEnhet: 'dag' });
console.log(diff.days); // 1
console.log(diff.timmar); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 varaktighetssträng: 1 dag, 1 timme, 30 minuter)
Jämföra datum och tider Moment och Temporal låter dig båda jämföra datum och tider för att avgöra vilka som kommer före den andra, men ta olika tillvägagångssätt med API:et. Moment tillhandahåller metoder som isBefore, isAfter och isSame för att jämföra två Moment-objekt. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // sant
Temporal använder en statisk jämförelsemetod för att utföra en jämförelse mellan två objekt av samma typ. Det returnerar -1 om det första datumet kommer före det andra, 0 om de är lika, eller 1 om det första datumet kommer efter det andra. Följande exempel visar hur man jämför två PlainDate-objekt. Båda argumenten till Temporal.PlainDate.compare måste vara PlainDate-objekt.
const date1 = Temporal.PlainDate.from({ år: 2026, månad: 2, dag: 24 }); const date2 = Temporal.PlainDate.from({ år: 2026, månad: 3, dag: 24 });
// datum1 kommer före datum2, alltså -1 console.log(Temporal.PlainDate.compare(date1, date2));
// Fel om vi försöker jämföra två objekt av olika typer console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Temporal error: Ogiltiga PlainDate-fält tillhandahålls.
I synnerhet gör detta det enkelt att sortera en uppsättning av Temporala objekt kronologiskt. // En uppsättning Temporal.PlainDate-objekt const datum = [ ... ];
// använd Temporal.PlainDate.compare som jämförande funktion dates.sort(Temporal.PlainDate.compare);
Tidszonsomvandlingar Kärnbiblioteket Moment stöder inte tidszonkonverteringar. Om du behöver den här funktionen måste du också installera moment-timezone-paketet. Det här paketet är inte skakbart i träd och kan därför lägga till avsevärt till din buntstorlek. När du har installerat ögonblick-tidszon kan du konvertera Moment-objekt till olika tidszoner med tz-metoden. Som med andra Moment-operationer, muterar detta det underliggandeobjekt. // Förutsatt amerikansk östlig tid const nu = moment(); console.log(nu); // Moment<2026-02-28T20:08:20-05:00>
// Konvertera till Stillahavstid. // Den ursprungliga österländska tiden är förlorad. now.tz('America/Los_Angeles'); console.log(nu); // Moment<2026-02-28T17:08:20-08:00>
Tidszonsfunktionalitet är inbyggd i Temporal API när ett Temporal.ZonedDateTime-objekt används. Dessa objekt inkluderar en withTimeZone-metod som returnerar en ny ZonedDateTime som representerar samma ögonblick i tiden, men i den angivna tidszonen. // Återigen, förutsatt amerikansk östtid const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2026-02-28, 20:12:02 EST
// Konvertera till Stillahavstid const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2026-02-28, 17:12:02 PST
// Originalobjektet förblir oförändrat console.log(now.toLocaleString()); // 2026-02-28, 20:12:02 EST
Obs: De formaterade värdena som returneras av toLocaleString är, som namnet antyder, språkberoende. Exempelkoden utvecklades i en-USA, så formatet är så här: 2026-28-2, 17:12:02 PST. På en annan plats kan detta vara annorlunda. Till exempel, i en-GB-lokalen, skulle du få något som 28/2/2026, 17:12:02 GMT-8. En verklig refaktorering Anta att vi bygger en app för att schemalägga händelser över tidszoner. En del av den här appen är en funktion, getEventTimes, som tar en ISO 8601-sträng som representerar tid och datum för händelsen, en lokal tidszon och en måltidszon. Funktionen skapar formaterade tids- och datumsträngar för händelsen i båda tidszonerna. Om funktionen ges en indatasträng som inte är en giltig tid-/datumsträng, kommer den att ge ett fel. Här är den ursprungliga implementeringen, med Moment (kräver också användning av moment-timezone-paketet).
importera ögonblick från 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, ÅÅÅÅ, h:mm:ss a z';
// 1. Skapa det första ögonblicket i användarens tidszon const eventTime = moment.tz( inputString, moment.ISO_8601, // Räkna med en ISO 8601-sträng sant, // Strikt analys userTimeZone );
// Skicka ett fel om inputString inte representerade ett giltigt datum if (!eventTime.isValid()) { throw new Error('Ogiltig inmatning av datum/tid'); }
// 2. Beräkna måltiden // KRITISKT: Vi måste klona, annars ändras 'eventTime' för alltid! const targetTime = eventTime.clone().tz(targetTimeZone);
returnera { lokalt: eventTime.format(timeFormat), mål: targetTime.format(timeFormat), }; }
const schema = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/London', );
console.log(schedule.local); // 5 mars 2026, 15:00:00 EST
console.log(schedule.target); // 5 mars 2026, 20:00:00 GMT
I det här exemplet använder vi ett förväntat datumformat enligt ISO 8601, som är användbart inbyggt i Moment. Vi använder också strikt analys, vilket innebär att Moment inte kommer att försöka gissa med en datumsträng som inte matchar formatet. Om en icke-ISO-datumsträng skickas kommer det att resultera i ett ogiltigt datumobjekt, och vi skapar ett fel. Temporal-implementeringen ser likadan ut, men har några viktiga skillnader.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analysera inmatningen direkt till ett ögonblick och skapa sedan // en ZonedDateTime i användarens zon. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Konvertera till målzonen // Detta returnerar automatiskt ett NYTT objekt; 'eventTime' är säker. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatera med Intl (inbyggd) const alternativ = { år: 'numerisk', månad: 'kort', dag: 'numerisk', timme: 'numerisk', minut: '2-siffrig', andra: '2-siffrig', timeZoneName: 'short' };
returnera { local: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, options) }; }
const schema = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/London', );
console.log(schedule.local); // 5 mars 2026, 15:00:00 EST
console.log(schedule.target); // 5 mars 2026, 20:00:00 GMT
Med Moment måste vi uttryckligen ange en formatsträng för de resulterande datumsträngarna. Oavsett användarens plats eller språk kommer evenemangstiderna alltid att vara formaterade som 5 mars 2026, 3:00:00kl. EST. Dessutom behöver vi inte uttryckligen göra ett undantag. Om en ogiltig sträng skickas till Temporal.Instant.from, kommer Temporal att kasta undantaget för oss. En sak att notera är att även med strikt analys är Moment-versionen fortfarande mildare. Temporal kräver tidszonsförskjutningen i slutet av strängen. Du bör också notera att eftersom vi använder navigator.language kommer den här koden bara att köras i en webbläsarmiljö, eftersom navigator inte är definierad i en Node.js-miljö. Temporal-implementeringen använder webbläsarens aktuella språkinställning (navigator.language), så användaren får automatiskt händelsetider formaterade i sitt lokala tidsformat. I en-USA är detta 5 mars 2026, 15:00:00 EST. Men om användaren är i London, till exempel, kommer evenemangstiderna att formateras som 5 mars 2026, 15:00:00 GMT-5. Sammanfattning
Åtgärd Moment.js Temporal Aktuell tid ögonblick () Temporal.Now.zonedDateTimeISO() Parsar ISO moment(str) Temporal.Instant.from(str) Lägg till tid .add(7, 'dagar') (muterar) .add({ dagar: 7 }) (nytt objekt) Skillnad .diff(other, 'timmar') .sedan(andra).timmar Tidszon .tz('Zone/Name') .withTimeZone('Zone/Name')
Vid första anblicken kan skillnaden vara något annorlunda (och i fallet med Temporal, ibland mer utförlig och mer strikt) syntax, men det finns flera viktiga fördelar med att använda Temporal framför Moment.js:
Att vara mer explicit innebär färre överraskningar och oavsiktliga buggar. Moment kan tyckas vara mildare, men det innebär "gissningar", vilket ibland kan resultera i felaktiga datum. Om du ger Temporal något ogiltigt, ger det ett fel. Om koden körs vet du att du har ett giltigt datum. Moment kan lägga till betydande storlek till applikationens paket, särskilt om du använder paketet ögonblick-tidszon. Temporal tillför ingenting (när den väl har skickats i dina målwebbläsare). Immutability ger dig förtroendet att du aldrig kommer att förlora eller skriva över data när du utför datumkonverteringar och operationer. Olika representationer av tid (Instant, PlainDateTime, ZonedDateTime) beroende på dina krav, där Moment alltid är ett omslag runt en UTC-tidsstämpel. Temporal använder Intl API:er för datumformatering, vilket innebär att du kan ha språkmedveten formatering utan att uttryckligen behöva ange tokens.
Anteckningar om Polyfill Som nämnts tidigare finns det en Temporal polyfill tillgänglig, distribuerad som ett npm-paket med namnet @js-temporal/polyfill. Om du vill använda Temporal idag behöver du denna polyfill för att stödja webbläsare som Safari som ännu inte har skickat API:et. De dåliga nyheterna med detta är att det kommer att öka din buntstorlek. Den goda nyheten är att den fortfarande lägger till betydligt mindre än ögonblick eller ögonblick-tidszon. Här är en jämförelse av paketstorlekarna som rapporterats av Bundlephobia.com, en webbplats som presenterar information om npm-paketstorlekar (klicka på varje paketnamn för att se Bundlephobia-analysen):
Paket Minifierad Minifierad och gzippad @js-temporal/polyfill 154,1 kB 44,1 kB ögonblick 294,4 kB 75,4 kB ögonblick-tidszon 1 MB 114,2 kB
Polyfillen har också historiskt haft vissa prestandaproblem kring minnesanvändning, och i skrivande stund anses den vara i ett alfatillstånd. På grund av detta kanske du inte vill använda den i produktionen förrän den når ett mer mogen tillstånd. Den andra goda nyheten är att förhoppningsvis kommer polyfillen inte att behövas mycket längre (såvida du inte behöver stödja äldre webbläsare, förstås). I skrivande stund har Temporal levererats i Chrome, Edge och Firefox. Det är inte riktigt klart i Safari ännu, även om det verkar vara tillgängligt med en runtime-flagga på den senaste Technology Preview.
