JavaScript Temporal Duration: Bemästra tidsintervallaritmetik och formatering för globala applikationer

Att hantera tid inom mjukvaruutveckling är notoriskt komplext. Från att spåra projekttidslinjer över kontinenter till att schemalägga internationella videokonferenser kan nyanserna av tidsintervall, tidszoner och sommartid snabbt leda till subtila men kritiska buggar. I årtionden har JavaScript-utvecklare brottats med det inbyggda Date-objektet, ett verktyg som, även om det är funktionellt för enkla tidpunkter, inte räcker till när det gäller precis tidsintervallaritmetik och robust, globalt medveten tidshantering.

Här kommer JavaScript Temporal API – ett banbrytande förslag designat för att erbjuda ett modernt, robust och användarvänligt API för att arbeta med datum och tider i JavaScript. Bland dess kraftfulla nya typer framstår Temporal.Duration som den definitiva lösningen för att hantera tidsintervall. Denna artikel kommer att ta dig på en djupdykning i Temporal.Duration, och utforska dess förmågor för aritmetik, jämförelse och intelligent formatering, för att säkerställa att dina applikationer kan hantera tid med global precision och tydlighet.

Oavsett om du bygger ett globalt logistiksystem, en finansiell handelsplattform eller en evenemangsplanerare för flera tidszoner, är förståelsen för Temporal.Duration avgörande för att eliminera tidsrelaterade tvetydigheter och leverera pålitliga, internationaliserade användarupplevelser.

Brister hos JavaScripts Date-objekt för tidsintervall

Innan vi firar ankomsten av Temporal.Duration är det viktigt att förstå begränsningarna med det befintliga Date-objektet, särskilt när det gäller tidsintervall. Date-objektet representerar en specifik tidpunkt, mätt i millisekunder sedan Unix-epoken (1 januari 1970, UTC). Även om det kan användas för att utföra grundläggande aritmetik, har det flera inneboende brister som gör det olämpligt för robust hantering av varaktigheter:

• Mutabilitet: Date-objekt är muterbara. Varje operation på ett Date-objekt ändrar dess interna tillstånd, vilket kan leda till oväntade sidoeffekter och svårspårade buggar, särskilt i komplexa applikationer eller samtidiga miljöer.

              const d = new Date('2023-01-15T10:00:00Z');
  const d2 = d; // d2 now references the same object as d
  d.setHours(d.getHours() + 1);
  
  console.log(d.toISOString());  // 2023-01-15T11:00:00.000Z
  console.log(d2.toISOString()); // 2023-01-15T11:00:00.000Z (d2 also changed!)
  
              
  
                
                  Copy
                
              
            

• Avsaknad av ett varaktighetskoncept: Date-objektet har inget direkt koncept för en "varaktighet" eller "period". Att beräkna skillnaden mellan två datum resulterar i ett antal millisekunder, som sedan manuellt måste konverteras till år, månader, dagar, etc. Denna manuella konvertering är felbenägen, särskilt när man hanterar månader med varierande längd eller skottår.

              const date1 = new Date('2023-01-01T00:00:00Z');
  const date2 = new Date('2023-03-01T00:00:00Z');
  
  const diffMs = date2.getTime() - date1.getTime();
  
  // How many months is this? What about leap years?
  // (diffMs / (1000 * 60 * 60 * 24 * 30)) is an approximation at best.
  console.log(`Difference in milliseconds: ${diffMs}`);
  console.log(`Approximate days: ${diffMs / (1000 * 60 * 60 * 24)}`); // Works for days, but not robust for months/years
  
              
  
                
                  Copy
                
              
            

• Tidszonstvetydighet: Date-objekt blandar ofta ihop lokal tid och UTC. Även om de internt lagrar UTC-millisekunder, arbetar deras metoder ofta med systemets lokala tidszon som standard, vilket leder till förvirring och inkonsekvenser när man arbetar med distribuerade system eller internationella användare.
• Utmaningar med sommartid (DST): Övergångar till sommartid kan göra att dagar blir 23 eller 25 timmar långa. Enkel aritmetik (t.ex. att lägga till 24 timmar till ett datum) kanske inte alltid resulterar i nästa kalenderdag, vilket leder till felaktiga beräkningar när en "dag" antas vara en fast 24-timmarsperiod.

Dessa begränsningar har historiskt sett tvingat utvecklare att förlita sig på tredjepartsbibliotek som Moment.js eller date-fns, eller att skriva komplex, felbenägen anpassad kod för att hantera tidsintervall korrekt. Temporal syftar till att införa dessa funktioner direkt i JavaScript.

Introduktion till JavaScript Temporal: En modern metod för tidshantering

Temporal API är ett omfattande, nytt globalt objekt i JavaScript designat för att vara en modern ersättning för det äldre Date-objektet. Dess kärnprinciper är oföränderlighet (immutability), explicit hantering av tidszoner och en tydlig uppdelning av ansvarsområden mellan olika tidskoncept. Temporal introducerar flera nya klasser, var och en representerande en distinkt aspekt av tid:

