JavaScript Temporal Duration: Obvladovanje izračunov časovnih intervalov

JavaScript Temporal API uvaja sodoben in zmogljiv način za obravnavo datumov, časov in časovnih intervalov. Objekt Temporal.Duration predstavlja dolžino časa, kar zagotavlja jasen in intuitiven pristop k izvajanju izračunov s časovnimi intervali. Ta članek se poglablja v podrobnosti Temporal.Duration in prikazuje, kako ustvariti, manipulirati in oblikovati trajanja za različne primere uporabe.

Kaj je Temporal.Duration?

Temporal.Duration predstavlja časovno obdobje, ki ga izraža v letih, mesecih, dnevih, urah, minutah, sekundah in delih sekunde (milisekunde, mikrosekunde, nanosekunde). Za razliko od objektov Date, ki predstavljajo določeno točko v času, Temporal.Duration predstavlja količino časa. Ustreza formatu trajanja ISO 8601 (npr. P1Y2M10DT2H30M predstavlja 1 leto, 2 meseca, 10 dni, 2 uri in 30 minut). Temporal API je zasnovan tako, da je bolj intuitiven in manj nagnjen k napakam kot zastareli objekt Date.

Ustvarjanje objektov Temporal.Duration

Obstaja več načinov za ustvarjanje objektov Temporal.Duration:

1. Iz navadnega objekta

Trajanje lahko ustvarite tako, da posredujete objekt z želenimi lastnostmi:

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

To ustvari trajanje 1 leto, 2 meseca, 10 dni, 2 uri in 30 minut. Upoštevajte, da argumenti ustrezajo naslednjemu vrstnemu redu: leta, meseci, tedni, dnevi, ure, minute, sekunde, milisekunde, mikrosekunde, nanosekunde.

2. Iz niza ISO 8601

Trajanje lahko ustvarite tudi iz niza trajanja ISO 8601 z uporabo Temporal.Duration.from():

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

To je še posebej uporabno, ko imate opravka s trajanjem, shranjenim v obliki niza ali prejetim iz zunanjega vira.

3. Uporaba metod `add()` in `subtract()` z `Temporal.Instant`, `Temporal.ZonedDateTime` itd.

Ko dodate ali odštejete Temporal.Duration od drugih tipov Temporal (kot sta Temporal.Instant ali Temporal.ZonedDateTime), se vrne Temporal.Duration, ki predstavlja razliko med dvema točkama v času, če ju nato odštejete. Na primer:

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

Dostop do komponent trajanja

Do posameznih komponent objekta Temporal.Duration lahko dostopate z uporabo njegovih lastnosti:

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

Izvajanje aritmetike s trajanjem

Objekti Temporal.Duration podpirajo seštevanje in odštevanje z uporabo metod add() in subtract(). Ti metodi vrneta nov objekt Temporal.Duration, ki predstavlja rezultat operacije.

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

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

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

Te metode lahko tudi verižite za bolj zapletene izračune:

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

Metoda negated() vrne nov objekt Temporal.Duration z vsemi komponentami, ki so negirane:

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

Metoda abs() vrne nov objekt Temporal.Duration z vsemi komponentami kot pozitivnimi vrednostmi (absolutne vrednosti):

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

Metoda with() vam omogoča ustvarjanje nove instance Temporal.Duration z nekaterimi ali vsemi lastnostmi, spremenjenimi v nove vrednosti. Če vrednost ni določena v argumentnem objektu, se uporabi prvotna vrednost trajanja. Na primer:

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

Normalizacija trajanj

Trajanja se lahko včasih izrazijo v nenormalizirani obliki (npr. P1Y12M, kar bi lahko poenostavili na P2Y). Metoda normalized() poskuša poenostaviti trajanje v njegovo najbolj kompaktno obliko. Vendar pa zahteva referenčni datum za obravnavo zapletenosti spreminjajočih se dolžin mesecev. Za pravilno normalizacijo boste potrebovali instanco Temporal.PlainDate, Temporal.ZonedDateTime ali Temporal.Instant.

