JavaScripti Temporal Duration: Ajaintervallide Aritmeetika Meistriklass

JavaScripti Temporal API muudab revolutsiooniliselt seda, kuidas me kuupäevi ja aegu käsitleme. Selle südames on Temporal.Duration objekt, võimas tööriist ajaintervallide esitamiseks ja manipuleerimiseks. See põhjalik juhend süveneb Temporal.Duration'i keerukustesse, andes teile teadmised, et sooritada keerulisi temporaalseid aritmeetilisi tehteid lihtsalt ja täpselt.

Mis on Temporal.Duration?

Temporal.Duration esindab ajavahemikku, mis on väljendatud aastates, kuudes, päevades, tundides, minutites, sekundites ja nanosekundites. Erinevalt Date'ist, mis esindab kindlat ajahetke, kirjeldab Duration suhtelist ajahulka. See muudab selle ideaalseks arvutuste jaoks, mis hõlmavad ajavahesid, niheteid ja korduvaid sündmusi.

Mõelge sellest kui aja retseptist. See ütleb teile, kui palju igast ajaühikust antud alguspunktile lisada või sellest lahutada. Näiteks saab kestust "1 aasta, 2 kuud ja 3 päeva" kasutada kuupäeva arvutamiseks, mis on 1 aasta, 2 kuud ja 3 päeva pärast kindlat kuupäeva.

Temporal.Duration Objektide Loomine

Temporal.Duration objekti loomiseks on mitu viisi:

1. Objekti literaalist

Kõige otsekohesem lähenemine on kasutada objekti literaali, millel on omadused iga ajaühiku jaoks:

            const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7); // 1 aasta, 2 kuud, 3 päeva, 4 tundi, 5 minutit, 6 sekundit, 7 nanosekundit
console.log(duration.toString()); // 'P1Y2M3DT4H5M6.000000007S'
            

              
                Copy
              
            
          

Võite ära jätta omadused, mille väärtus on null. Näiteks:

            const duration = new Temporal.Duration(0, 0, 7); // 7 päeva
console.log(duration.toString()); // 'P7D'
            

              
                Copy
              
            
          

2. ISO 8601 stringist

Temporal.Duration'i saab luua ka ISO 8601 kestuse stringist:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S'); // 1 aasta, 2 kuud, 3 päeva, 4 tundi, 5 minutit, 6 sekundit
console.log(duration.toString()); // 'P1Y2M3DT4H5M6S'

const duration2 = Temporal.Duration.from('PT30M'); // 30 minutit
console.log(duration2.toString()); // 'PT30M'
            

              
                Copy
              
            
          

See meetod on eriti kasulik, kui tegelete andmetega välistest allikatest, mis kasutavad ISO 8601 vormingut. Stringi vorming järgib mustrit P[aastad]Y[kuud]M[päevad]D[T[tunnid]H[minutid]M[sekundid]S].

3. Teistest Temporaalsetest Tüüpidest

Saate arvutada kestuse kahe Temporal.Instant, Temporal.ZonedDateTime, Temporal.PlainDate või Temporal.PlainTime objekti vahel, kasutades meetodit until(). See on eriti kasulik kahe sündmuse vahel möödunud aja määramiseks.

            const start = Temporal.PlainDate.from('2023-01-01');
const end = Temporal.PlainDate.from('2023-03-15');
const duration = start.until(end);
console.log(duration.toString()); // 'P2M14D'
            

              
                Copy
              
            
          

Duration'i Omadustele Juurdepääs

Kui teil on Temporal.Duration objekt, saate selle omadustele juurde pääseda, et saada kätte üksikud ajakomponendid:

            const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7);

console.log(duration.years); // 1
console.log(duration.months); // 2
console.log(duration.days); // 3
console.log(duration.hours); // 4
console.log(duration.minutes); // 5
console.log(duration.seconds); // 6
console.log(duration.nanoseconds); // 7
            

              
                Copy
              
            
          

Need omadused on ainult lugemiseks, tagades, et Duration objekt jääb muutumatuks.

Temporal.Duration'i Aritmeetika

Üks Temporal.Duration'i peamisi tugevusi on selle võime sooritada aritmeetilisi tehteid. Saate liita, lahutada, korrutada ja jagada kestusi, muutes keerulised ajaarvutused oluliselt lihtsamaks.

1. Kestuste Liitmine

