JavaScript Temporal.Duration: Laika Intervālu Aprēķinu Apgūšana

JavaScript Temporal API ievieš modernu un jaudīgu veidu, kā apstrādāt datumus, laikus un laika intervālus. Temporal.Duration objekts attēlo laika ilgumu, nodrošinot skaidru un intuitīvu pieeju laika intervālu aprēķiniem. Šajā rakstā detalizēti aplūkots Temporal.Duration, demonstrējot, kā izveidot, manipulēt un formatēt ilgumus dažādiem lietošanas gadījumiem.

Kas ir Temporal.Duration?

Temporal.Duration attēlo laika posmu, izsakot to gados, mēnešos, dienās, stundās, minūtēs, sekundēs un sekundes daļās (milisekundēs, mikrosekundēs, nanosekundēs). Atšķirībā no Date objektiem, kas attēlo konkrētu laika punktu, Temporal.Duration attēlo laika daudzumu. Tas atbilst ISO 8601 ilguma formātam (piemēram, P1Y2M10DT2H30M nozīmē 1 gadu, 2 mēnešus, 10 dienas, 2 stundas un 30 minūtes). Temporal API ir izstrādāts, lai būtu intuitīvāks un mazāk pakļauts kļūdām nekā mantotais Date objekts.

Temporal.Duration Objektu Izveide

Ir vairāki veidi, kā izveidot Temporal.Duration objektus:

1. No vienkārša objekta

Jūs varat izveidot ilgumu, padodot objektu ar vēlamajām īpašībām:

const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // Rezultāts: P1Y2M10DT2H30M

Šis kods izveido ilgumu, kas ir 1 gads, 2 mēneši, 10 dienas, 2 stundas un 30 minūtes. Ņemiet vērā, ka argumenti atbilst šādai secībai: years (gadi), months (mēneši), weeks (nedēļas), days (dienas), hours (stundas), minutes (minūtes), seconds (sekundes), milliseconds (milisekundes), microseconds (mikrosekundes), nanoseconds (nanosekundes).

2. No ISO 8601 virknes

Jūs varat arī izveidot ilgumu no ISO 8601 ilguma virknes, izmantojot Temporal.Duration.from():

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.toString()); // Rezultāts: P1Y2M10DT2H30M

Tas ir īpaši noderīgi, strādājot ar ilgumiem, kas saglabāti virknes formātā vai saņemti no ārēja avota.

3. Izmantojot add() un subtract() metodes ar Temporal.Instant, Temporal.ZonedDateTime utt.

Kad jūs pieskaitāt vai atņemat Temporal.Duration no citiem Temporal tipiem (piemēram, Temporal.Instant vai Temporal.ZonedDateTime), tiek atgriezts Temporal.Duration, kas attēlo starpību starp diviem laika punktiem, ja jūs tos pēc tam atņemat. Piemēram:

const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ hours: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Rezultāts: PT5H

Piekļuve Ilguma Komponentiem

Jūs varat piekļūt atsevišķiem Temporal.Duration objekta komponentiem, izmantojot tā īpašības:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // Rezultāts: 1
console.log(duration.months);     // Rezultāts: 2
console.log(duration.days);       // Rezultāts: 10
console.log(duration.hours);      // Rezultāts: 2
console.log(duration.minutes);     // Rezultāts: 30
console.log(duration.seconds);     // Rezultāts: 0
console.log(duration.milliseconds); // Rezultāts: 0
console.log(duration.microseconds); // Rezultāts: 0
console.log(duration.nanoseconds);  // Rezultāts: 0

Aritmētikas Veikšana ar Ilgumiem

Temporal.Duration objekti atbalsta saskaitīšanu un atņemšanu, izmantojot add() un subtract() metodes. Šīs metodes atgriež jaunu Temporal.Duration objektu, kas attēlo operācijas rezultātu.

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

const addedDuration = duration1.add(duration2);
console.log(addedDuration.toString()); // Rezultāts: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // Rezultāts: P10M26D

