JavaScript Temporal API: Moodne kuupäeva ja kellaaja manipuleerimine

JavaScripti Date objekt on arendajatele pikka aega pettumust valmistanud. Selle muutlikkus, sisseehitatud ajavööndi toe puudumine ja kohmakas API on viinud lugematute teekide ja lahendusteni. Õnneks püüab Temporal API neid puudusi kõrvaldada, pakkudes moodsat, intuitiivset ja ajavööndit teadvat lahendust kuupäeva ja kellaaja manipuleerimiseks JavaScriptis.

Mis on Temporal API?

Temporal API on uus globaalne objekt, Temporal, mis pakub moodsat ja standardiseeritud viisi kuupäevade ja kellaaegadega töötamiseks JavaScriptis. See on loodud asendama vana Date objekti, pakkudes märkimisväärseid parandusi API disaini, muutumatuse, ajavööndi toe ja üldise kasutatavuse osas. See on osa ECMAScripti ettepanekust ja seda rakendatakse peamistes JavaScripti mootorites.

Temporal API peamised eelised:

• Muutumatus: Temporaalsed objektid on muutumatud, mis tähendab, et nendega tehtavad toimingud tagastavad uusi objekte, selle asemel et muuta originaali. See aitab vältida ootamatuid kõrvalmõjusid ja muudab koodi hõlpsamini mõistetavaks.
• Selge API: API on loodud olema intuitiivsem ja järjepidevam kui vana Date objekt.
• Ajavööndi tugi: Temporal pakub tugevat ajavööndite tuge, võimaldades teil töötada kuupäevade ja kellaaegadega erinevates kohtades üle maailma.
• Kalendri tugi: Lisaks Gregoriuse kalendrile võimaldab API kasutada ka teisi kalendrisüsteeme, hõlbustades globaalseid rakendusi.
• Liigsekundi käsitlemine: Temporal API arvestab liigsekunditega, pakkudes täpsemaid ajaarvutusi.

Temporaliga alustamine

Kuigi Temporal API on alles väljatöötamisel ja seda ei toetata veel täielikult kõigis brauserites ja Node.js keskkondades, saate sellega katsetama hakata juba täna, kasutades polütäidet. Saate installida polütäite npm kaudu:

            npm install @js-temporal/polyfill
            

              
                Copy
              
            
          

Seejärel importige polütäide oma JavaScripti koodis:

            import { Temporal } from '@js-temporal/polyfill';
            

              
                Copy
              
            
          

Kui polütäide on installitud, saate hakata kasutama Temporal objekti ja selle erinevaid klasse.

Temporali põhiklassid

Temporal API pakub mitmeid põhiklasse kuupäevade ja kellaaegadega töötamiseks:

• Temporal.PlainDate: Esindab kalendrikuupäeva (aasta, kuu ja päev) ilma ajavööndi või kellaaja teabeta.
• Temporal.PlainTime: Esindab kellaaega (tund, minut, sekund ja sekundi murdosa) ilma kuupäeva või ajavööndi teabeta.
• Temporal.PlainDateTime: Esindab kuupäeva ja kellaaega ilma ajavööndi teabeta.
• Temporal.ZonedDateTime: Esindab kuupäeva ja kellaaega koos konkreetse ajavööndiga.
• Temporal.Instant: Esindab konkreetset ajahetke, mõõdetuna nanosekundites alates Unixi ajastu algusest (1. jaanuar 1970 kell 00:00:00 koordineeritud maailmaaeg (UTC)).
• Temporal.TimeZone: Esindab ajavööndit.
• Temporal.Duration: Esindab ajavahemikku, näiteks tunde, minuteid või sekundeid.
• Temporal.Now: Pakub juurdepääsu praegusele kuupäevale ja kellaajale.

PlainDate'iga töötamine

Klass Temporal.PlainDate esindab kuupäeva ilma ajavööndi või kellaaja teabeta. See on kasulik sünnipäevade, tähtpäevade või muude kuupäevapõhiste sündmuste esindamiseks.

PlainDate loomine:

            const plainDate = Temporal.PlainDate.from({ year: 2024, month: 10, day: 26 });
console.log(plainDate.toString()); // Väljund: 2024-10-26
            

              
                Copy
              
            
          

Saate luua ka PlainDate ISO 8601 vormingus stringist:

            const plainDateFromString = Temporal.PlainDate.from('2024-12-25');
console.log(plainDateFromString.toString()); // Väljund: 2024-12-25
            

              
                Copy
              
            
          