Kasutage meetodit add(), et liita kaks kestust kokku:

            const duration1 = new Temporal.Duration(1, 2, 3);
const duration2 = new Temporal.Duration(0, 0, 7);
const sum = duration1.add(duration2);
console.log(sum.toString()); // 'P1Y2M10D'
            

              
                Copy
              
            
          

2. Kestuste Lahutamine

Kasutage meetodit subtract(), et lahutada üks kestus teisest:

            const duration1 = new Temporal.Duration(1, 2, 3);
const duration2 = new Temporal.Duration(0, 0, 7);
const difference = duration1.subtract(duration2);
console.log(difference.toString()); // 'P1Y2M-4D'
            

              
                Copy
              
            
          

Pange tähele, et suurema kestuse lahutamine väiksemast võib mõnede omaduste puhul anda negatiivseid väärtusi.

3. Kestuste Korrutamine

Kasutage meetodit multiply(), et korrutada kestust skalaarväärtusega:

            const duration = new Temporal.Duration(1, 0, 0);
const doubled = duration.multiply(2);
console.log(doubled.toString()); // 'P2Y'
            

              
                Copy
              
            
          

See on kasulik kestuste skaleerimiseks, et esindada näiteks teatud sündmuse kahekordset pikkust.

4. Kestuste Muutmine

Kasutage meetodit negated() või abs(), et muuta kestust:

            const duration = new Temporal.Duration(1, 0, 0);
const negated = duration.negated();
console.log(negated.toString()); // 'P-1Y'

const durationNegative = new Temporal.Duration(-1, 0, 0);
const absoluteValue = durationNegative.abs();
console.log(absoluteValue.toString()); // 'P1Y'

            

              
                Copy
              
            
          

Kestuste Normaliseerimine

Kestused võivad mõnikord olla normaliseerimata olekus, mis tähendab, et need sisaldavad komponente, mida saaks väljendada suuremates ühikutes. Näiteks kestuse "1 aasta ja 12 kuud" saaks normaliseerida "2 aastaks".

Kestuse normaliseerimiseks saate kasutada meetodeid toPlainDays(), toPlainHours(), toPlainMinutes(), toPlainSeconds() või toPlainNanoseconds() koos teise Temporal tüübiga, näiteks Temporal.PlainDate. Normaliseerimine nõuab konteksti, et õigesti arvesse võtta erineva pikkusega kuid ja liigaastaid.

            const plainDate = Temporal.PlainDate.from('2024-01-01'); // Näidis alguskuupäev
const duration = new Temporal.Duration(0, 13, 0); // 13 kuud

// Normaliseerimine kuupäeva kontekstis
const normalizedDate = plainDate.add(duration);

// Kestuse arvutamine algkuupäevast normaliseeritud kuupäevani
const normalizedDuration = plainDate.until(normalizedDate);
console.log(normalizedDuration.toString()); // Väljund: 'P1Y1M'
            

              
                Copy
              
            
          

Selles näites annab 13 kuu pikkuse kestuse lisamine 1. jaanuarile 2024 tulemuseks 1. veebruari 2025. Seejärel arvutab meetod until() kestuse algkuupäeva ja tulemuseks saadud kuupäeva vahel, andes meile normaliseeritud kestuseks 1 aasta ja 1 kuu.

Töötamine Erinevate Temporaalsete Tüüpidega

Temporal.Duration on loodud sujuvaks koostööks teiste Temporaalsete tüüpidega, nagu Temporal.Instant, Temporal.ZonedDateTime, Temporal.PlainDate ja Temporal.PlainTime. See võimaldab teil sooritada keerulisi temporaalseid arvutusi, mis hõlmavad konkreetseid ajahetki ja kuupäevi.

1. Kestuste Lisamine Temporal.PlainDate'ile

Saate lisada Duration'i Temporal.PlainDate'ile, et arvutada tulevane kuupäev:

            const startDate = Temporal.PlainDate.from('2023-01-01');
const duration = new Temporal.Duration(1, 0, 0); // 1 aasta
const futureDate = startDate.add(duration);
console.log(futureDate.toString()); // '2024-01-01'
            

              
                Copy
              
            
          

2. Kestuste Lahutamine Temporal.ZonedDateTime'ist

Sarnaselt saate lahutada Duration'i Temporal.ZonedDateTime'ist, et arvutada möödunud kuupäev ja kellaaeg:

            const startDateTime = Temporal.ZonedDateTime.from('2023-01-01T12:00:00+00:00[UTC]');