Na primer, normalizacija trajanja, ki vključuje mesece in dneve, zahteva referenčni datum:

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

V tem primeru se trajanje P1M32D normalizira glede na 1. januar 2024, kar ima za posledico P2M1D, ker ima januar 31 dni.

Če imate opravka samo s časovnimi komponentami (ure, minute, sekunde itd.), lahko normalizirate brez referenčnega datuma:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //ali izpustite argument relativeTo
console.log(normalizedDuration.toString()); // Output: P1DT2H1M

Primerjava trajanj

Trajanja lahko primerjate z metodo compare(). Ta metoda vrne:

-1, če je prvo trajanje krajše od drugega trajanja.
0, če sta trajanji enaki.
1, če je prvo trajanje daljše od drugega trajanja.

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

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

Praktični primeri

1. Izračun časa do dogodka

Recimo, da želite izračunati čas, ki je še ostal do določenega dogodka. Uporaba Temporal.Now.zonedDateTimeISO() za pridobitev trenutnega časa in odštevanje datuma dogodka. Če je datum dogodka že mimo, bo izhod negativen.

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()); // Output: npr. P262DT14H30M (odvisno od trenutnega datuma in časa)

2. Sledenje trajanjem projektnih nalog

Pri vodenju projektov lahko uporabite Temporal.Duration za sledenje ocenjenemu ali dejanskemu trajanju nalog.

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

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Total estimated duration: ${totalEstimatedDuration.toString()}`); // Output: Total estimated duration: P1DT

3. Izračun starosti

Medtem ko natančen izračun starosti zahteva upoštevanje prestopnih let in časovnih pasov, lahko Temporal.Duration zagotovi razumno oceno:

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(`Estimated age: ${ageDuration.years} years`); // Output: Estimated age: 33 years

4. Prikaz človeku berljivih trajanj

Pogosto morate trajanja prikazati v človeku berljivi obliki. Medtem ko Temporal.Duration nima vgrajenih funkcij za oblikovanje, lahko ustvarite logiko oblikovanja po meri:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} leto${duration.years > 1 ? 's' : ''}`);
  if (duration.months) parts.push(`${duration.months} mesec${duration.months > 1 ? 's' : ''}`);
  if (duration.days) parts.push(`${duration.days} dan${duration.days > 1 ? 's' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} ura${duration.hours > 1 ? 's' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} minuta${duration.minutes > 1 ? 's' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} sekunda${duration.seconds > 1 ? 's' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Output: 1 leto, 2 meseca, 10 dni, 2 uri, 30 minut

Napredna uporaba in premisleki

1. Obravnavanje časovnih pasov

Pri obravnavanju časovnih intervalov, ki prečkajo meje časovnih pasov ali prehode na poletni čas, je ključnega pomena uporaba Temporal.ZonedDateTime za zagotavljanje natančnih izračunov. Z uporabo Temporal.PlainDate in Temporal.PlainTime se boste izognili vsem pretvorbam časovnih pasov.

2. Najmanjša enota in zaokroževanje

Metodi `since()` in `until()` pogosto sprejmeta možnosti za določitev najmanjše enote za nastalo trajanje. Na primer, izračun časa *do* dogodka in omejitev rezultatov na dneve.

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()); //primer izhoda PT340D

3. Prestopne sekunde

Temporal ne upošteva prestopnih sekund izvorno. Če potrebujete izjemno natančnost, boste morali prestopne sekunde obravnavati ločeno.

4. Časovni pasovi IANA

Temporal API se zanaša na bazo podatkov časovnih pasov IANA (Internet Assigned Numbers Authority). Zagotovite, da ima vaše okolje posodobljeno različico baze podatkov IANA za natančno obravnavo pretvorb časovnih pasov.

Najboljše prakse

Uporabite format ISO 8601 za nize trajanja: To zagotavlja doslednost in interoperabilnost.
Izberite ustrezen tip Temporal: Uporabite Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime ali Temporal.Instant glede na to, ali potrebujete podporo za časovni pas ali ne.
Po potrebi normalizirajte trajanja: Normalizacija poenostavi trajanja in olajša njihovo primerjavo.
Pazljivo obravnavajte časovne pasove: Pretvorbe časovnih pasov so lahko zapletene, zato uporabite Temporal.ZonedDateTime in se zavedajte prehodov na poletni čas.
Upoštevajte najmanjšo enoto: Pri izračunu trajanj določite najmanjšo enoto, da dobite želeno raven natančnosti.
Napišite enotske teste: Temeljito preizkusite svojo kodo, da zagotovite natančnost izračunov trajanja.

Pogoste pasti

Ignoriranje časovnih pasov: Neupoštevanje časovnih pasov lahko povzroči nepravilne izračune trajanja, zlasti pri obravnavanju dogodkov na različnih lokacijah.
Uporaba zastarelega objekta Date: Zastareli objekt Date je znan po svojih posebnostih in nedoslednostih. Za bolj zanesljivo obravnavo datuma in časa raje uporabite Temporal API.
Ne normalizacija trajanj: Ne normalizacija trajanj lahko zaplete primerjave in izračune.
Nepravilen format ISO 8601: Uporaba neveljavnega niza trajanja ISO 8601 lahko povzroči napake.

Primeri uporabe v resničnem svetu v različnih kulturah

Temporal API je lahko še posebej koristen v globalnih aplikacijah, kjer so razlike v časovnih pasovih in kulturne nianse pomembne. Tukaj je nekaj primerov:

Globalno načrtovanje dogodkov: Natančno načrtovanje dogodkov v več časovnih pasovih ob upoštevanju prehodov na poletni čas. Na primer, načrtovanje spletnega seminarja, ki se začne ob 9:00 PST, in prikaz ustreznega časa začetka v različnih časovnih pasovih, kot so CET, JST in AEDT.
Načrtovanje mednarodnih potovanj: Izračun trajanja potovanj, vključno s postanki in spremembami časovnih pasov. To je uporabno za ustvarjanje načrtov poti in upravljanje urnikov letov. Na primer, izračun celotnega časa potovanja od New Yorka do Tokia, vključno s postankom v Londonu in prilagoditvijo glede na razlike v časovnih pasovih.
Globalna e-trgovina: Prikaz ocenjenih časov dostave v lokalnem časovnem pasu uporabnika. To zahteva upoštevanje časovnega pasu izvora, trajanja pošiljanja in ciljnega časovnega pasu. Na primer, artikel, poslan iz skladišča v Nemčiji stranki v Avstraliji, z ocenjenim časom dostave 7 dni, prikazan v lokalnem času stranke.
Čezmejne finančne transakcije: Natančen izračun obračunavanja obresti ali rokov za plačilo v različnih regijah. To pogosto vključuje upoštevanje različnih delovnih dni in praznikov v vsaki državi. Na primer, izračun obresti, obračunanih na posojilo v Singapurju, ob upoštevanju singapurskih državnih praznikov.
Multikulturne aplikacije za koledar: Podpora različnim koledarskim sistemom, kot sta islamski ali hebrejski koledar, in natančen izračun trajanj dogodkov in opomnikov na podlagi teh koledarjev.
Globalno vodenje projektov: Sledenje trajanjem projektnih nalog in rokom v distribuiranih ekipah ob upoštevanju različnih urnikov dela in časovnih pasov.

Zaključek

Temporal.Duration ponuja robusten in intuitiven način za delo s časovnimi intervali v JavaScriptu. Z razumevanjem njegovih funkcij in najboljših praks lahko samozavestno izvajate natančne in zanesljive izračune trajanja v svojih aplikacijah. Sprejetje Temporal API vodi do čistejše, lažje vzdrževane kode in zmanjšuje tveganje napak, povezanih z zastarelo obravnavo datuma in časa.

Ko se boste poglabljali v Temporal API, se spomnite, da se posvetujete z uradno dokumentacijo in eksperimentirate z različnimi scenariji, da bi v celoti dojeli njegove zmožnosti. S svojo moderno zasnovo in obsežnimi funkcijami bo Temporal revolucioniral način, kako obravnavamo datume, čase in trajanja v JavaScriptu.