Kuupäeva komponentidele juurdepääs:

            const year = plainDate.year; // 2024
const month = plainDate.month; // 10
const day = plainDate.day;   // 26
const dayOfWeek = plainDate.dayOfWeek; // Nädala päev (1-7, esmaspäev-pühapäev)
const dayOfYear = plainDate.dayOfYear; // Aasta päev (1-366)
const daysInMonth = plainDate.daysInMonth; // Päevade arv kuus
const isLeapYear = plainDate.isLeapYear;   // Boolean, mis näitab, kas aasta on liigaasta
            

              
                Copy
              
            
          

Päevade lisamine ja lahutamine:

            const nextDay = plainDate.add({ days: 1 });
console.log(nextDay.toString()); // Väljund: 2024-10-27

const previousWeek = plainDate.subtract({ weeks: 1 });
console.log(previousWeek.toString()); // Väljund: 2024-10-19
            

              
                Copy
              
            
          

Kuupäevade võrdlemine:

            const anotherDate = Temporal.PlainDate.from({ year: 2024, month: 11, day: 15 });

if (plainDate.equals(anotherDate)) {
  console.log('Kuupäevad on võrdsed');
} else if (plainDate.lessThan(anotherDate)) {
  console.log('plainDate on varasem kui anotherDate');
} else {
  console.log('plainDate on hilisem kui anotherDate');
}
// Väljund: plainDate on varasem kui anotherDate
            

              
                Copy
              
            
          

PlainTime'iga töötamine

Klass Temporal.PlainTime esindab kellaaega ilma kuupäeva või ajavööndi teabeta. See on kasulik lahtiolekuaegade, koosolekuaegade või muude ajapõhiste sündmuste esindamiseks.

PlainTime loomine:

            const plainTime = Temporal.PlainTime.from({ hour: 14, minute: 30, second: 0 });
console.log(plainTime.toString()); // Väljund: 14:30:00
            

              
                Copy
              
            
          

Saate luua ka PlainTime ISO 8601 vormingus stringist:

            const plainTimeFromString = Temporal.PlainTime.from('09:00:00');
console.log(plainTimeFromString.toString()); // Väljund: 09:00:00
            

              
                Copy
              
            
          

Kellaaja komponentidele juurdepääs:

            const hour = plainTime.hour;   // 14
const minute = plainTime.minute; // 30
const second = plainTime.second; // 0
const millisecond = plainTime.millisecond; // 0
const microsecond = plainTime.microsecond; // 0
const nanosecond = plainTime.nanosecond;   // 0
            

              
                Copy
              
            
          

Kellaaja lisamine ja lahutamine:

            const laterTime = plainTime.add({ minutes: 15 });
console.log(laterTime.toString()); // Väljund: 14:45:00

const earlierTime = plainTime.subtract({ hours: 1 });
console.log(earlierTime.toString()); // Väljund: 13:30:00
            

              
                Copy
              
            
          

Kellaaegade võrdlemine:

            const anotherTime = Temporal.PlainTime.from({ hour: 15, minute: 0, second: 0 });

if (plainTime.equals(anotherTime)) {
  console.log('Kellaajad on võrdsed');
} else if (plainTime.lessThan(anotherTime)) {
  console.log('plainTime on varasem kui anotherTime');
} else {
  console.log('plainTime on hilisem kui anotherTime');
}
// Väljund: plainTime on varasem kui anotherTime
            

              
                Copy
              
            
          

PlainDateTime'iga töötamine

Klass Temporal.PlainDateTime esindab kuupäeva ja kellaaega ilma ajavööndi teabeta. See ühendab PlainDate ja PlainTime funktsionaalsuse.

PlainDateTime loomine:

            const plainDateTime = Temporal.PlainDateTime.from({ year: 2024, month: 10, day: 26, hour: 14, minute: 30, second: 0 });
console.log(plainDateTime.toString()); // Väljund: 2024-10-26T14:30:00
            

              
                Copy
              
            
          

Saate luua ka PlainDateTime ISO 8601 vormingus stringist:

            const plainDateTimeFromString = Temporal.PlainDateTime.from('2024-12-25T09:00:00');
console.log(plainDateTimeFromString.toString()); // Väljund: 2024-12-25T09:00:00
            

              
                Copy
              
            
          

Kuupäeva ja kellaaja komponentidele juurdepääs:

            const year = plainDateTime.year;   // 2024
const month = plainDateTime.month; // 10
const day = plainDateTime.day;     // 26
const hour = plainDateTime.hour;   // 14
const minute = plainDateTime.minute; // 30
const second = plainDateTime.second; // 0
            

              
                Copy
              
            
          