• Temporal.Instant: En specifik, otvetydig tidpunkt, oberoende av någon kalender eller tidszon (liknande en Unix-tidsstämpel, men med nanosekundprecision).
• Temporal.ZonedDateTime: En specifik tidpunkt i en viss kalender och tidszon. Detta är den mest kompletta representationen av ett specifikt datum och tid för en användare.
• Temporal.PlainDate: Ett kalenderdatum (år, månad, dag) utan tid eller tidszon.
• Temporal.PlainTime: En klocktid (timme, minut, sekund, etc.) utan datum eller tidszon.
• Temporal.PlainDateTime: Ett kalenderdatum och klocktid tillsammans, utan tidszon.
• Temporal.PlainYearMonth: Ett specifikt år och månad i ett kalendersystem.
• Temporal.PlainMonthDay: En specifik månad och dag i ett kalendersystem.
• Temporal.Duration: En signerad tidslängd, såsom "5 timmar och 30 minuter" eller "2 dagar". Detta är vårt fokus i denna guide.

Alla Temporal-objekt är oföränderliga, vilket innebär att operationer som att lägga till eller subtrahera tid skapar nya objekt istället för att modifiera befintliga, vilket ökar förutsägbarheten och minskar antalet buggar.

Förstå Temporal.Duration

En Temporal.Duration representerar en tidslängd. Avgörande är att den är oberoende av en specifik start- eller slutpunkt. Det är helt enkelt "hur mycket tid" som har förflutit eller kommer att förflyta. Den kan bestå av år, månader, veckor, dagar, timmar, minuter, sekunder, millisekunder, mikrosekunder och nanosekunder. Varje komponent är ett heltal och kan vara positivt eller negativt.

Till exempel är "2 timmar och 30 minuter" en varaktighet. "Perioden från 1 januari till 1 mars" är en varaktighet mellan två specifika punkter, som kan *representeras* av en Temporal.Duration, men själva Duration är bara intervallet.

Skapa en varaktighet

Det finns flera enkla sätt att skapa Temporal.Duration-objekt:

1. Använda konstruktorn

Konstruktorn låter dig specificera varje komponent direkt. Notera att argumenten är ordnade från största enhet (år) till minsta (nanosekunder).

            // new Temporal.Duration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds)

// A duration of 2 hours and 30 minutes
const duration1 = new Temporal.Duration(0, 0, 0, 0, 2, 30, 0, 0, 0, 0);
console.log(duration1.toString()); // P2H30M

// A duration of 1 year, 2 months, 3 days
const duration2 = new Temporal.Duration(1, 2, 0, 3);
console.log(duration2.toString()); // P1Y2M3D

// A duration of -5 days
const duration3 = new Temporal.Duration(0, 0, 0, -5);
console.log(duration3.toString()); // P-5D

            

              
                Copy
              
            
          

2. Använda Temporal.Duration.from() med ett objekt

Detta är ofta det mest läsbara sättet att skapa varaktigheter, vilket låter dig specificera endast de komponenter du behöver.

            // Duration of 1.5 hours
const halfHourDuration = Temporal.Duration.from({ hours: 1, minutes: 30 });
console.log(halfHourDuration.toString()); // P1H30M

// Duration of 7 days (1 week)
const oneWeekDuration = Temporal.Duration.from({ days: 7 });
console.log(oneWeekDuration.toString());  // P7D

// Duration with fractional seconds (e.g., 2.5 seconds)
const twoPointFiveSeconds = Temporal.Duration.from({ seconds: 2, milliseconds: 500 });
console.log(twoPointFiveSeconds.toString()); // PT2.5S

// Negative duration
const negativeDuration = Temporal.Duration.from({ minutes: -45 });
console.log(negativeDuration.toString()); // PT-45M

            

              
                Copy
              
            
          

3. Använda Temporal.Duration.from() med en ISO 8601-sträng

Temporal använder sig av ISO 8601-formatet för varaktigheter, vilket är en standard för att representera varaktigheter. Detta är utmärkt för att tolka varaktigheter från externa datakällor.

Formatet ser generellt ut som P[years]Y[months]M[weeks]W[days]DT[hours]H[minutes]M[seconds]S. T separerar datumkomponenter från tidskomponenter.

            // 1 year, 2 months, 3 days
const isoDuration1 = Temporal.Duration.from('P1Y2M3D');
console.log(isoDuration1.toString()); // P1Y2M3D

// 4 hours, 5 minutes, 6 seconds
const isoDuration2 = Temporal.Duration.from('PT4H5M6S');
console.log(isoDuration2.toString()); // PT4H5M6S

// A combined duration
const isoDuration3 = Temporal.Duration.from('P7DT12H30M');
console.log(isoDuration3.toString()); // P7DT12H30M

// Fractional seconds are also supported
const isoDuration4 = Temporal.Duration.from('PT1.5S');
console.log(isoDuration4.toString()); // PT1.5S

            

              
                Copy
              
            
          