Jūs varat arī savienot šīs metodes sarežģītākiem aprēķiniem:

const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // Rezultāts: P1DT11H30M

Metode negated() atgriež jaunu Temporal.Duration objektu, kurā visi komponenti ir ar pretēju zīmi (negatīvi):

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Rezultāts: -P1Y2M10DT2H30M

Metode abs() atgriež jaunu Temporal.Duration objektu, kurā visi komponenti ir pozitīvas vērtības (absolūtās vērtības):

const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Rezultāts: P1Y2M10DT2H30M

Metode with() ļauj izveidot jaunu Temporal.Duration instanci, kurā dažas vai visas īpašības ir nomainītas uz jaunām vērtībām. Ja argumenta objektā vērtība nav norādīta, tad tiek izmantota sākotnējā ilguma vērtība. Piemēram:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // Rezultāts: P2Y2M5DT2H30M

Ilgumu Normalizēšana

Dažreiz ilgumus var izteikt nenormalizētā formā (piemēram, P1Y12M, ko varētu vienkāršot uz P2Y). Metode normalized() mēģina vienkāršot ilgumu līdz tā kompaktākajai formai. Tomēr, lai apstrādātu mainīgo mēnešu garumu sarežģītību, ir nepieciešams atskaites datums. Lai pareizi normalizētu, jums būs nepieciešama Temporal.PlainDate, Temporal.ZonedDateTime vai Temporal.Instant instance.

Piemēram, lai normalizētu ilgumu, kas ietver mēnešus un dienas, ir nepieciešams atskaites datums:

const duration = Temporal.Duration.from("P1M32D");
const referenceDate = Temporal.PlainDate.from("2024-01-01");
const normalizedDuration = duration.normalized({ relativeTo: referenceDate });
console.log(normalizedDuration.toString()); // Rezultāts: P2M1D

Šajā piemērā ilgums P1M32D tiek normalizēts attiecībā pret 2024. gada 1. janvāri, rezultātā iegūstot P2M1D, jo janvārī ir 31 diena.

Ja jūs strādājat tikai ar laika komponentiem (stundas, minūtes, sekundes utt.), jūs varat normalizēt bez atskaites datuma:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //vai izlaidiet relativeTo argumentu
console.log(normalizedDuration.toString()); // Rezultāts: P1DT2H1M

Ilgumu Salīdzināšana

Jūs varat salīdzināt ilgumus, izmantojot compare() metodi. Šī metode atgriež:

• -1, ja pirmais ilgums ir īsāks par otro ilgumu.
• 0, ja ilgumi ir vienādi.
• 1, ja pirmais ilgums ir garāks par otro ilgumu.

const duration1 = Temporal.Duration.from("P1Y");
const duration2 = Temporal.Duration.from("P6M");

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // Rezultāts: 1

Praktiski Piemēri

1. Laika Aprēķināšana līdz Notikumam

Pieņemsim, ka vēlaties aprēķināt atlikušo laiku līdz konkrētam notikumam. Izmantojot Temporal.Now.zonedDateTimeISO(), lai iegūtu pašreizējo laiku, un atņemot notikuma datumu. Ja notikuma datums ir pagājis, rezultāts būs negatīvs.

const eventDate = Temporal.ZonedDateTime.from({ timeZone: 'America/Los_Angeles', year: 2024, month: 12, day: 25, hour: 9, minute: 0, second: 0 });
const now = Temporal.Now.zonedDateTimeISO('America/Los_Angeles');

const durationUntilEvent = eventDate.since(now);

console.log(durationUntilEvent.toString()); // Rezultāts: piem., P262DT14H30M (atkarībā no pašreizējā datuma un laika)

2. Projekta Uzdevumu Ilguma Izsekošana

Projektu vadībā varat izmantot Temporal.Duration, lai izsekotu plānoto vai faktisko uzdevumu ilgumu.