Kuupäevade ja kellaaegade lisamine ja lahutamine:

            const nextDayAndTime = plainDateTime.add({ days: 1, hours: 2 });
console.log(nextDayAndTime.toString()); // Väljund: 2024-10-27T16:30:00

const previousWeekAndTime = plainDateTime.subtract({ weeks: 1, minutes: 30 });
console.log(previousWeekAndTime.toString()); // Väljund: 2024-10-19T14:00:00
            

              
                Copy
              
            
          

Teisendamine PlainDate ja PlainTime:

            const plainDateFromDateTime = plainDateTime.toPlainDate();
console.log(plainDateFromDateTime.toString()); // Väljund: 2024-10-26

const plainTimeFromDateTime = plainDateTime.toPlainTime();
console.log(plainTimeFromDateTime.toString()); // Väljund: 14:30:00
            

              
                Copy
              
            
          

ZonedDateTime'iga töötamine

Klass Temporal.ZonedDateTime esindab kuupäeva ja kellaaega koos konkreetse ajavööndiga. See on ülioluline rakenduste jaoks, mis peavad käsitlema kuupäevi ja kellaaegu erinevates kohtades üle maailma. Erinevalt vanast Date objektist pakub Temporal sisseehitatud ajavööndi tuge.

ZonedDateTime loomine:

            const zonedDateTime = Temporal.ZonedDateTime.from({ year: 2024, month: 10, day: 26, hour: 14, minute: 30, second: 0, timeZone: 'America/Los_Angeles' });
console.log(zonedDateTime.toString()); // Väljund: 2024-10-26T14:30:00-07:00[America/Los_Angeles]
            

              
                Copy
              
            
          

Saate luua ka ZonedDateTime objektist Instant ja ajavööndist:

            const instant = Temporal.Instant.fromEpochSeconds(1666785000); // Näidis ajatempel
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO('Europe/London');
console.log(zonedDateTimeFromInstant.toString()); // Väljund varieerub sõltuvalt tegelikust ajast, kuid kajastab kuupäeva/kellaaega Euroopas/Londonis
            

              
                Copy
              
            
          

Kuupäeva ja kellaaja komponentidele juurdepääs:

            const year = zonedDateTime.year;   // 2024
const month = zonedDateTime.month; // 10
const day = zonedDateTime.day;     // 26
const hour = zonedDateTime.hour;   // 14
const minute = zonedDateTime.minute; // 30
const second = zonedDateTime.second; // 0
const timeZone = zonedDateTime.timeZone; // Temporal.TimeZone objekt
            

              
                Copy
              
            
          

Ajavööndite vahel teisendamine:

            const newYorkDateTime = zonedDateTime.withTimeZone('America/New_York');
console.log(newYorkDateTime.toString()); // Väljund: 2024-10-26T17:30:00-04:00[America/New_York]
            

              
                Copy
              
            
          

Suveaja (DST) käsitlemine:

Temporal käsitleb DST üleminekuid automaatselt. Aja lisamisel või lahutamisel võtab see arvesse DST-d, tagades täpsed tulemused. Näiteks kaaluge kohtumist, mis on planeeritud üle DST ülemineku Saksamaal:

            const meetingStart = Temporal.ZonedDateTime.from({ year: 2024, month: 3, day: 31, hour: 2, minute: 30, timeZone: 'Europe/Berlin' });
const meetingEnd = meetingStart.add({ hours: 1 }); // 1 tunni lisamine
console.log(meetingEnd.toString()); // Väljund: 2024-03-31T03:30:00+02:00[Europe/Berlin]. Pange tähele, et nihe muutub DST tõttu
            

              
                Copy
              
            
          

Instant'iga töötamine

Klass Temporal.Instant esindab konkreetset ajahetke, mõõdetuna nanosekundites alates Unixi ajastu algusest. See on kasulik täpsete ajahetkede salvestamiseks ja võrdlemiseks.

Instant loomine:

            const instant = Temporal.Instant.fromEpochSeconds(1666785000); // Näidis Unixi ajatempel sekundites
console.log(instant.toString()); // Väljund on selle hetke ISO string esitus
            

              
                Copy
              
            
          

Teisendamine ZonedDateTime:

            const zonedDateTimeFromInstant = instant.toZonedDateTimeISO('America/Los_Angeles');
console.log(zonedDateTimeFromInstant.toString()); // Väljund: Kuupäev ja kellaaeg America/Los_Angeles ajavööndis, mis vastab hetkele
            

              
                Copy
              
            
          

