JavaScript Temporali Durationi valdamine: põhjalik juhend ajaintervallide arvutamiseks

JavaScripti Temporal API on märkimisväärne edasiminek kuupäevade ja kellaaegade käsitlemisel. Üks selle põhikomponente on Duration-objekt, mis on loodud spetsiaalselt ajaintervallide esitamiseks. Erinevalt traditsioonilisest Date-objektist, mis kannatab muutlikkuse ja ajavööndite keerukuse all, pakub Duration puhtamat, täpsemat ja rahvusvaheliselt teadlikumat viisi ajavahemikega töötamiseks. See põhjalik juhend uurib Duration-objekti üksikasjalikult, alates põhitõdedest kuni keerukate stsenaariumideni.

Mis on Temporal Duration?

Temporal.Duration esindab ajavahemikku, mis on sõltumatu mis tahes konkreetsest kalendrisüsteemist või ajavööndist. See keskendub ainult aja kogusele, mida väljendatakse aastates, kuudes, päevades, tundides, minutites, sekundites ja sekundi murdosades. Mõelge sellest kui "5 aastat, 3 kuud ja 2 päeva", mitte kui "1. jaanuarist 2023 kuni 3. märtsini 2028".

See eristus on ülioluline, sest kestused on oma olemuselt suhtelised. Kestuse lisamine konkreetsele kuupäevale annab alati uue kuupäeva, kuid täpne tulemus sõltub kalendrisüsteemist ja alguskuupäevast. Näiteks ühe kuu lisamine 31. jaanuarile annab erinevaid kuupäevi sõltuvalt sellest, kas tegemist on liigaastaga.

Duration-objektide loomine

On mitmeid viise Temporal.Duration-objektide loomiseks:

1. Komponentidest

Kõige otsesem viis on kasutada meetodit Temporal.Duration.from objektiga, mis sisaldab soovitud komponente:

            const duration1 = Temporal.Duration.from({ years: 1, months: 6, days: 15 });
console.log(duration1.toString()); // Väljund: P1Y6M15D

const duration2 = Temporal.Duration.from({ hours: 8, minutes: 30, seconds: 12, milliseconds: 500 });
console.log(duration2.toString()); // Väljund: PT8H30M12.5S

const duration3 = Temporal.Duration.from({ years: 2, days: -5, seconds: 30 });
console.log(duration3.toString()); // Väljund: P2YT-5S30S

            

              
                Copy
              
            
          

Pange tähele, et saate kasutada negatiivseid väärtusi, et esitada kestusi, mis liiguvad ajas tagasi.

2. ISO 8601 stringist

Meetod Temporal.Duration.from aktsepteerib ka ISO 8601 kestuse stringi:

            const duration4 = Temporal.Duration.from('P3Y2M10DT5H30M');
console.log(duration4.toString()); // Väljund: P3Y2M10DT5H30M

const duration5 = Temporal.Duration.from('PT1H15M30S');
console.log(duration5.toString()); // Väljund: PT1H15M30S

const duration6 = Temporal.Duration.from('P-1Y');
console.log(duration6.toString()); // Väljund: P-1Y

            

              
                Copy
              
            
          

ISO 8601 kestuse formaat on P[aastad]Y[kuud]M[päevad]D[T[tunnid]H[minutid]M[sekundid]S]. 'P' tähistab perioodi (kestust) ja 'T' eraldab kuupäeva ja kellaaja komponente.

3. Konstruktori kasutamine

Saate kasutada ka otse Temporal.Duration konstruktorit:

            const duration7 = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8);
console.log(duration7.toString()); // Väljund: P1Y2M3W4DT5H6M7S8ms

            

              
                Copy
              
            
          

Konstruktori argumendid on järgmises järjekorras: aastad, kuud, nädalad, päevad, tunnid, minutid, sekundid, millisekundid, mikrosekundid, nanosekundid.

Durationi omadused

Kui teil on Duration-objekt, saate selle komponentidele juurde pääseda selle omaduste kaudu:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S');

console.log(duration.years);       // Väljund: 1
console.log(duration.months);      // Väljund: 2
console.log(duration.days);        // Väljund: 3
console.log(duration.hours);       // Väljund: 4
console.log(duration.minutes);     // Väljund: 5
console.log(duration.seconds);     // Väljund: 6
console.log(duration.milliseconds);  // Väljund: 0
console.log(duration.microseconds);  // Väljund: 0
console.log(duration.nanoseconds);   // Väljund: 0

            

              
                Copy
              
            
          

Kestuse aritmeetika

Duration-objekt pakub meetodeid aritmeetiliste tehete sooritamiseks:

1. Kestuste liitmine

Kasutage meetodit add, et liita kaks kestust kokku:

            const duration1 = Temporal.Duration.from('P1Y2M');
const duration2 = Temporal.Duration.from('P3M4D');

const sum = duration1.add(duration2);
console.log(sum.toString()); // Väljund: P1Y5M4D

            

              
                Copy
              
            
          