const duration = new Temporal.Duration(0, 0, 0, 6); // 6 tundi
const pastDateTime = startDateTime.subtract(duration);
console.log(pastDateTime.toString()); // '2023-01-01T06:00:00+00:00[UTC]'
            

              
                Copy
              
            
          

Praktilised Näited ja Kasutusjuhud

Temporal.Duration on mitmekülgne tööriist, millel on arvukalt praktilisi rakendusi. Siin on mõned näited:

1. Vanuse Arvutamine

Saate kasutada Temporal.Duration'i, et arvutada inimese vanus tema sünnikuupäeva alusel:

            const birthDate = Temporal.PlainDate.from('1990-05-15');
const today = Temporal.Now.plainDateISO();
const ageDuration = birthDate.until(today);

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

              
                Copy
              
            
          

2. Korduvate Sündmuste Planeerimine

Temporal.Duration on ideaalne korduvate sündmuste, näiteks iganädalaste koosolekute või igakuiste aruannete planeerimiseks. Saate seda kasutada sündmuse järgmise toimumisaja arvutamiseks selle kordumisintervalli alusel.

3. Ajavahede Arvutamine Reisi Planeerimiseks

Rahvusvahelise reisi planeerimisel saate kasutada Temporal.Duration'i kahe asukoha vahelise ajavahe arvutamiseks:

            const departureTime = Temporal.ZonedDateTime.from('2023-03-01T10:00:00+01:00[Europe/Paris]');
const arrivalTime = Temporal.ZonedDateTime.from('2023-03-01T14:00:00-08:00[America/Los_Angeles]');
const flightDuration = departureTime.until(arrivalTime);

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

              
                Copy
              
            
          

4. Taimerite Rakendamine

Looge taimereid eriliste sündmuste, tooteesitluste või tähtaegade jaoks, kuvades dünaamiliselt järelejäänud aega.

5. Jõudlusnäitajate Mõõtmine

Salvestage kriitiliste koodilõikude täitmise kestus, et tuvastada jõudluse kitsaskohad ja optimeerida koodi.

Rahvusvahelistamise Kaalutlused

Globaalses kontekstis kuupäevade ja aegadega töötades on oluline arvestada rahvusvahelistamisega. Temporal API pakub mitmeid funktsioone, mis aitavad teil käsitleda erinevaid ajavööndeid, kalendreid ja lokaate.

1. Ajavööndid

Kasutage Temporal.ZonedDateTime'i, et töötada kuupäevade ja aegadega kindlates ajavööndites. See tagab, et teie arvutused on täpsed, olenemata kasutaja asukohast.

2. Kalendrid

Temporal API toetab erinevaid kalendreid, nagu Gregoriuse kalender, Islami kalender ja Jaapani kalender. Saate määrata kalendri Temporal.PlainDate või Temporal.ZonedDateTime objekti loomisel.

3. Lokaadid

Kasutage meetodit toLocaleString(), et vormindada kuupäevi ja aegu vastavalt kasutaja lokaadile. See tagab, et kuupäevad ja ajad kuvatakse kultuuriliselt sobival viisil.

            const date = Temporal.PlainDate.from('2023-03-15');

console.log(date.toLocaleString('en-US')); // '3/15/2023'
console.log(date.toLocaleString('fr-FR')); // '15/03/2023'
console.log(date.toLocaleString('ja-JP')); // '2023/03/15'
            

              
                Copy
              
            
          

Parimad Praktikad Temporal.Duration'iga Töötamisel

Et tagada oma koodi robustsus ja hooldatavus, järgige neid parimaid praktikaid Temporal.Duration'iga töötamisel:

• Kasutage Temporal API-d järjepidevalt: Vältige Temporal API segamist vananenud Date objektiga, kuna see võib põhjustada ebajärjekindlust ja vigu.
• Käsitlege ajavööndeid hoolikalt: Määrake alati ajavöönd, kui töötate kuupäevade ja aegadega, mis on seotud kindla asukohaga.
• Valideerige kasutaja sisendit: Valideerige kasutaja sisendit, et tagada selle õige vorming ja oodatud vahemik.
• Testige oma koodi põhjalikult: Testige oma koodi erinevate ajavööndite, kalendrite ja lokaatidega, et tagada selle korrektne toimimine kõikides stsenaariumides.
• Dokumenteerige oma kood: Dokumenteerige oma kood selgelt ja lühidalt, selgitades iga funktsiooni eesmärki ja selle tehtud eeldusi.