Utföra aritmetik med varaktigheter

Den sanna kraften hos Temporal.Duration lyser igenom i dess aritmetiska förmågor. Du kan addera, subtrahera, multiplicera och dividera varaktigheter, och även addera/subtrahera dem från andra Temporal-datum/tidstyper. Alla operationer returnerar nya Temporal.Duration-objekt på grund av oföränderligheten.

Addera varaktigheter

add()-metoden kombinerar två varaktigheter.

            const sprintDuration = Temporal.Duration.from({ weeks: 2 });
const bufferDuration = Temporal.Duration.from({ days: 3 });

const totalProjectTime = sprintDuration.add(bufferDuration);
console.log(totalProjectTime.toString()); // P2W3D (or P17D if normalized later)

// Adding a negative duration is equivalent to subtraction
const result = Temporal.Duration.from({ hours: 5 }).add({ hours: -2 });
console.log(result.toString()); // PT3H

            

              
                Copy
              
            
          

Du kan också addera en varaktighet till vilket Temporal-datum/tidsobjekt som helst. Det är här magin sker, eftersom Temporal korrekt hanterar tidszonsförskjutningar och övergångar till sommartid när det är relevant.

            const projectStart = Temporal.PlainDateTime.from('2023-10-26T09:00:00');
const projectDuration = Temporal.Duration.from({ days: 10, hours: 4 });

const projectEnd = projectStart.add(projectDuration);
console.log(projectEnd.toString()); // 2023-11-05T13:00:00

// With a ZonedDateTime, the time zone rules are applied correctly
const meetingStartUTC = Temporal.ZonedDateTime.from('2024-03-09T14:00:00[UTC]');
const meetingDuration = Temporal.Duration.from({ hours: 1, minutes: 45 });

const meetingEndUTC = meetingStartUTC.add(meetingDuration);
console.log(meetingEndUTC.toString()); // 2024-03-09T15:45:00+00:00[UTC]

// Example crossing a DST boundary (assuming 'Europe/Berlin' shifts at 03:00 on 2024-03-31)
const springForwardStart = Temporal.ZonedDateTime.from('2024-03-30T22:00:00[Europe/Berlin]');
const twentyFourHours = Temporal.Duration.from({ hours: 24 });

const nextDay = springForwardStart.add(twentyFourHours); // Adds 24 actual hours
console.log(springForwardStart.toString()); // 2024-03-30T22:00:00+01:00[Europe/Berlin]
console.log(nextDay.toString());          // 2024-03-31T23:00:00+02:00[Europe/Berlin] (Local time skipped an hour)

            

              
                Copy
              
            
          

Notera hur additionen av 24 timmar till 2024-03-30T22:00:00 i Berlin (som är UTC+1) resulterar i 2024-03-31T23:00:00 (nu UTC+2). Klockan hoppade fram en timme, så klocktiden är en timme senare på samma datum i förhållande till den ursprungliga klocktiden. Detta demonstrerar exakt Temporals medvetenhet om tidszoner och sommartid när man utför aritmetik på `ZonedDateTime`.

Subtrahera varaktigheter

subtract()-metoden fungerar på liknande sätt som add(), men den tar bort tid.

            const deadlineDuration = Temporal.Duration.from({ days: 30 });
const gracePeriod = Temporal.Duration.from({ days: 5 });

const effectiveDeadline = deadlineDuration.subtract(gracePeriod);
console.log(effectiveDeadline.toString()); // P25D

const taskEnd = Temporal.PlainDateTime.from('2023-12-01T17:00:00');
const taskDuration = Temporal.Duration.from({ hours: 8, minutes: 30 });

const taskStart = taskEnd.subtract(taskDuration);
console.log(taskStart.toString()); // 2023-12-01T08:30:00

            

              
                Copy
              
            
          

Multiplicera och dividera varaktigheter

Metoderna multiply() och divide() skalar komponenterna i en varaktighet med en given faktor. Detta är användbart för scenarier som att beräkna total tid för flera iterationer av en uppgift.

            const trainingSession = Temporal.Duration.from({ minutes: 45 });
const weeklyTraining = trainingSession.multiply(5); // Five sessions a week
console.log(weeklyTraining.toString()); // PT225M

const totalProjectHours = Temporal.Duration.from({ hours: 160 });
const teamMembers = 4;

const hoursPerMember = totalProjectHours.divide(teamMembers);
console.log(hoursPerMember.toString()); // PT40H

            

              
                Copy
              
            
          

Negera varaktigheter

negate()-metoden vänder på tecknet för alla komponenter i en varaktighet. En positiv varaktighet blir negativ, och vice versa.

            const delayDuration = Temporal.Duration.from({ hours: 3 });
const advanceDuration = delayDuration.negate();

console.log(delayDuration.toString());   // PT3H
console.log(advanceDuration.toString()); // PT-3H

            

              
                Copy
              
            
          

Absolutvärdet av varaktigheter