const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 stundas
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 stundas

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Kopējais plānotais ilgums: ${totalEstimatedDuration.toString()}`); // Rezultāts: Kopējais plānotais ilgums: P1DT

3. Vecuma Aprēķināšana

Lai gan precīzai vecuma aprēķināšanai ir jāņem vērā garie gadi un laika joslas, Temporal.Duration var sniegt diezgan precīzu aplēsi:

const birthDate = Temporal.PlainDate.from("1990-05-15");
const currentDate = Temporal.PlainDate.from("2024-01-20");

const ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Aptuvenais vecums: ${ageDuration.years} gadi`); // Rezultāts: Aptuvenais vecums: 33 gadi

4. Cilvēkam Lasāmu Ilgumu Attēlošana

Bieži vien ir nepieciešams attēlot ilgumus cilvēkam lasāmā formātā. Lai gan Temporal.Duration nav iebūvētu formatēšanas funkciju, jūs varat izveidot pielāgotu formatēšanas loģiku:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} gads${duration.years !== 1 ? 'i' : ''}`);
  if (duration.months) parts.push(`${duration.months} mēnesis${duration.months !== 1 ? 'i' : ''}`);
  if (duration.days) parts.push(`${duration.days} diena${duration.days !== 1 ? 's' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} stunda${duration.hours !== 1 ? 's' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} minūte${duration.minutes !== 1 ? 's' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} sekunde${duration.seconds !== 1 ? 's' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Rezultāts: 1 gads, 2 mēneši, 10 dienas, 2 stundas, 30 minūtes

Papildu Izmantošana un Apsvērumi

1. Laika Joslu Apstrāde

Strādājot ar laika intervāliem, kas šķērso laika joslu robežas vai vasaras laika pārejas, ir ļoti svarīgi izmantot Temporal.ZonedDateTime, lai nodrošinātu precīzus aprēķinus. Izmantojot Temporal.PlainDate un Temporal.PlainTime, tiks novērstas jebkādas laika joslu konvertācijas.

2. Mazākā Mērvienība un Noapaļošana

Metodes `since()` un `until()` bieži pieņem opcijas, lai definētu rezultātā iegūtā ilguma mazāko mērvienību. Piemēram, aprēķinot laiku *līdz* notikumam un ierobežojot rezultātus līdz dienām.

const eventDate = Temporal.PlainDate.from("2024-12-25");
const now = Temporal.PlainDate.from("2024-01-20");

const durationUntilEvent = now.until(eventDate, { smallestUnit: 'days' });

console.log(durationUntilEvent.toString()); //piemēra rezultāts PT340D

3. Garo sekunžu apstrāde

Temporal neatbalsta garās sekundes. Ja nepieciešama ārkārtēja precizitāte, garās sekundes jāapstrādā atsevišķi.

4. IANA Laika Joslas

Temporal API paļaujas uz IANA (Internet Assigned Numbers Authority) laika joslu datubāzi. Pārliecinieties, ka jūsu vidē ir atjaunināta IANA datubāzes versija, lai precīzi apstrādātu laika joslu konvertācijas.

Labākās Prakses

• Izmantojiet ISO 8601 formātu ilguma virknēm: Tas nodrošina konsekvenci un sadarbspēju.
• Izvēlieties atbilstošo Temporal tipu: Izmantojiet Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime vai Temporal.Instant atkarībā no tā, vai jums ir nepieciešams laika joslu atbalsts.
• Normalizējiet ilgumus, kad nepieciešams: Normalizācija vienkāršo ilgumus un atvieglo to salīdzināšanu.
• Rūpīgi apstrādājiet laika joslas: Laika joslu konvertācijas var būt sarežģītas, tāpēc izmantojiet Temporal.ZonedDateTime un ņemiet vērā vasaras laika pārejas.
• Apsveriet mazāko mērvienību: Aprēķinot ilgumus, norādiet mazāko mērvienību, lai iegūtu vēlamo precizitātes līmeni.
• Rakstiet vienībtestus (unit tests): Rūpīgi testējiet savu kodu, lai nodrošinātu, ka ilguma aprēķini ir precīzi.

Biežākās Kļūdas

• Laika joslu ignorēšana: Ja netiek ņemtas vērā laika joslas, tas var novest pie nepareiziem ilguma aprēķiniem, īpaši strādājot ar notikumiem dažādās vietās.
• Mantotā Date objekta izmantošana: Mantotais Date objekts ir pazīstams ar savām dīvainībām un nekonsekvenci. Dodiet priekšroku Temporal API, lai nodrošinātu uzticamāku datuma un laika apstrādi.
• Ilgumu nenormalizēšana: Ilgumu nenormalizēšana var sarežģīt salīdzināšanu un aprēķinus.
• Nepareizs ISO 8601 formāts: Nederīgas ISO 8601 ilguma virknes izmantošana var izraisīt kļūdas.

Reālās Pasaules Pielietojuma Piemēri Dažādās Kultūrās

Temporal API var būt īpaši noderīgs globālās lietojumprogrammās, kur laika joslu atšķirības un kultūras nianses ir nozīmīgas. Šeit ir daži piemēri:

• Globāla Notikumu Plānošana: Precīza notikumu plānošana vairākās laika joslās, ņemot vērā vasaras laika pārejas. Piemēram, plānojot vebināru, kas sākas plkst. 9:00 PST, un attēlojot atbilstošo sākuma laiku dažādās laika joslās, piemēram, CET, JST un AEDT.
• Starptautisko Ceļojumu Plānošana: Ceļojumu ilguma aprēķināšana, ieskaitot pārsēšanās un laika joslu maiņas. Tas ir noderīgi, lai ģenerētu maršrutus un pārvaldītu lidojumu grafikus. Piemēram, aprēķinot kopējo ceļojuma laiku no Ņujorkas uz Tokiju, ieskaitot pārsēšanos Londonā un pielāgojoties laika joslu atšķirībām.
• Globālā E-komercija: Paredzamā piegādes laika attēlošana lietotāja vietējā laika joslā. Tas prasa ņemt vērā izcelsmes laika joslu, piegādes ilgumu un galamērķa laika joslu. Piemēram, prece, kas tiek nosūtīta no noliktavas Vācijā klientam Austrālijā, ar paredzamo piegādes laiku 7 dienas, tiek attēlota klienta vietējā laikā.
• Pārrobežu Finanšu Darījumi: Precīza procentu uzkrāšanas vai maksājumu termiņu aprēķināšana dažādos reģionos. Tas bieži ietver dažādu darba dienu un svētku dienu ņemšanu vērā katrā valstī. Piemēram, aprēķinot procentus, kas uzkrāti par aizdevumu Singapūrā, ņemot vērā Singapūras valsts svētku dienas.
• Daudzkultūru Kalendāra Lietojumprogrammas: Dažādu kalendāru sistēmu, piemēram, islāma vai ebreju kalendāra, atbalstīšana un precīza notikumu ilguma un atgādinājumu aprēķināšana, pamatojoties uz šiem kalendāriem.
• Globālā Projektu Vadība: Projektu uzdevumu ilguma un termiņu izsekošana sadalītās komandās, ņemot vērā dažādus darba grafikus un laika joslas.

Noslēgums

Temporal.Duration nodrošina robustu un intuitīvu veidu, kā strādāt ar laika intervāliem JavaScript. Izprotot tā funkcijas un labākās prakses, jūs varat droši veikt precīzus un uzticamus ilguma aprēķinus savās lietojumprogrammās. Temporal API izmantošana noved pie tīrāka, vieglāk uzturama koda un samazina kļūdu risku, kas saistīts ar mantoto datuma un laika apstrādi.

Iedziļinoties Temporal API, neaizmirstiet iepazīties ar oficiālo dokumentāciju un eksperimentēt ar dažādiem scenārijiem, lai pilnībā izprastu tā iespējas. Ar savu moderno dizainu un visaptverošajām funkcijām Temporal ir gatavs revolucionizēt veidu, kā mēs apstrādājam datumus, laikus un ilgumus JavaScript.