2. Kestuste lahutamine

Kasutage meetodit subtract, et lahutada üks kestus teisest:

            const duration1 = Temporal.Duration.from('P1Y2M');
const duration2 = Temporal.Duration.from('P3M4D');

const difference = duration1.subtract(duration2);
console.log(difference.toString()); // Väljund: PPT11M-4D

            

              
                Copy
              
            
          

3. Kestuse eitamine

Kasutage meetodit negated, et pöörata kestuse kõigi komponentide märk vastupidiseks:

            const duration = Temporal.Duration.from('P1Y2M-3D');
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Väljund: P-1YT-2M3D

            

              
                Copy
              
            
          

4. Kestuse absoluutväärtus

Kasutage meetodit abs, et saada kestus, mille kõik komponendid on positiivsed:

            const duration = Temporal.Duration.from('P-1YT2M-3D');
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Väljund: P1YT2M3D

            

              
                Copy
              
            
          

5. Kestuse korrutamine

Kasutage meetodit multiply, et korrutada kestust arvuga:

            const duration = Temporal.Duration.from('PT1H30M');
const multipliedDuration = duration.multiply(2.5);
console.log(multipliedDuration.toString()); // Väljund: PT3H45M

            

              
                Copy
              
            
          

6. Kestuse ümardamine

Kasutage meetodit round, et ümardada kestus kindla ühikuni. See nõuab valiku relativeTo määramist, mis võib olla Temporal.PlainDateTime või Temporal.ZonedDateTime, sest mõned ühikud (nagu kuud ja aastad) on muutuva pikkusega.

            const duration = Temporal.Duration.from('P1DT12H30M');
const relativeTo = Temporal.PlainDateTime.from('2024-01-01T00:00:00');

const roundedDuration = duration.round({ smallestUnit: 'days', relativeTo });
console.log(roundedDuration.toString()); // Väljund: P2D

            

              
                Copy
              
            
          

Selles näites ümardatakse 1 päev ja 12 tundi 2 päevaks.

Kestuste võrdlemine

Saate võrrelda kahte kestust, kasutades meetodit compare. Siiski pidage meeles, et segaühikutega kestusi (nt aastad ja päevad) ei saa usaldusväärselt võrrelda ilma suhtelise kontekstita (konkreetne kuupäev ja kalender). Funktsioon compare tagastab:

• -1 kui kestus1 on väiksem kui kestus2
• 0 kui kestus1 on võrdne kestusega2
• 1 kui kestus1 on suurem kui kestus2

            const duration1 = Temporal.Duration.from('PT1H');
const duration2 = Temporal.Duration.from('PT30M');

console.log(Temporal.Duration.compare(duration1, duration2)); // Väljund: 1
console.log(Temporal.Duration.compare(duration2, duration1)); // Väljund: -1
console.log(Temporal.Duration.compare(duration1, Temporal.Duration.from('PT1H'))); // Väljund: 0

const duration3 = Temporal.Duration.from('P1M');
const duration4 = Temporal.Duration.from('P30D');

// duration3 ja duration4 otse võrdlemine viskab paljudes mootorites vea
// kui 'relativeTo' pole määratud, kuna kuu pikkus ei ole konstantne.

            

              
                Copy
              
            
          

Praktilised näited ja kasutusjuhud

Temporal.Duration-objekt on uskumatult mitmekülgne ja seda saab kasutada paljudes rakendustes:

1. Projekti kestuse arvutamine

Kujutage ette, et haldate projekti, millel on algus- ja lõppkuupäev. Saate kasutada Temporal.PlainDate ja Temporal.Duration, et arvutada projekti kestus:

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

const duration = endDate.since(startDate);
console.log(duration.toString()); // Väljund: P1M5D

            

              
                Copy
              
            
          

2. Korduvate sündmuste planeerimine

Saate kasutada Temporal.Duration, et määratleda korduvate sündmuste sagedust, näiteks iganädalasi koosolekuid või igakuiseid aruandeid:

            const eventFrequency = Temporal.Duration.from({ weeks: 1 });
let nextEventDate = Temporal.PlainDate.from('2024-01-22');

for (let i = 0; i < 5; i++) {
  console.log(`Event ${i + 1}: ${nextEventDate.toString()}`);
  nextEventDate = nextEventDate.add(eventFrequency);
}

// Väljund:
// Event 1: 2024-01-22
// Event 2: 2024-01-29
// Event 3: 2024-02-05
// Event 4: 2024-02-12
// Event 5: 2024-02-19

            

              
                Copy
              
            
          

3. Vanuse arvutamine

Kuigi vanuse täpne arvutamine nõuab liigaastate ja erinevate kalendrisüsteemide käsitlemist, saab Temporal.Duration anda hea ligikaudse tulemuse:

            const birthDate = Temporal.PlainDate.from('1990-05-10');
const today = Temporal.PlainDate.from('2024-02-15');

