Gotovo svaka vrsta aplikacije napisana u JavaScript-u radi s vremenom ili datumima u nekom svojstvu. U početku je ovo bilo ograničeno na ugrađeni Date API. Ovaj API uključuje osnovnu funkcionalnost, ali je prilično ograničen u onome što može učiniti. Biblioteke trećih strana kao što je Moment.js, a kasnije i ugrađeni API-ji kao što su Intl API-ji i novi Temporal API, dodaju mnogo veću fleksibilnost radu sa vremenima i datumima. Uspon i pad trenutka.js Moment.js je JavaScript biblioteka sa moćnim uslužnim programima za rad sa vremenima i datumima. Uključuje funkcije koje nedostaju iz osnovnog API-ja za datum, kao što je manipulacija vremenskom zonom, i čini mnoge uobičajene operacije jednostavnijim. Moment također uključuje funkcije za formatiranje datuma i vremena. Postala je široko korištena biblioteka u mnogim različitim aplikacijama. Međutim, Moment je također imao svoje probleme. To je velika biblioteka i može značajno povećati veličinu paketa aplikacije. Budući da biblioteka ne podržava potresanje stabla (karakteristiku modernih paketa koji mogu ukloniti neiskorištene dijelove biblioteka), cijela biblioteka Moment je uključena čak i ako koristite samo jednu ili dvije njene funkcije. Još jedan problem sa Momentom je činjenica da su objekti koje stvara promjenjivi. Pozivanje određenih funkcija na objektu Moment ima nuspojave i mutira vrijednost tog objekta. To može dovesti do neočekivanog ponašanja ili grešaka. U 2020. godini, održavatelji Momenta odlučili su da stave biblioteku u režim održavanja. Ne radi se na razvoju novih karakteristika, a održavaoci preporučuju da se ne koriste za nove projekte. Postoje i druge JavaScript biblioteke datuma, kao što je date-fns, ali postoji novi igrač u gradu, API ugrađen direktno u JavaScript: Temporal. To je novi standard koji popunjava rupe u originalnom Date API-ju, kao i rješava neka ograničenja koja se nalaze u Momentu i drugim bibliotekama. Šta je temporalno? Temporal je novi API za vrijeme i datum koji se dodaje standardu ECMAScript, koji definira moderni JavaScript. Od marta 20266, dostigao je 4. fazu procesa TC39 (komitet koji nadgleda predloge i dodatke JavaScript jeziku), i biće uključen u sledeću verziju specifikacije ECMAScript. Već je implementiran u nekoliko pretraživača: Chrome 144+ i Firefox 139+, a uskoro se očekuje i Safari. Polifil je takođe dostupan za nepodržane pretraživače i Node.js. Temporal API kreira objekte koji, općenito, predstavljaju trenutke u vremenu. To mogu biti oznake punog radnog vremena i datuma u datoj vremenskoj zoni, ili mogu biti generički primjer vremena „zidnog sata“ bez ikakvih informacija o vremenskoj zoni ili datumu. Neke od glavnih karakteristika Temporal-a uključuju:
Vremena sa ili bez datuma. Temporalni objekat može predstavljati određeno vreme na određeni datum ili vreme bez ikakvih informacija o datumu. Određeni datum, bez vremena, također može biti predstavljen. Podrška za vremensku zonu. Temporalni objekti su potpuno svjesni vremenske zone i mogu se konvertirati u različite vremenske zone. Moment također podržava vremenske zone, ali zahtijeva dodatnu biblioteku trenutak-vremenske zone. Nepromjenjivost. Jednom kada je Temporal objekat kreiran, ne može se mijenjati. Vremenska aritmetika ili konverzije vremenske zone ne modificiraju osnovni objekt. Umjesto toga, generiraju novi temporalni objekt. Indeksiranje zasnovano na 1. Uobičajeni izvor grešaka sa Date API-jem (kao i sa Momentom) je da su meseci nulto indeksirani. To znači da je januar mjesec 0, a ne mjesec 1 kako svi razumijemo u stvarnom životu. Vremenski popravlja ovo korišćenjem indeksiranja zasnovanog na 1 - januar je mesec 1. Ugrađen je u pretraživač. Pošto je Temporal API u samom pretraživaču, on ništa ne dodaje veličini paketa vaše aplikacije.
Takođe je važno napomenuti da API za datum neće nestati. Iako Temporal zamjenjuje ovaj API, on se ne uklanja niti odbacuje. Mnoge aplikacije bi se pokvarile ako bi pretraživači iznenada uklonili Date API. Međutim, također imajte na umu da se Moment sada smatra naslijeđenim projektom u načinu održavanja. U ostatku članka, pogledat ćemo neke "recepte" za migraciju koda baziranog na Momentu na novi Temporal API. Počnimo sa preuređivanjem! Kreiranje objekata datuma i vremena Prije nego što možemo manipulirati datumima i vremenom, moramo kreirati objekte koji ih predstavljaju. Za kreiranje objekta Moment koji predstavlja trenutni datum i vrijeme, koristite funkciju moment. const sada = moment(); console.log(sada); // Trenutak<2026-02-18T21:26:29-05:00>
Ovaj objekt se sada može formatirati ili njime manipulirati po potrebi.
// pretvoriti u UTC //upozorenje: Ovo mutira objekt Moment i stavlja ga u UTC mod! console.log(sada.utc()); // Trenutak<2026-02-19T02:26:29Z>
// ispisuje formatirani niz - imajte na umu da sada koristi UTC vrijeme console.log(now.format('MM/DD/GGGG hh:mm:ss a')); // 19.02.2026 02:27:07 ujutro
Ključna stvar koju treba zapamtiti o Momentu je da objekt Moment uvijek uključuje informacije o vremenu i datumu. Ako trebate raditi samo s informacijama o vremenu, to je obično u redu, ali može uzrokovati neočekivano ponašanje u situacijama kao što su ljetno računanje vremena ili prijestupne godine, gdje datum može utjecati na izračunavanje vremena. Temporalni je fleksibilniji. Možete kreirati objekt koji predstavlja trenutni datum i vrijeme kreiranjem Temporal.Instant objekta. Ovo predstavlja tačku u vremenu definisanu vremenom od "epohe" (ponoć UTC 1. januara 1970.). Temporal može referencirati ovaj trenutak u vremenu s preciznošću na nivou nanosekunde. const now = Temporal.Now.instant();
// vidi sirove nanosekunde od epohe console.log(now.epochNanoseconds); // 1771466342612000000n
// format za UTC console.log(sada.toString()); // 2026-02-19T01:55:27.844Z
// format za određenu vremensku zonu console.log(now.toString({ vremenska zona: 'Amerika/Nju_Jork' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant objekti se također mogu kreirati za određeno vrijeme i datum korištenjem statičke metode from.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatirajte trenutak u lokalnoj vremenskoj zoni. Imajte na umu da ovo samo kontroliše // formatiranje - ne mijenja objekt kao moment.utc. console.log(myInstant.toString({ vremenska zona: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Također možete kreirati druge vrste temporalnih objekata, uključujući:
Temporal.PlainDate: Datum bez informacija o vremenu. Temporal.PlainTime: Vrijeme bez informacija o datumu. Temporal.ZonedDateTime: Datum i vrijeme u određenoj vremenskoj zoni.
Svaki od njih ima metodu from koja se može pozvati sa objektom koji specificira datum i/ili vrijeme, ili nizom datuma za raščlanjivanje. // Samo spoj const today = Temporal.PlainDate.from({ godina: 2026, mjesec: 2, // imajte na umu da koristimo 2 za februar dan: 18 }); console.log(danas.toString()); // 2026-02-18
// Samo vrijeme const lunchTime = Temporal.PlainTime.from({ sat: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Datum i vrijeme u istočnoj vremenskoj zoni SAD const dueAt = Temporal.ZonedDateTime.from({ vremenska zona: 'America/New_York', godina: 2026, mjesec: 3, dan: 1, sat: 12, minuta: 0, drugo: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Parsing Pokrili smo programsko kreiranje informacija o datumu i vremenu. Pogledajmo sada raščlanjivanje. Parsing je jedno područje u kojem je Moment fleksibilniji od ugrađenog Temporal API-ja. Niz datuma možete raščlaniti tako što ćete ga proslijediti funkciji momenta. Sa jednim argumentom, Moment očekuje ISO niz datuma, ali možete koristiti alternativne formate ako navedete drugi argument koji navodi format datuma koji se koristi.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/GG h:mm:ss');
console.log(isoDate); // Trenutak<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Trenutak<2026-02-21T09:00:00-05:00>
U starijim verzijama, Moment bi najbolje pogodio da analizira bilo koji proizvoljno formatirani niz datuma. To bi moglo dovesti do nepredvidivih rezultata. Na primjer, da li je 02-03-2026 2. februar ili 3. mart? Iz tog razloga, novije verzije Momenta prikazuju uočljivo upozorenje o zastarjelosti ako se poziva bez ISO formatiranog niza datuma (osim ako nije naveden i drugi argument sa željenim formatom). Temporal će analizirati samo posebno formatiran niz datuma. Niz mora biti usklađen sa ISO 8601 formatom ili njegovom ekstenzijom, RFC 9557. Ako se neusaglašeni niz datuma prosljeđuje metodi from, Temporal će izbaciti RangeError.
// Korištenje niza datuma RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ vremenska zona: 'Amerika/Nju_Jork' })); // 2026-02-21T09:00:00-05:00
// Korištenje nepoznatog niza datuma const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Vremenska greška: Nevažeći znak prilikom raščlanjivanja vrijednosti godine.
Tačni zahtjevi niza datuma zavise od vrste temporalnog objekta koji kreirate. U gornjem primjeru, Temporal.Instant zahtijeva puni ISO8601 ili RFC 9557 niz datuma koji specificira datum i vrijeme sa pomakom vremenske zone, ali također možete kreirati PlainDate ili PlainTime objekte koristeći samo podskup formata datuma. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Imajte na umu da ovi nizovi i dalje moraju biti u skladu s očekivanim formatom ili će se pojaviti greška.
// Korištenje vremenskih nizova koji nisu usklađeni. Sve ovo će baciti RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profesionalni savjet: Rukovanje ne-ISO stringovima Budući da Temporal daje prednost pouzdanosti, neće pokušati pogoditi format niza kao što je 02-01-2026. Ako vaš izvor podataka koristi takve stringove, morat ćete izvršiti neke manipulacije nizovima kako biste preuredili vrijednosti u ISO string kao što je 2026-02-01 prije nego što ga pokušate koristiti s Temporal-om.
Formatiranje Jednom kada imate objekat Moment ili Temporal, vjerovatno ćete ga u nekom trenutku htjeti pretvoriti u formatirani niz. Ovo je slučaj kada je Moment malo sažetiji. Metodu formata objekta pozivate sa nizom tokena koji opisuju željeni format datuma. const datum = moment();
console.log(date.format('MM/DD/GGGG')); // 22.02.2026
console.log(date.format('MMMM do GGGG, h:mm:ss a')); // 22. februar 2026, 20:18:30
S druge strane, Temporal zahtijeva da budete malo više opširniji. Temporalni objekti, kao što je Instant, imaju metodu toLocaleString koja prihvaća različite opcije oblikovanja specificirane kao svojstva objekta.
const datum = Temporal.Now.instant();
// bez argumenata, dobit ćemo zadani format za trenutni lokal console.log(date.toLocaleString()); // 22.02.2026., 20:23:36 (pod pretpostavkom da je lokacija en-US)
// propušta opcije formatiranja za generiranje prilagođenog formatnog niza console.log(date.toLocaleString('en-US', { mjesec: 'dug', dan: 'numerički', godina: 'numerički', sat: '2-cifren', minuta: '2-cifren' })); // 22. februar 2026. u 20:23
// samo proslijedite polja koja želite u format stringu console.log(date.toLocaleString('en-US', { mjesec: 'kratak', dan: 'numerički' })); // 22. feb
Vremensko formatiranje datuma zapravo koristi Intl.DateTimeFormat API (koji je već lako dostupan u modernim pretraživačima) ispod haube. To znači da možete kreirati objekt DateTimeFormat za višekratnu upotrebu sa svojim prilagođenim opcijama oblikovanja, a zatim proslijediti temporalne objekte njegovoj metodi formatiranja. Zbog toga ne podržava prilagođene formate datuma kao Moment. Ako vam treba nešto poput 'Q1 2026' ili drugo specijalizovano formatiranje, možda će vam trebati neki prilagođeni kod za formatiranje datuma ili posegnuti za bibliotekom treće strane. const formatter = new Intl.DateTimeFormat('en-US', { mjesec: '2-cifren', dan: '2-cifren', godina: 'numerički' });
const datum = Temporal.Now.instant(); console.log(formatter.format(datum)); // 22.02.2026
Tokeni za formatiranje Momenta jednostavniji su za pisanje, ali nisu prilagođeni lokalizaciji. Format stringova "tvrdi kod" stvari kao što je redoslijed mjesec/dan. Prednost korištenja konfiguracijskog objekta, kao što to čini Temporal, je u tome što će se automatski prilagoditi bilo kojem lokalu i koristiti ispravan format. const datum = Temporal.Now.instant();
const formatOptions = { mjesec: 'numerički', dan: 'numerički', godina: 'numerički' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.2.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Kalkulacije datuma U mnogim aplikacijama morat ćete na kraju izvršiti neke proračune na datum. Možda želite da dodate ili oduzmete jedinice vremena (dane, sate, sekunde, itd.). Na primjer, ako imate trenutni datum, možda ćete htjeti pokazati korisniku datum za 1 sedmicu od sada. Objekti momenta imaju metode kao što su zbrajanje i oduzimanje koje izvode ove operacije. Ove funkcije uzimaju vrijednost i jedinicu, na primjer: add(7, 'days'). Jedna vrlo bitna razlika između Momenta i Temporal-a, međutim, je ta što se prilikom izvođenja ovih izračunavanja datuma, osnovni objekt mijenja i gubi njegova originalna vrijednost. const sada = moment();
console.log(sada); // Trenutak<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dana'); console.log(sljedeća sedmica); // Trenutak<2026-03-03T20:08:36-05:00>
// Shvatio sam - originalni objekt je mutiran console.log(sada); // Trenutak<2026-03-03T20:08:36-05:00>
Da biste izbjegli gubitak originalnog datuma, možete pozvati clone na objektu Moment da kreirate kopiju. const now= moment(); const nextWeek = now.clone().add(7, 'dana');
console.log(sada); // Trenutak<2026-02-24T20:12:55-05:00>
console.log(sljedeća sedmica); // Trenutak<2026-03-03T20:12:55-05:00>
S druge strane, temporalni objekti su nepromjenjivi. Jednom kada kreirate objekt kao što je Instant, PlainDate i tako dalje, vrijednost tog objekta se nikada neće promijeniti. Temporalni objekti također imaju metode dodavanja i oduzimanja. Temporal je malo izbirljiv oko toga koje vremenske jedinice se mogu dodati kojim tipovima objekata. Na primjer, ne možete dodati dane u Instant:
const now = Temporal.Now.instant(); const nextWeek = now.add({ days: 7 }); // RangeError: Vremenska greška: Najveća jedinica ne može biti jedinica datuma
To je zato što Instant objekti predstavljaju određenu tačku u vremenu u UTC-u i agnostički su na kalendar. Budući da se dužina dana može promijeniti na osnovu pravila vremenske zone kao što je ljetno računanje vremena, ovaj izračun nije dostupan na Instantu. Međutim, ovu operaciju možete izvesti na drugim tipovima objekata, kao što je PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026., 20:23:59
const nextWeek = now.add({ days: 7 });
// Imajte na umu da originalni PlainDateTime ostaje nepromijenjen console.log(now.toLocaleString()); // 24.02.2026., 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Također možete izračunati koliko je vremena prošlo između dva objekta Moment ili Temporal. Sa Momentovom diff funkcijom, morate dati jedinicu za granularnost, inače će vratiti razliku u milisekundama. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(datum2.diff(datum1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
Da biste to učinili s temporalnim objektom, možete proslijediti drugi temporalni objekt njegovim metodama do ili since. Ovo vraća Temporal.Duration objekt koji sadrži informacije o vremenskoj razlici. Objekt Duration ima svojstva za svaku komponentu razlike, a također može generirati ISO 8601 niz trajanja koji predstavlja vremensku razliku.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// najveća jedinica specificira najveću jedinicu vremena za predstavljanje // u proračunu trajanja const diff = date2.since(datum1, { najveća jedinica: 'dan' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 niz trajanja: 1 dan, 1 sat, 30 minuta)
Poređenje datuma i vremena Moment i Temporal vam omogućavaju da uporedite datume i vremena da odredite koji dolazi ispred drugog, ali koristite različite pristupe sa API-jem. Moment pruža metode kao što su isBefore, isAfter i isSame za poređenje dva objekta Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(datum1.isBefore(datum2)); // istina
Temporal koristi statičku metodu poređenja da izvrši poređenje između dva objekta istog tipa. Vraća -1 ako prvi datum dolazi prije drugog, 0 ako su jednaki ili 1 ako prvi datum dolazi nakon drugog. Sljedeći primjer pokazuje kako uporediti dva PlainDate objekta. Oba argumenta za Temporal.PlainDate.compare moraju biti PlainDate objekti.
const date1 = Temporal.PlainDate.from({ godina: 2026, mjesec: 2, dan: 24 }); const date2 = Temporal.PlainDate.from({ godina: 2026, mjesec: 3, dan: 24 });
// datum1 dolazi prije datuma2, dakle -1 console.log(Temporal.PlainDate.compare(datum1, date2));
// Greška ako pokušamo uporediti dva objekta različitih tipova console.log(Temporal.PlainDate.compare(datum1, Temporal.Now.instant())); // TypeError: Vremenska greška: navedena su nevažeća polja PlainDate.
Konkretno, ovo olakšava sortiranje niza Temporal objekata hronološki. // Niz Temporal.PlainDate objekata konst datumi = [ ... ];
// koristi Temporal.PlainDate.compare kao funkciju komparatora dates.sort(Temporal.PlainDate.compare);
Pretvorbe vremenske zone Osnovna biblioteka Moment ne podržava konverzije vremenskih zona. Ako vam je potrebna ova funkcionalnost, također morate instalirati paket moment-vremenske zone. Ovaj paket se ne može protresti i stoga može značajno povećati veličinu vašeg paketa. Nakon što instalirate moment-vremensku zonu, možete pretvoriti objekte Moment u različite vremenske zone pomoću tz metode. Kao i kod drugih Moment operacija, ovo mutira temeljobjekt. // Pretpostavljajući američko istočno vrijeme const sada = moment(); console.log(sada); // Trenutak<2026-02-28T20:08:20-05:00>
// Pretvori u pacifičko vrijeme. // Izvorno istočno vrijeme je izgubljeno. now.tz('Amerika/Los_Angeles'); console.log(sada); // Trenutak<2026-02-28T17:08:20-08:00>
Funkcionalnost vremenske zone ugrađena je u Temporal API kada se koristi objekt Temporal.ZonedDateTime. Ovi objekti uključuju withTimeZone metodu koja vraća novi ZonedDateTime koji predstavlja isti trenutak u vremenu, ali u navedenoj vremenskoj zoni. // Opet, uz pretpostavku američkom istočnom vremenu const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.2.2026., 20:12:02 EST
// Pretvori u pacifičko vrijeme const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28.2.2026., 17:12:02 PST
// Originalni objekt ostaje nepromijenjen console.log(now.toLocaleString()); // 28.2.2026., 20:12:02 EST
Napomena: Formatirane vrijednosti koje vraća toLocaleString su, kao što naziv implicira, zavisne od lokalizacije. Primjer koda je razvijen u en-US lokalu, tako da je format ovakav: 28.2.2026, 17:12:02 PST. Na drugom lokalitetu ovo može biti drugačije. Na primjer, u en-GB lokalizaciji, dobili biste nešto poput 28/2/2026, 17:12:02 GMT-8. Refaktoring u stvarnom svijetu Pretpostavimo da pravimo aplikaciju za zakazivanje događaja u različitim vremenskim zonama. Dio ove aplikacije je funkcija getEventTimes, koja uzima ISO 8601 niz koji predstavlja vrijeme i datum događaja, lokalnu vremensku zonu i ciljnu vremensku zonu. Funkcija kreira formatirane nizove vremena i datuma za događaj u obje vremenske zone. Ako se funkciji dodijeli ulazni niz koji nije važeći niz vremena/datuma, ispostavit će grešku. Evo originalne implementacije, koristeći Moment (također zahtijeva korištenje paketa trenutak-vremenska zona).
uvoz trenutka iz 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, GGGG, h:mm:ss a z';
// 1. Kreirajte početni trenutak u vremenskoj zoni korisnika const eventTime = moment.tz( inputString, moment.ISO_8601, // Očekujte ISO 8601 niz true, // Strogo raščlanjivanje userTimeZone );
// Dobacuje grešku ako inputString ne predstavlja važeći datum if (!eventTime.isValid()) { throw new Error('Neispravan unos datuma/vremena'); }
// 2. Izračunajte ciljno vrijeme // KRITIČNO: Moramo klonirati, ili se 'eventTime' zauvijek mijenja! const targetTime = eventTime.clone().tz(targetTimeZone);
vrati { lokalno: eventTime.format(timeFormat), cilj: targetTime.format(timeFormat), }; }
const raspored = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', 'Evropa/London', );
console.log(schedule.local); // 5. mart 2026, 15:00:00 EST
console.log(schedule.target); // 5. mart 2026., 20:00:00 GMT
U ovom primjeru koristimo očekivani format datuma ISO 8601, koji je korisno ugrađen u Moment. Također koristimo striktno raščlanjivanje, što znači da Moment neće pokušati pogoditi s nizom datuma koji ne odgovara formatu. Ako se prenese niz datuma koji nije ISO, to će rezultirati nevažećim objektom datuma, a mi ćemo izbaciti grešku. Temporal implementacija izgleda slično, ali ima nekoliko ključnih razlika.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Parsirajte ulaz direktno u Instant, a zatim kreirajte // ZonedDateTime u zoni korisnika. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Pretvori u ciljnu zonu // Ovo automatski vraća NOVI objekat; 'eventTime' je sigurno. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatiranje koristeći Intl (ugrađeno) const options = { godina: 'numerički', mjesec: 'kratak', dan: 'numerički', sat: 'numerički', minuta: '2-cifrena', drugi: '2-cifren', timeZoneName: 'kratko' };
vrati { lokalno: eventTime.toLocaleString(navigator.language, options), cilj: targetTime.toLocaleString(navigator.language, opcije) }; }
const raspored = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', 'Evropa/London', );
console.log(schedule.local); // 5. marta 2026., 15:00:00 EST
console.log(schedule.target); // 5. mart 2026., 20:00:00 GMT
Sa Momentom, moramo eksplicitno specificirati niz formata za rezultirajuće nizove datuma. Bez obzira na lokaciju ili lokalizaciju korisnika, vremena događaja uvijek će biti formatirana kao 5. mart 2026., 3:00:00pm EST. Također, ne moramo eksplicitno baciti izuzetak. Ako je nevažeći string proslijeđen Temporal.Instant.from, Temporal će izbaciti izuzetak umjesto nas. Jedna stvar koju treba napomenuti je da je čak i sa striktnim raščlanjivanjem, verzija Momenta i dalje blaža. Temporal zahtijeva pomak vremenske zone na kraju niza. Takođe treba da imate na umu da pošto koristimo navigator.language, ovaj kod će se izvoditi samo u okruženju pretraživača, pošto navigator nije definisan u okruženju Node.js. Temporal implementacija koristi trenutnu lokalizaciju pretraživača (navigator.language), tako da će korisnik automatski dobiti vremena događaja formatirana u svom lokalnom formatu vremena. U en-US lokalu, ovo je 5. mart 2026., 15:00:00 EST. Međutim, ako je korisnik u Londonu, na primjer, vrijeme događaja će biti formatirano kao 5. mart 2026., 15:00:00 GMT-5. Rezime
Akcija Moment.js Vremenski Trenutno vrijeme trenutak() Temporal.Now.zonedDateTimeISO() Parsing ISO trenutak(str) Temporal.Instant.from(str) Dodaj vrijeme .add(7, 'dana') (mutira) .add({ dana: 7 }) (novi objekat) Razlika .diff(ostalo, 'sati') .od(ostalo).sati Vremenska zona .tz('Zona/Naziv') .withTimeZone('Zona/Ime')
Na prvi pogled, razlika može biti malo drugačija (iu slučaju Temporal, ponekad opširnija i stroža) sintaksa, ali postoji nekoliko ključnih prednosti korištenja Temporal u odnosu na Moment.js:
Biti eksplicitniji znači manje iznenađenja i neželjenih grešaka. Moment se može činiti blažim, ali uključuje "nagađanje", što ponekad može rezultirati netačnim datumima. Ako Temporal-u date nešto nevažeće, on će prikazati grešku. Ako se kod pokrene, znate da imate ispravan datum. Moment može dodati značajnu veličinu paketu aplikacije, posebno ako koristite paket trenutak-vremenska zona. Temporal ne dodaje ništa (kada se pošalje u vaše ciljne pretraživače). Nepromjenjivost vam daje sigurnost da nikada nećete izgubiti ili prepisati podatke prilikom izvođenja konverzija datuma i operacija. Različiti prikazi vremena (Instant, PlainDateTime, ZonedDateTime) ovisno o vašim zahtjevima, gdje je Moment uvijek omotač oko UTC vremenske oznake. Temporal koristi Intl API-je za formatiranje datuma, što znači da možete imati formatiranje svjesno lokalizacije bez potrebe da eksplicitno specificirate tokene.
Bilješke o polifilu Kao što je ranije spomenuto, dostupan je Temporal polyfill, distribuiran kao npm paket pod nazivom @js-temporal/polyfill. Ako želite koristiti Temporal danas, trebat će vam ovaj polifil za podršku pretraživačima kao što je Safari koji još nisu isporučili API. Loša vijest s ovim je da će povećati veličinu vašeg paketa. Dobra vijest je da i dalje dodaje znatno manje od momenta ili moment-vremenske zone. Evo poređenja veličina paketa prema Bundlephobia.com, web stranici koja predstavlja informacije o veličinama npm paketa (kliknite na naziv svakog paketa da vidite analizu Bundlephobia):
Paket Minifikovano Minimizirano i gzipovano @js-temporal/polyfill 154,1 kB 44,1 kB moment 294,4 kB 75,4 kB trenutak-vremenska zona 1 MB 114,2 kB
Polifil je također povijesno imao problema s performansama oko korištenja memorije, a u vrijeme pisanja smatra se da je u alfa stanju. Zbog toga ga možda nećete htjeti koristiti u proizvodnji dok ne dostigne zrelije stanje. Druga dobra vijest je da se nadamo da polyfill više neće biti potreban (osim ako ne trebate podržavati starije pretraživače, naravno). U vrijeme pisanja, Temporal se isporučivao u Chromeu, Edgeu i Firefoxu. Još nije sasvim spreman u Safariju, iako se čini da je dostupan sa zastavicom za vrijeme izvođenja u najnovijem tehnološkom pregledu.