abs()-metoden returnerar en ny Temporal.Duration med alla komponenter gjorda positiva, vilket effektivt ger dig storleken på varaktigheten oavsett dess tecken.

            const negativeDelay = Temporal.Duration.from({ minutes: -60 });
const positiveDuration = negativeDelay.abs();

console.log(negativeDelay.toString());  // PT-60M
console.log(positiveDuration.toString()); // PT60M

            

              
                Copy
              
            
          

Jämföra och normalisera varaktigheter

Att jämföra varaktigheter kan vara knepigt, särskilt när olika enheter är inblandade (t.ex. är 1 månad lika med 30 dagar?). Temporal tillhandahåller verktyg för både jämförelse och normalisering för att hantera dessa komplexiteter.

Jämföra varaktigheter med compare()

Den statiska metoden Temporal.Duration.compare(duration1, duration2, options) returnerar:

• -1 om duration1 är mindre än duration2
• 0 om duration1 är lika med duration2
• 1 om duration1 är större än duration2

Avgörande är att när du jämför varaktigheter som inkluderar enheter med variabel längd som år, månader eller veckor, behöver du ofta ange ett relativeTo-alternativ. Denna parameter är ett `Temporal.ZonedDateTime`- eller `Temporal.PlainDateTime`-objekt som ger sammanhang för hur dessa enheter ska tolkas (t.ex. hur många dagar det är i en specifik månad eller ett år).

            const oneHour = Temporal.Duration.from({ hours: 1 });
const sixtyMinutes = Temporal.Duration.from({ minutes: 60 });

console.log(Temporal.Duration.compare(oneHour, sixtyMinutes)); // 0 (De är ekvivalenta)

const oneMonth = Temporal.Duration.from({ months: 1 });
const thirtyDays = Temporal.Duration.from({ days: 30 });

// Without relativeTo, month/year comparisons are difficult
console.log(Temporal.Duration.compare(oneMonth, thirtyDays)); // 0 (Temporal gör en rimlig gissning utan kontext, ofta baserat på genomsnitt)

// With relativeTo, the comparison is precise based on the context's calendar
const startOfJanuary = Temporal.PlainDate.from('2023-01-01');
const endOfFebruaryLeap = Temporal.PlainDate.from('2024-02-01'); // Leap year

// In January 2023, 1 month is 31 days
const comparisonJan = Temporal.Duration.compare(oneMonth, thirtyDays, { relativeTo: startOfJanuary });
console.log(`1 month vs 30 days in Jan 2023: ${comparisonJan}`); // 1 (1 månad > 30 dagar)

// In February 2024 (leap year), 1 month is 29 days
const comparisonFeb = Temporal.Duration.compare(oneMonth, thirtyDays, { relativeTo: endOfFebruaryLeap });
console.log(`1 month vs 30 days in Feb 2024: ${comparisonFeb}`); // -1 (1 månad < 30 dagar)

            

              
                Copy
              
            
          

Normalisera varaktigheter med normalize() och round()

Varaktigheter kan representeras på många sätt (t.ex. 90 minuter eller 1 timme och 30 minuter). Normalisering och avrundning hjälper till att standardisera dessa representationer för konsekvens och visning.

normalize()

normalize()-metoden förenklar varaktighetskomponenter där det är möjligt (t.ex. blir 60 minuter 1 timme, 24 timmar blir 1 dag, förutsatt att `relativeTo`-kontexten tillåter det om månader/år är inblandade).

            const longMinutes = Temporal.Duration.from({ minutes: 90 });
console.log(longMinutes.toString()); // PT90M
console.log(longMinutes.normalize().toString()); // PT1H30M

const multipleDays = Temporal.Duration.from({ hours: 48 });
console.log(multipleDays.toString()); // PT48H
console.log(multipleDays.normalize().toString()); // P2D

            

              
                Copy
              
            
          

round()

round()-metoden är mer kraftfull för att omvandla och avrunda varaktigheter till specifika enheter. Den tar ett alternativobjekt med:

• largestUnit: Den största enheten att inkludera i resultatet (t.ex. 'years', 'days', 'hours').
• smallestUnit: Den minsta enheten att inkludera i resultatet (t.ex. 'minutes', 'seconds', 'milliseconds').
• roundingIncrement: Ett heltal att avrunda den minsta enheten med (t.ex. 5 för avrundning till närmaste 5 minuter).
• roundingMode: Hur man hanterar oavgjorda fall (t.ex. 'halfExpand', 'trunc', 'ceil', 'floor').
• relativeTo: Krävs för att avrunda varaktigheter som innehåller år, månader eller veckor.

            const complexDuration = Temporal.Duration.from({ hours: 2, minutes: 45, seconds: 30 });

// Round to the nearest hour
const roundedToHours = complexDuration.round({ smallestUnit: 'hour' });
console.log(roundedToHours.toString()); // PT3H

// Round to the nearest 30 minutes, keeping hours
const roundedTo30Minutes = complexDuration.round({
  largestUnit: 'hour',
  smallestUnit: 'minute',
  roundingIncrement: 30
});
console.log(roundedTo30Minutes.toString()); // PT3H