const ageDuration = today.since(birthDate);

console.log(`Ligikaudne vanus: ${ageDuration.years} aastat, ${ageDuration.months} kuud, ${ageDuration.days} päeva`);

            

              
                Copy
              
            
          

4. Ajavöönditeadlikud arvutused: lennukestused

Globaalsete rakenduste puhul on ajavööndite käsitlemine ülioluline. Mõelgem näiteks lennukestuste arvutamisele erinevate ajavööndite vahel:

            const departureZonedDateTime = Temporal.ZonedDateTime.from('2024-03-15T10:00:00[America/Los_Angeles]');
const arrivalZonedDateTime = Temporal.ZonedDateTime.from('2024-03-16T14:30:00[Europe/London]');

const flightDuration = arrivalZonedDateTime.since(departureZonedDateTime);

console.log(`Lennu kestus: ${flightDuration.hours} tundi, ${flightDuration.minutes} minutit`);
console.log(flightDuration.toString());

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas Temporal.ZonedDateTime, kui seda kombineerida meetodiga .since(), kohandub automaatselt ajavööndite erinevustega, pakkudes täpset lennukestust.

5. Teenusetaseme lepingute (SLA) jälgimine

Paljud veebiteenused lubavad tööaja garantiisid. Saate kasutada `Temporal.Duration` nende lepingute määratlemiseks ja jälgimiseks.

            const slaGuarantee = Temporal.Duration.from('PT99H59M59S'); // Peaaegu 100 tundi
const downtime = Temporal.Duration.from('PT1H');

if (downtime.compare(slaGuarantee) > 0) {
  console.log("SLA-d on rikutud!");
} else {
  console.log("SLA on täidetud.");
}

            

              
                Copy
              
            
          

Täpsemad kaalutlused

1. Kuude ja aastate mitmetähenduslikkus

Nagu varem mainitud, võib kuude ja aastate pikkus varieeruda. Nende ühikutega arvutusi tehes on sageli vaja pakkuda suhtelist konteksti, kasutades Temporal.PlainDateTime või Temporal.ZonedDateTime. See on eriti oluline kestuste ümardamisel või võrdlemisel.

2. Kalendrisüsteemid

Temporal API toetab erinevaid kalendrisüsteeme. Vaikimisi kasutab see ISO 8601 kalendrit, mis on kõige laialdasemalt kasutatav. Siiski saate Temporal.PlainDate või Temporal.ZonedDateTime objekte luues määrata ka teisi kalendrisüsteeme. Kestused jäävad kalendrist sõltumatuks; need esindavad aja hulka.

3. Ajavööndite andmebaasi uuendused

Ajavööndireeglid võivad aja jooksul muutuda poliitilistel või geograafilistel põhjustel. Täpsete arvutuste tagamiseks on ülioluline hoida oma ajavööndite andmebaas ajakohasena, eriti kui tegelete Temporal.ZonedDateTime-ga. Kaasaegsed JavaScripti käituskeskkonnad tegelevad sellega tavaliselt automaatselt, kuid mõnes keskkonnas peate võib-olla andmebaasi käsitsi uuendama.

Parimad praktikad

• Kasutage ISO 8601 kestuse stringe serialiseerimiseks ja andmevahetuseks. See tagab koostalitlusvõime ja väldib mitmetähenduslikkust.
• Eelistage ajaintervallide esitamiseks Temporal.Duration-it, selle asemel et arvutada otse kahe Date-objekti vahe. See viib puhtama ja paremini hooldatava koodini.
• Olge teadlik kuude ja aastate mitmetähenduslikkusest ning pakkuge alati vajadusel suhtelist konteksti.
• Kasutage ajavöönditeadlike arvutuste jaoks Temporal.ZonedDateTime-i.
• Hoidke oma ajavööndite andmebaas ajakohasena.
• Segaühikutega kestusi võrreldes kasutage täpse võrdluse tagamiseks alati round-meetodit koos suhtelise kontekstiga.

Kokkuvõte

Temporal.Duration-objekt pakub võimsat ja intuitiivset viisi JavaScriptis ajaintervallidega töötamiseks. Selle omadusi, meetodeid ja parimaid praktikaid mõistes saate kirjutada robustsemat, täpsemat ja rahvusvaheliselt teadlikumat koodi. Temporal API ja eriti Duration-objekt on märkimisväärne samm edasi JavaScripti kuupäevade ja kellaaegade käsitlemisel, muutes ajaga seotud arvutuste lihtsustamise abil rakenduste loomise täpsemaks ja globaalselt asjakohasemaks. Võtke Temporal API omaks ja avage selle potentsiaal oma ajaga seotud arvutuste lihtsustamiseks.

Kuna Temporal API areneb pidevalt, olge kursis uute funktsioonide ja uuendustega. Ametlik ECMAScripti ettepanek ja sellega seotud dokumentatsioon on suurepärased ressursid ajakohasena püsimiseks.