Levinud Lõksud ja Kuidas Neid Vältida

Kuigi Temporal API lihtsustab kuupäevade ja aegade käsitlemist, võivad teatud lõksud viia ootamatute tulemusteni. Nende levinud probleemide teadmine ja nende vältimine on usaldusväärse koodi kirjutamisel ülioluline.

1. Vale Kestuse Stringi Vorming

Veenduge, et kestuse string vastaks rangelt ISO 8601 vormingule. Isegi väike kõrvalekalle võib põhjustada parsimisvigu või valesid arvutusi.

            // Vale: Puudub 'T' ajakomponentide jaoks
// Temporal.Duration.from('P1D2H3M'); // See võib visata vea või anda ootamatuid tulemusi

// Õige: Korrektne ISO 8601 vorming
const duration = Temporal.Duration.from('P1DT2H3M');
console.log(duration.toString()); // Väljund: 'P1DT2H3M'
            

              
                Copy
              
            
          

2. Liigaastate ja Suveaja Ignoreerimine

Liigaastad ja suveaeg (DST) võivad oluliselt mõjutada kestuse arvutusi, eriti pikkade ajavahemike puhul. Kasutage alati sobivaid Temporaalseid tüüpe ja meetodeid nende anomaaliate arvessevõtmiseks.

            // Näide suveajaga
const plainDateTime = Temporal.PlainDate.from('2023-03-12'); // Suveajale ülemineku päev USAs
const duration1Day = Temporal.Duration.from('P1D');
const nextDay = plainDateTime.add(duration1Day);

console.log(nextDay.toString()); // Kuupäev muutub korrektselt, arvestades suveajast tingitud ajamuutust
            

              
                Copy
              
            
          

3. Temporaalsete Tüüpide Sobimatu Segamine

Veenduge, et kasutate oma arvutustes õigeid Temporaalseid tüüpe. Näiteks vältige Temporal.PlainDate'i kasutamist operatsioonideks, mis nõuavad ajavööndi teadlikkust.

4. Valed Normaliseerimise Eeldused

Normaliseerige kestused alati kindlas kontekstis (nt suhtes Temporal.PlainDate'iga), et käsitleda mitmetähenduslikke ühikuid nagu kuud või aastad täpselt.

            // Vale: Eeldades, et kuu on alati 30 päeva
const duration = new Temporal.Duration(0, 1, 0); // 1 kuu
// const daysInMonth = duration.months * 30; // See ei ole täpne

// Õige: Kasutades Temporal.PlainDate'i, et määrata päevade arv konkreetses kuus
const startDate = Temporal.PlainDate.from('2023-02-01');
const endDate = startDate.add({ months: 1 });
const daysInMonth = startDate.until(endDate, { unit: 'days' }).days;
console.log(daysInMonth); // Väljund: 28 (veebruari 2023 kohta)
            

              
                Copy
              
            
          

Kokkuvõte

Temporal.Duration on võimas tööriist ajaintervallidega töötamiseks JavaScriptis. Mõistes selle omadusi, meetodeid ja parimaid praktikaid, saate sooritada keerulisi temporaalseid aritmeetilisi tehteid lihtsalt ja täpselt. Kuna Temporal API kogub laiemat kasutust, muutub Temporal.Duration'i valdamine oluliseks oskuseks igale JavaScripti arendajale. Olgu tegemist vanuste arvutamise, sündmuste planeerimise või rahvusvaheliste reiside kavandamisega, pakub Temporal.Duration tugeva ja usaldusväärse lahenduse kõikidele teie ajaga seotud vajadustele. Võtke Temporal API omaks ja avage oma JavaScripti koodis uus täpsuse ja selguse tase.

See juhend on käsitlenud Temporal.Duration'i põhiaspekte. Süvenedes Temporal API-sse, uurige selle täpsemaid funktsioone, nagu kohandatud kalendrid ja ajavööndi käsitlemine, et oma temporaalse programmeerimise oskusi veelgi parandada. Kõige ajakohasema teabe ja spetsifikatsioonide saamiseks konsulteerige alati ametliku ECMAScript Temporal dokumentatsiooniga.

Head kodeerimist!