const preciseDuration = Temporal.Duration.from({ minutes: 123, seconds: 45 });

// Display as hours and minutes
const formattedDuration = preciseDuration.round({ largestUnit: 'hour', smallestUnit: 'minute' });
console.log(formattedDuration.toString()); // PT2H4M

// Rounding with months/years requires relativeTo
const longTermDuration = Temporal.Duration.from({ months: 1, days: 10 });
const referenceDate = Temporal.PlainDate.from('2023-01-15');

// Round to months, relative to a date
const roundedToMonths = longTermDuration.round({ largestUnit: 'month', smallestUnit: 'month', relativeTo: referenceDate });
console.log(roundedToMonths.toString()); // P1M

            

              
                Copy
              
            
          

Beräkna varaktigheter mellan Temporal-objekt

En av de vanligaste användningarna av varaktigheter är att beräkna tidsintervallet mellan två specifika tidpunkter. Temporal tillhandahåller metoderna until() och since() på sina datum/tidsobjekt för detta ändamål.

until()-metoden

until()-metoden beräknar varaktigheten från mottagarobjektet till argumentobjektet. Den är inkluderande för startpunkten och exkluderande för slutpunkten. Den tar ett alternativobjekt liknande round() för att specificera de önskade enheterna och avrundningsbeteendet.

            const startDate = Temporal.PlainDate.from('2023-01-01');
const endDate = Temporal.PlainDate.from('2023-03-15');

// Duration in largest possible units (months, then days)
const projectLength = startDate.until(endDate);
console.log(projectLength.toString()); // P2M14D

// Duration purely in days
const totalDays = startDate.until(endDate, { largestUnit: 'day' });
console.log(totalDays.toString()); // P73D

// Duration between two specific times, respecting time zones
const meetingStart = Temporal.ZonedDateTime.from('2024-07-20T10:00:00[America/New_York]');
const meetingEnd = Temporal.ZonedDateTime.from('2024-07-20T11:30:00[America/New_York]');

const elapsedMeetingTime = meetingStart.until(meetingEnd, { largestUnit: 'hour', smallestUnit: 'minute' });
console.log(elapsedMeetingTime.toString()); // PT1H30M

// Cross-timezone duration (from NYC to London)
const nyStartTime = Temporal.ZonedDateTime.from('2024-08-01T09:00:00[America/New_York]');
const londonEndTime = Temporal.ZonedDateTime.from('2024-08-01T17:00:00[Europe/London]');

const travelDuration = nyStartTime.until(londonEndTime);
console.log(travelDuration.toString()); // PT13H (Actual elapsed time, not wall-clock difference)

            

              
                Copy
              
            
          

Det sista exemplet är särskilt insiktsfullt. Även om New York ligger 5 timmar efter London, och klocktiderna är 9:00 och 17:00 på samma dag, beräknar until()-metoden korrekt den faktiska förflutna tiden på 13 timmar. Detta beror på att ZonedDateTime implicit hanterar tidszonsskillnaden.

since()-metoden

since()-metoden är motsatsen till until(). Den beräknar varaktigheten från argumentobjektet till mottagarobjektet, vilket resulterar i en negativ varaktighet om argumentet ligger i framtiden i förhållande till mottagaren.

            const currentDateTime = Temporal.ZonedDateTime.from('2024-06-15T12:00:00[Europe/Paris]');
const historicEvent = Temporal.ZonedDateTime.from('2024-01-01T00:00:00[Europe/Paris]');

const timeSinceEvent = currentDateTime.since(historicEvent, { largestUnit: 'month', smallestUnit: 'day' });
console.log(timeSinceEvent.toString()); // P5M14D

const futureDate = Temporal.PlainDate.from('2025-01-01');
const pastDate = Temporal.PlainDate.from('2024-01-01');

const durationFromFuture = pastDate.since(futureDate);
console.log(durationFromFuture.toString()); // P-1Y

            

              
                Copy
              
            
          

Hantera olika enheter och avrundning för beräknade varaktigheter

När man beräknar varaktigheter är det ofta nödvändigt att specificera `largestUnit` och `smallestUnit` för att få en mänskligt läsbar representation, särskilt för ålder, förfluten tid eller nedräkningar.

            const birthDate = Temporal.PlainDate.from('1990-07-15');
const today = Temporal.PlainDate.from('2024-06-15');

// Calculate age in years, months, and days
const age = birthDate.until(today, { largestUnit: 'year', smallestUnit: 'day' });
console.log(`Age: ${age.years} years, ${age.months} months, ${age.days} days`); // Age: 33 years, 11 months, 0 days

// Calculate time remaining for a task in hours and minutes
const now = Temporal.Instant.fromEpochSeconds(Date.now() / 1000);
const deadline = Temporal.Instant.from('2024-07-01T09:00:00Z');