Hetkede võrdlemine:

            const anotherInstant = Temporal.Instant.fromEpochSeconds(1666790000);

if (instant.equals(anotherInstant)) {
  console.log('Hetked on võrdsed');
} else if (instant.lessThan(anotherInstant)) {
  console.log('hetk on varasem kui anotherInstant');
} else {
  console.log('hetk on hilisem kui anotherInstant');
}
// Väljund: hetk on varasem kui anotherInstant
            

              
                Copy
              
            
          

Duration'iga töötamine

Klass Temporal.Duration esindab ajavahemikku, näiteks tunde, minuteid või sekundeid. See on kasulik kahe kuupäeva või kellaaja vahe arvutamiseks.

Duration loomine:

            const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });
console.log(duration.toString()); // Väljund: PT2H30M
            

              
                Copy
              
            
          

Kuupäevade/kellaaegade vahe arvutamine:

            const startDate = Temporal.PlainDateTime.from({ year: 2024, month: 1, day: 1, hour: 0, minute: 0, second: 0 });
const endDate = Temporal.PlainDateTime.from({ year: 2024, month: 1, day: 3, hour: 12, minute: 30, second: 0 });
const difference = endDate.since(startDate);
console.log(difference.toString()); // Väljund: P2DT12H30M

// Kestuse komponentidele juurdepääs
console.log(difference.days);    // 2
console.log(difference.hours);   // 12
console.log(difference.minutes); // 30
            

              
                Copy
              
            
          

Kestuse lisamine kuupäevadele/kellaaegadele:

            const newDate = startDate.add(duration);
console.log(newDate.toString()); // Väljund: 2024-01-03T02:30:00
            

              
                Copy
              
            
          

Kalendritega töötamine

Temporal API toetab erinevaid kalendrisüsteeme peale Gregoriuse kalendri. Kuigi see pole veel täielikult rakendatud kõigis polütäidetes ja mootorites, on eesmärk võimaldada rakendustel käsitleda kuupäevi erinevatele kultuuridele omaselt. Näiteks Jaapani kalendri kasutamiseks (hüpoteetiliselt, kuna rakendamine on alles väljatöötamisel):

            // See on kontseptuaalne näide, kuna kalendri tugi on alles väljatöötamisel
// const japaneseDate = Temporal.PlainDate.from({ year: 2024, month: 10, day: 26, calendar: 'japanese' });
// console.log(japaneseDate.toString()); // Oodatav: Väljund vormindatud vastavalt Jaapani kalendrile

            

              
                Copy
              
            
          

Märkus: Kalendri tugi on Temporal API arenev funktsioon ja täielik funktsionaalsus pole veel universaalselt saadaval.

Praktilised näited ja kasutusjuhtumid

Temporal API pakub laia valikut võimalusi kuupäevade ja kellaaegade käsitlemiseks JavaScriptis. Siin on mõned praktilised näited ja kasutusjuhtumid:

• Kohtumiste planeerimine: Looge planeerimisrakendus, mis võimaldab kasutajatel broneerida kohtumisi oma kohalikus ajavööndis. Temporal.ZonedDateTime muudab ajavööndite vahel teisendamise ja DST üleminekute käsitlemise lihtsaks. Berliini kliiniku jaoks, mis planeerib kohtumisi globaalselt:

            const appointmentTimeBerlin = Temporal.ZonedDateTime.from({ year: 2024, month: 11, day: 5, hour: 10, minute: 0, timeZone: 'Europe/Berlin' });
const appointmentTimeLA = appointmentTimeBerlin.withTimeZone('America/Los_Angeles');
console.log(`Kohtumise aeg Berliinis: ${appointmentTimeBerlin.toString()}`);
console.log(`Kohtumise aeg Los Angeleses: ${appointmentTimeLA.toString()}`);
            

              
                Copy
              
            
          

• Vanuse arvutamine: Määrake kasutaja vanus tema sünnikuupäeva alusel. PlainDate võimaldab teil esindada sünnikuupäeva ilma ajavööndi teabeta.

            const birthDate = Temporal.PlainDate.from({ year: 1990, month: 5, day: 15 });
const today = Temporal.Now.plainDateISO();
const age = today.year - birthDate.year - (today.month < birthDate.month || (today.month === birthDate.month && today.day < birthDate.day) ? 1 : 0);
console.log(`Vanus: ${age}`);
            

              
                Copy
              
            
          