const timeLeft = now.until(deadline, { largestUnit: 'hour', smallestUnit: 'minute', roundingMode: 'ceil' });
console.log(`Time left: ${timeLeft.hours} hours and ${timeLeft.minutes} minutes.`); // Example: Time left: 355 hours and 38 minutes.

            

              
                Copy
              
            
          

Formatera varaktigheter för en global publik

Även om Temporal.Duration ger exakta, programmatiska representationer av tidsintervall, har den inte en inbyggd toLocaleString()-metod. Detta är avsiktligt: varaktigheter är abstrakta tidslängder, och deras visning kan variera kraftigt beroende på kontext, språk och önskad detaljnivå. Du, som utvecklare, är ansvarig för att presentera varaktigheter på ett användarvänligt och globalt förståeligt sätt.

ISO 8601-strängrepresentation

Standardmetoden toString() för ett Temporal.Duration-objekt returnerar dess ISO 8601-strängrepresentation. Detta är utmärkt för kommunikation mellan maskiner, serialisering och lagring, men sällan för direkt visning för slutanvändare.

            const examDuration = Temporal.Duration.from({ hours: 2, minutes: 15 });
console.log(examDuration.toString()); // PT2H15M

const holidayDuration = Temporal.Duration.from({ weeks: 2, days: 3 });
console.log(holidayDuration.toString()); // P2W3D

            

              
                Copy
              
            
          

Manuell formatering för läsbarhet och internationalisering

För visning mot användare kommer du vanligtvis att extrahera komponenterna från en varaktighet och formatera dem med hjälp av stränginterpolation och JavaScripts Intl API.

Här är ett exempel på en anpassad funktion som formaterar en varaktighet:

            function formatDurationToHumanReadable(duration, locale = 'en-US') {
  const parts = [];

  // Using Intl.NumberFormat for locale-aware number formatting
  const numberFormatter = new Intl.NumberFormat(locale);

  if (duration.years !== 0) {
    parts.push(numberFormatter.format(duration.years) + ' ' + (duration.years === 1 ? 'year' : 'years'));
  }
  if (duration.months !== 0) {
    parts.push(numberFormatter.format(duration.months) + ' ' + (duration.months === 1 ? 'month' : 'months'));
  }
  if (duration.weeks !== 0) {
    parts.push(numberFormatter.format(duration.weeks) + ' ' + (duration.weeks === 1 ? 'week' : 'weeks'));
  }
  if (duration.days !== 0) {
    parts.push(numberFormatter.format(duration.days) + ' ' + (duration.days === 1 ? 'day' : 'days'));
  }
  if (duration.hours !== 0) {
    parts.push(numberFormatter.format(duration.hours) + ' ' + (duration.hours === 1 ? 'hour' : 'hours'));
  }
  if (duration.minutes !== 0) {
    parts.push(numberFormatter.format(duration.minutes) + ' ' + (duration.minutes === 1 ? 'minute' : 'minutes'));
  }
  if (duration.seconds !== 0) {
    // Round seconds for display if they have fractional parts
    const roundedSeconds = numberFormatter.format(duration.seconds.toFixed(0)); // Or toFixed(1) for one decimal
    parts.push(roundedSeconds + ' ' + (duration.seconds === 1 ? 'second' : 'seconds'));
  }

  if (parts.length === 0) {
    // Handle cases where the duration is zero or very small (e.g., nanoseconds only)
    if (duration.milliseconds !== 0 || duration.microseconds !== 0 || duration.nanoseconds !== 0) {
        const totalMs = duration.milliseconds + duration.microseconds / 1000 + duration.nanoseconds / 1_000_000;
        return numberFormatter.format(totalMs.toFixed(2)) + ' milliseconds';
    }
    return '0 seconds';
  }

  // Join parts with comma and 'and' for the last part (basic English joining)
  if (parts.length > 1) {
    const lastPart = parts.pop();
    return parts.join(', ') + ' and ' + lastPart;
  } else {
    return parts[0];
  }
}

const tripDuration = Temporal.Duration.from({ days: 3, hours: 10, minutes: 45 });
console.log(formatDurationToHumanReadable(tripDuration, 'en-US')); // 3 days, 10 hours and 45 minutes
console.log(formatDurationToHumanReadable(tripDuration, 'es-ES')); // 3 días, 10 horas y 45 minutos (example of Intl.NumberFormat)

const meetingReminder = Temporal.Duration.from({ minutes: 5 });
console.log(formatDurationToHumanReadable(meetingReminder, 'en-GB')); // 5 minutes

const microDuration = Temporal.Duration.from({ nanoseconds: 1234567 });
console.log(formatDurationToHumanReadable(microDuration, 'en-US')); // 1.23 milliseconds

            

              
                Copy
              
            
          

För mer avancerad pluralisering och lokaliserad listformatering kan du kombinera detta med Intl.RelativeTimeFormat eller mer komplexa bibliotek för strängmallar. Nyckeln är att separera beräkningen av varaktigheten (hanteras av Temporal) från dess presentation (hanteras av din formateringslogik och Intl).

Använda Intl.DurationFormat (framtid/förslag)

Det finns ett pågående TC39-förslag för Intl.DurationFormat, som syftar till att erbjuda ett inbyggt, språkanpassat sätt att formatera varaktigheter. Om det standardiseras och implementeras skulle det avsevärt förenkla den manuella formateringen som visas ovan, och erbjuda en robust lösning för internationalisering direkt inom JavaScript-ekosystemet.

Det skulle troligen fungera på liknande sätt som andra Intl-objekt:

            // This is hypothetical and based on the proposal's current state
// Check browser compatibility before using in production

/*
const duration = Temporal.Duration.from({ days: 1, hours: 2, minutes: 30 });

const formatter = new Intl.DurationFormat('en-US', {
  style: 'long',
  years: 'long',
  days: 'long',
  hours: 'long',
  minutes: 'long',
});

console.log(formatter.format(duration)); // "1 day, 2 hours, 30 minutes"

const shortFormatter = new Intl.DurationFormat('fr-FR', { style: 'short', hours: 'numeric', minutes: 'numeric' });
console.log(shortFormatter.format(duration)); // "1 j, 2 h, 30 min"
*/

            

              
                Copy
              
            
          

Även om det ännu inte är tillgängligt i alla miljöer, håll ett öga på detta förslag eftersom det lovar att bli den definitiva lösningen för global formatering av varaktigheter i framtiden.

Praktiska användningsfall och globala överväganden

Temporal.Duration är inte bara en akademisk förbättring; det löser verkliga problem i applikationer som verkar över olika tidszoner och kulturer.

1. Schemaläggning och evenemangshantering

För plattformar som hanterar internationella evenemang, konferenser eller möten är det avgörande att beräkna evenemangets varaktighet, tid kvar till ett evenemang eller hur länge en paus varar. Temporal.Duration säkerställer att dessa beräkningar är korrekta oavsett användarens plats eller lokala tidszonsregler.

            // Calculate remaining time for a global webinar
const now = Temporal.ZonedDateTime.from('2024-07-25T10:00:00[Europe/London]'); // Example current time
const webinarStart = Temporal.ZonedDateTime.from('2024-07-26T14:30:00[Asia/Tokyo]');

const timeUntilWebinar = now.until(webinarStart, {
  largestUnit: 'hour',
  smallestUnit: 'minute',
  roundingMode: 'ceil' // Round up to ensure users don't miss it
});

console.log(`Webinar starts in ${timeUntilWebinar.hours} hours and ${timeUntilWebinar.minutes} minutes.`);
// Output will be accurate based on actual time elapsed between these two ZonedDateTimes.

            

              
                Copy
              
            
          

2. Prestandamätning och loggning

Att mäta exekveringstiden för operationer, API-svarstider eller varaktigheten av batchjobb kräver hög precision. Temporal.Duration, särskilt i kombination med Temporal.Instant (som erbjuder nanosekundprecision), är idealiskt för detta.

            const startTime = Temporal.Instant.now();

// Simulate a complex operation
for (let i = 0; i < 1_000_000; i++) { Math.sqrt(i); }

const endTime = Temporal.Instant.now();

const executionDuration = startTime.until(endTime);

// Format to seconds with milliseconds for display
const formattedExecution = executionDuration.round({ smallestUnit: 'millisecond', largestUnit: 'second' });

console.log(`Operation took ${formattedExecution.seconds}.${String(formattedExecution.milliseconds).padStart(3, '0')} seconds.`);

            

              
                Copy
              
            
          

3. Finansiella beräkningar

Inom finans är exakta tidsintervall av yttersta vikt för att beräkna ränta, lånevillkor eller investeringsperioder. Det exakta antalet dagar, månader eller år i en period måste vara korrekt, särskilt när man hanterar skottår eller specifika månadslängder.

            const loanStartDate = Temporal.PlainDate.from('2023-04-01');
const loanEndDate = Temporal.PlainDate.from('2028-03-31');

const loanTerm = loanStartDate.until(loanEndDate, { largestUnit: 'year', smallestUnit: 'month' });
console.log(`Loan term: ${loanTerm.years} years and ${loanTerm.months} months.`); // 4 years and 11 months

            

              
                Copy
              
            
          

4. Internationaliseringsutmaningar på nytt