• Kuupäevade ja kellaaegade kuvamine erinevates vormingutes: Vormindage kuupäevad ja kellaajad vastavalt kasutaja lokaadile. Kuigi rahvusvahelistumise (Intl) funktsioonid on eraldi, saab Temporali objekte hõlpsasti vormindada, kasutades meetodit toLocaleString() või sarnaseid meetodeid koos Intl API funktsioonidega.

            const zonedDateTimeNow = Temporal.Now.zonedDateTimeISO('en-GB');
console.log(zonedDateTimeNow.toLocaleString('en-GB'));
console.log(zonedDateTimeNow.toLocaleString('de-DE'));
            

              
                Copy
              
            
          

• Sündmuste kestuse jälgimine: Arvutage sündmuse kestus ja kuvage see inimesele loetavas vormingus. Duration võimaldab teil esindada kahe kuupäeva või kellaaja vahet.

            const eventStart = Temporal.Instant.fromEpochSeconds(1700000000); // Näidis alguse ajatempel
const eventEnd = Temporal.Instant.fromEpochSeconds(1700005000);   // Näidis lõpu ajatempel
const durationOfEvent = eventEnd.since(eventStart);
console.log(`Sündmuse kestus: ${durationOfEvent.minutes} minutit`);
            

              
                Copy
              
            
          

Temporal API kasutamise parimad tavad

Siin on mõned parimad tavad, mida Temporal API kasutamisel meeles pidada:

• Kasutage muutumatust: Võtke omaks Temporali objektide muutumatus. Vältige objektide otsest muutmist. Selle asemel looge uusi objekte, kasutades selliseid meetodeid nagu add, subtract ja with.
• Käsitlege ajavööndeid hoolikalt: Olge kuupäevade ja kellaaegadega töötamisel ajavööndite suhtes tähelepanelik. Kasutage ZonedDateTime, kui peate esindama kuupäevi ja kellaaegu konkreetses ajavööndis.
• Kasutage selgeid muutujate nimesid: Kasutage kirjeldavaid muutujate nimesid, mis selgelt näitavad kasutatava Temporali objekti tüüpi (nt plainDate, zonedDateTime, duration).
• Kaaluge polütäiteid: Kuna Temporal on veel suhteliselt uus, tagage piisav tugi, kasutades vajadusel polütäite teeki.
• Valideerige sisend: Kontrollige alati kasutaja sisendit, veendumaks, et kuupäevad ja kellaajad on õiges vormingus.

Migreerimine vanalt Date'ilt

Migreerimine vanalt Date objektilt võib olla järkjärguline protsess. Kaaluge neid strateegiaid:

• Järk-järguline kasutuselevõtt: Alustage Temporali kasutamisega uues koodis, säilitades samal ajal Date oma rakenduse olemasolevates osades.
• Ümbrise funktsioonid: Looge ümbrise funktsioonid, mis teisendavad Date ja Temporali objektide vahel, et hõlbustada koostalitlusvõimet migreerimise ajal.
• Põhjalik testimine: Testige migreerimist põhjalikult, veendumaks, et kõik kuupäeva ja kellaaja arvutused on täpsed.

Temporal API vs. Moment.js

Moment.js oli populaarne teek kuupäeva ja kellaaja manipuleerimiseks JavaScriptis, kuid seda peetakse nüüd vananenud projektiks ja on hooldusrežiimis. Temporal API pakub moodsama ja standardiseeritud lahenduse, mis kõrvaldab paljud Moment.js puudused. Moment.js on muutlik ja sellel puudub kohalik ajavööndi tugi. Temporal API on muutumatu ja sellel on kohalik ajavööndi tugi.

Järeldus

JavaScripti Temporal API kujutab endast olulist edasiminekut vana Date objekti ees. Selle muutumatus, selge API, ajavööndi tugi ja kalendri tugi muudavad selle võimsaks tööriistaks kuupäevade ja kellaaegade käsitlemiseks kaasaegsetes JavaScripti rakendustes. Kuigi kasutuselevõtt on alles kasvanud, võimaldab polütäite kasutamine hakata selle eeliseid juba täna ära kasutama. Kuna API on laiemalt toetatud, eeldatakse, et sellest saab standardne viis kuupäevade ja kellaaegadega töötamiseks JavaScriptis.

Võtke omaks Temporal API ja avage tõhusam ja usaldusväärsem viis kuupäevade ja kellaaegade haldamiseks oma projektides, tagades, et teie rakendus käsitleb globaalseid ajavööndeid ja arvutusi täpselt.