• Tidszoner och sommartid: Temporal.Duration i sig är tidszonsagnostiskt; det representerar en fast tidslängd. Men när du adderar eller subtraherar en Duration till/från en ZonedDateTime, tillämpar Temporal korrekt tidszonsregler, inklusive övergångar till sommartid. Detta säkerställer att en "24-timmars varaktighet" verkligen flyttar fram en ZonedDateTime med 24 faktiska timmar, även om det innebär att korsa en sommartidsgräns som gör *klockdagens* längd kortare eller längre. Denna konsekvens är en stor vinst över `Date`.
• Kulturella variationer: Olika kulturer uttrycker varaktigheter olika. Medan Temporal.Duration tillhandahåller de råa komponenterna (år, månader, dagar, etc.), är det ditt ansvar att använda `Intl`-API:er eller anpassad logik för att presentera dessa på ett sätt som resonerar med användarens språk och kultur. Till exempel kan vissa kulturer uttrycka "1 timme och 30 minuter" som "90 minuter" eller använda olika pluraliseringsregler.
• Kalendersystem: Temporal stöder också olika kalendersystem (t.ex. japanska, persiska, islamiska kalendrar). Även om Duration i sig är kalender-agnostiskt, respekterar aritmetiken den specifika kalenderns regler (t.ex. antal dagar i en månad, skottårsregler inom den kalendern) när den interagerar med kalendermedvetna typer som PlainDate eller ZonedDateTime. Detta är avgörande för globala applikationer som kan behöva visa datum i icke-gregorianska kalendrar.

Temporals nuvarande status och anammande

I slutet av 2023/början av 2024 är JavaScript Temporal API ett Steg 3 TC39-förslag. Detta innebär att specifikationen är i stort sett stabil, och den genomgår implementering och testning i olika JavaScript-motorer och webbläsare. Stora webbläsare som Chrome, Firefox och Safari arbetar aktivt med att implementera Temporal, med experimentella flaggor eller tidiga versioner redan tillgängliga.

Även om det ännu inte är universellt tillgängligt utan en polyfill, indikerar dess avancerade stadium att det är mycket troligt att det blir en standarddel av JavaScript. Utvecklare kan börja experimentera med Temporal idag genom att använda polyfills eller genom att aktivera experimentella funktioner i sina utvecklingsmiljöer i webbläsaren. Tidigt anammande låter dig ligga steget före, förstå dess fördelar och integrera det i dina projekt allt eftersom webbläsarstödet rullas ut.

Dess slutliga utbredda anammande kommer att avsevärt minska behovet av externa datum/tid-bibliotek och erbjuda en robust, inbyggd lösning för tidshantering i JavaScript.

Bästa praxis för att använda Temporal Duration

För att maximera fördelarna med Temporal.Duration i dina applikationer, överväg dessa bästa praxis:

• Föredra Temporal.Duration.from(): När du skapar varaktigheter från kända komponenter eller ISO-strängar är Temporal.Duration.from() med en objektliteral ofta mer läsbar och mindre felbenägen än konstruktorns positionella argument.
• Använd relativeTo för tvetydiga jämförelser: Ange alltid ett relativeTo-alternativ när du jämför eller avrundar varaktigheter som innehåller år, månader eller veckor. Detta säkerställer korrekta beräkningar genom att ge den nödvändiga kalenderkontexten.
• Utnyttja until() och since(): För att beräkna intervallet mellan två specifika tidpunkter, föredra metoderna until() och since() på Temporal-datum/tidsobjekt. De hanterar komplexiteten med tidszoner och sommartid korrekt.
• Normalisera och avrunda för visning: Innan du presenterar varaktigheter för användare, överväg att använda normalize() och särskilt round() för att konvertera varaktigheten till de mest lämpliga och förståeliga enheterna (t.ex. konvertera 90 minuter till "1 timme och 30 minuter").
• Separera intern representation från visning: Håll dina interna varaktighetsberäkningar exakta med Temporal.Duration. Omvandla och formatera endast för visning när du renderar användargränssnittet, med hjälp av anpassade formateringsfunktioner och Intl-API:et för global noggrannhet.
• Håll dig uppdaterad: Håll ett öga på Temporal API:s framsteg och webbläsarkompatibilitet. Allt eftersom det rör sig mot full standardisering kommer ekosystemet att utvecklas, och nya verktyg eller bästa praxis kan dyka upp.
• Var medveten om precision: Även om Temporal stöder nanosekundprecision, använd endast den precision du verkligen behöver. Högre precision kan ibland göra felsökning svårare eller resultera i oväntad avrundning vid konvertering till displayer med lägre precision.

Slutsats

Introduktionen av Temporal.Duration markerar ett betydande steg framåt för JavaScript-utvecklare som kämpar med tidsintervallaritmetik. Genom att tillhandahålla ett oföränderligt, explicit och globalt medvetet API, adresserar Temporal de långvariga begränsningarna hos det äldre Date-objektet.

Du kan nu med självförtroende utföra komplexa tidsberäkningar, mäta perioder noggrant och presentera varaktigheter på ett sätt som är både exakt och kulturellt lämpligt för användare över hela världen. Oavsett om du beräknar varaktigheten av en mjukvaru-releasecykel, den återstående tiden till en global produktlansering eller en persons exakta ålder, erbjuder Temporal.Duration de verktyg du behöver för att bygga robusta och pålitliga applikationer.

Omfamna Temporal.Duration och förvandla hur du hanterar tid i dina JavaScript-projekt. Framtiden för datum- och tidshantering i JavaScript är här, och den lovar en mer förutsägbar, kraftfull och globalt kompatibel utvecklingsupplevelse.