Aproape orice fel de aplicație scrisă în JavaScript funcționează cu ore sau date într-o anumită calitate. La început, acest lucru a fost limitat la API-ul Date încorporat. Acest API include funcționalități de bază, dar este destul de limitat în ceea ce poate face. Bibliotecile terțe, cum ar fi Moment.js, și API-urile încorporate mai târziu, cum ar fi API-urile Intl și noul API Temporal, adaugă o flexibilitate mult mai mare lucrului cu ore și date. Ascensiunea și căderea momentului.js Moment.js este o bibliotecă JavaScript cu utilități puternice pentru lucrul cu ore și date. Include caracteristici lipsă din API-ul de bază Date, cum ar fi manipularea fusului orar, și simplifică multe operațiuni comune. Moment include și funcții de formatare a datelor și orelor. A devenit o bibliotecă utilizată pe scară largă în multe aplicații diferite. Cu toate acestea, Moment a avut și partea ei de probleme. Este o bibliotecă mare și se poate adăuga semnificativ la dimensiunea pachetului unei aplicații. Deoarece biblioteca nu acceptă treeking tree (o caracteristică a bundlerelor moderne care poate elimina părți neutilizate ale bibliotecilor), întreaga bibliotecă Moment este inclusă chiar dacă utilizați doar una sau două dintre funcțiile sale. O altă problemă cu Moment este faptul că obiectele pe care le creează sunt mutabile. Apelarea anumitor funcții pe un obiect Moment are efecte secundare și modifică valoarea acelui obiect. Acest lucru poate duce la un comportament neașteptat sau erori. În 2020, întreținătorii Moment au decis să pună biblioteca în modul de întreținere. Nu se realizează nicio dezvoltare de caracteristici noi, iar întreținerii recomandă să nu o folosească pentru proiecte noi. Există și alte biblioteci de date JavaScript, cum ar fi date-fns, dar există un nou player în oraș, un API integrat direct în JavaScript: Temporal. Este un nou standard care completează găurile API-ului original Date și rezolvă unele dintre limitările găsite în Moment și în alte biblioteci. Ce este temporal? Temporal este un nou API pentru oră și dată care este adăugat la standardul ECMAScript, care definește JavaScript modern. Din martie 20266, a ajuns la Etapa 4 a procesului TC39 (comitetul care supraveghează propunerile și completările la limbajul JavaScript) și va fi inclus în următoarea versiune a specificației ECMAScript. A fost deja implementat în mai multe browsere: Chrome 144+ și Firefox 139+, urmând ca Safari să urmeze în curând. Un polyfill este disponibil și pentru browserele neacceptate și pentru Node.js. API-ul Temporal creează obiecte care, în general, reprezintă momente în timp. Acestea pot fi ștampile cu normă întreagă și cu data într-un anumit fus orar sau pot fi o instanță generică a orei „ceas de perete” fără informații despre fus orar sau dată. Unele dintre principalele caracteristici ale Temporal includ:
Ore cu sau fără date. Un obiect temporal poate reprezenta o anumită oră la o anumită dată sau o oră fără nicio informație despre dată. Poate fi reprezentată și o anumită dată, fără oră. Suport pentru fusul orar. Obiectele temporare sunt pe deplin conștiente de fusul orar și pot fi convertite în diferite fusuri orare. Moment acceptă și fusurile orare, dar necesită biblioteca suplimentară de fus orar moment. Imuabilitate. Odată ce un obiect temporal este creat, acesta nu poate fi modificat. Conversiile aritmetice sau fus orar nu modifică obiectul de bază. În schimb, generează un nou obiect Temporal. Indexarea bazată pe 1. O sursă comună de erori cu API-ul Date (precum și cu Moment) este că lunile sunt indexate la zero. Aceasta înseamnă că ianuarie este luna 0, mai degrabă decât luna 1, așa cum înțelegem cu toții în viața reală. Temporal rezolvă acest lucru utilizând indexarea bazată pe 1 - ianuarie este luna 1. Este încorporat în browser. Deoarece Temporal este un API în browser în sine, nu adaugă nimic la dimensiunea pachetului aplicației dvs.
De asemenea, este important să rețineți că API-ul Date nu dispare. Deși Temporal înlocuiește acest API, acesta nu este eliminat sau depreciat. Multe aplicații s-ar rupe dacă browserele ar elimina brusc API-ul Date. Cu toate acestea, rețineți că Moment este acum considerat un proiect moștenit în modul de întreținere. În restul articolului, ne vom uita la câteva „rețete” pentru migrarea codului bazat pe moment la noul API Temporal. Să începem refactorizarea! Crearea obiectelor de dată și oră Înainte de a putea manipula datele și orele, trebuie să creăm obiecte care să le reprezinte. Pentru a crea un obiect Moment care reprezintă data și ora curente, utilizați funcția moment. const acum = moment(); console.log(acum); // Moment<2026-02-18T21:26:29-05:00>
Acest obiect poate fi acum formatat sau manipulat după cum este necesar.
// convertiți în UTC //avertisment: Aceasta modifică obiectul Moment și îl pune în modul UTC! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// imprimă un șir formatat - rețineți că acum folosește ora UTC console.log(now.format('LL/ZZ/AAAA hh:mm:ss a')); // 19.02.2026 02:27:07
Lucrul cheie de reținut despre Moment este că un obiect Moment include întotdeauna informații despre oră și dată. Dacă trebuie să lucrați doar cu informații despre oră, acest lucru este de obicei bine, dar poate provoca un comportament neașteptat în situații precum ora de vară sau anii bisecți, în care data poate avea un efect asupra calculelor de timp. Temporalul este mai flexibil. Puteți crea un obiect reprezentând data și ora curente prin crearea unui obiect Temporal.Instant. Acesta reprezintă un punct în timp definit de timpul de la „epocă” (miezul nopții UTC pe 1 ianuarie 1970). Temporal poate face referire la acest moment în timp cu o precizie la nivel de nanosecunde. const acum = Temporal.Now.instant();
// vezi nanosecunde brute de la epocă console.log(now.epochNanoseconds); // 1771466342612000000n
// format pentru UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format pentru un anumit fus orar console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Obiectele Temporal.Instant pot fi create și pentru o anumită oră și dată, utilizând metoda de la statică.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatați momentul în fusul orar local. Rețineți că aceasta controlează doar // formatarea - nu modifică obiectul așa cum o face moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
De asemenea, puteți crea și alte tipuri de obiecte temporale, inclusiv:
Temporal.PlainDate: O dată fără informații despre oră. Temporal.PlainTime: O oră fără informații despre dată. Temporal.ZonedDateTime: O dată și oră într-un anumit fus orar.
Fiecare dintre acestea are o metodă from care poate fi apelată cu un obiect care specifică data și/sau ora, sau un șir de date de analizat. // Doar o întâlnire const astăzi = Temporal.PlainDate.from({ Anul: 2026, luna: 2, // rețineți că folosim 2 pentru februarie ziua: 18 }); console.log(azi.toString()); // 2026-02-18
// Doar un timp const lunchTime = Temporal.PlainTime.from({ ora: 12 }); console.log(lunchTime.toString()); // 12:00:00
// O dată și o oră în fusul orar estic al SUA const dueAt = Temporal.ZonedDateTime.from({ fus orar: „America/New_York”, Anul: 2026, luna: 3, ziua: 1, ora: 12, minut: 0, secunda: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Analizarea Am acoperit crearea programatică a informațiilor despre dată și oră. Acum să ne uităm la analiza. Analiza este un domeniu în care Moment este mai flexibil decât API-ul Temporal încorporat. Puteți analiza un șir de date trecându-l la funcția moment. Cu un singur argument, Moment așteaptă un șir de dată ISO, dar puteți utiliza formate alternative dacă furnizați un al doilea argument care specifică formatul de dată utilizat.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'L/D/AA h:mm:ss');
console.log(isoDate); // Moment<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Moment<2026-02-21T09:00:00-05:00>
În versiunile mai vechi, Moment ar face cea mai bună presupunere pentru a analiza orice șir de dată formatat arbitrar. Acest lucru ar putea duce la rezultate imprevizibile. De exemplu, 02-03-2026 este 2 februarie sau 3 martie? Din acest motiv, versiunile mai noi de Moment afișează un avertisment de depreciere proeminent dacă este apelat fără un șir de dată formatat ISO (cu excepția cazului în care este dat și al doilea argument cu formatul dorit). Temporal va analiza doar un șir de dată formatat specific. Șirul trebuie să fie compatibil cu formatul ISO 8601 sau cu extensia sa, RFC 9557. Dacă un șir de dată neconform este transmis unei metode de la, Temporal va lansa un RangeError.
// Folosind un șir de dată RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Folosind un șir de date necunoscute const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Eroare temporală: caracter nevalid în timpul analizării valorii anului.
Cerințele exacte ale șirului de date depind de tipul de obiect temporal pe care îl creați. În exemplul de mai sus, Temporal.Instant necesită un ISO complet8601 sau RFC 9557 șir de dată care specifică data și ora cu o compensare a fusului orar, dar puteți crea și obiecte PlainDate sau PlainTime folosind doar un subset al formatului de dată. 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
Rețineți că aceste șiruri trebuie să respecte în continuare formatul așteptat, altfel va fi generată o eroare.
// Folosind șiruri de timp neconforme. Toate acestea vor arunca o RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Sfat profesionist: gestionarea șirurilor non-ISO Deoarece Temporal acordă prioritate fiabilității, nu va încerca să ghicească formatul unui șir precum 02-01-2026. Dacă sursa dvs. de date utilizează astfel de șiruri, va trebui să faceți o manipulare a șirurilor pentru a rearanja valorile într-un șir ISO, cum ar fi 2026-02-01, înainte de a încerca să îl utilizați cu Temporal.
Formatare Odată ce aveți un obiect Moment sau Temporal, probabil că veți dori să îl convertiți într-un șir formatat la un moment dat. Acesta este un exemplu în care Moment este puțin mai concis. Apelați metoda de formatare a obiectului cu un șir de jetoane care descriu formatul de dată dorit. const date = moment();
console.log(data.format('LL/ZZ/AAAA')); // 22.02.2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 februarie 2026, ora 20:18:30
Pe de altă parte, Temporal vă cere să fiți puțin mai pronunțat. Obiectele temporale, cum ar fi Instant, au o metodă toLocaleString care acceptă diverse opțiuni de formatare specificate ca proprietăți ale unui obiect.
const date = Temporal.Now.instant();
// fără argumente, vom obține formatul implicit pentru localitatea curentă console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (presupunând o locație de en-US)
// trece opțiuni de formatare pentru a genera un șir de format personalizat console.log(date.toLocaleString('en-US', { luna: „lung”, zi: „numeric”, anul: „numeric”, ora: „2 cifre”, minut: „2 cifre” })); // 22 februarie 2026 la 20:23
// trece doar câmpurile dorite în șirul de format console.log(date.toLocaleString('en-US', { luna: „scurtă”, zi: „numeric” })); // 22 februarie
Formatarea temporală a datei utilizează de fapt API-ul Intl.DateTimeFormat (care este deja disponibil în browserele moderne) sub capotă. Aceasta înseamnă că puteți crea un obiect DateTimeFormat reutilizabil cu opțiunile de formatare personalizate, apoi puteți trece obiecte Temporal la metoda sa de format. Din acest motiv, nu acceptă formate de date personalizate, așa cum o face Moment. Dacă aveți nevoie de ceva de genul „Q1 2026” sau de altă formatare specializată, este posibil să aveți nevoie de un cod personalizat de formatare a datei sau să ajungeți la o bibliotecă terță parte. const formatter = new Intl.DateTimeFormat('en-US', { luna: „2 cifre”, zi: „2 cifre”, anul: „numeric” });
const date = Temporal.Now.instant(); console.log(formatter.format(data)); // 22.02.2026
Indicatoarele de formatare ale momentului sunt mai simplu de scris, dar nu sunt prietenoase cu localul. Formatul conține „cod greu” lucruri precum ordinea lunii/zi. Avantajul utilizării unui obiect de configurare, așa cum face Temporal, este că acesta se va adapta automat la orice locație dată și va folosi formatul corect. const date = Temporal.Now.instant();
const formatOptions = { luna: „numeric”, zi: „numeric”, anul: „numeric” };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.02.2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Calcule date În multe aplicații, va trebui să ajungeți să efectuați unele calcule la o dată. Poate doriți să adăugați sau să scădeți unități de timp (zile, ore, secunde etc.). De exemplu, dacă aveți data curentă, este posibil să doriți să arătați utilizatorului data peste o săptămână. Obiectele moment au metode precum adunarea și scăderea care efectuează aceste operații. Aceste funcții iau o valoare și o unitate, de exemplu: add(7, 'zile'). O diferență foarte importantă între Moment și Temporal este că atunci când se efectuează aceste calcule de dată, obiectul de bază este modificat și valoarea sa inițială se pierde. const acum = moment();
console.log(acum); // Moment<2026-02-24T20:08:36-05:00>
const nextWeek = acum.add(7, 'zile'); console.log(săptămâna viitoare); // Moment<2026-03-03T20:08:36-05:00>
// Gotcha - obiectul original a fost mutat console.log(acum); // Moment<2026-03-03T20:08:36-05:00>
Pentru a evita pierderea datei inițiale, puteți apela la clonare pe obiectul Moment pentru a crea o copie. const acum= moment(); const nextWeek = now.clone().add(7, 'zile');
console.log(acum); // Moment<2026-02-24T20:12:55-05:00>
console.log(săptămâna viitoare); // Moment<2026-03-03T20:12:55-05:00>
Pe de altă parte, obiectele temporale sunt imuabile. Odată ce ați creat un obiect precum un Instant, PlainDate și așa mai departe, valoarea acelui obiect nu se va schimba niciodată. Obiectele temporale au și metode de adunare și scădere. Temporal este puțin pretențios cu privire la ce unități de timp pot fi adăugate la ce tipuri de obiecte. De exemplu, nu puteți adăuga zile la un Instant:
const acum = Temporal.Now.instant(); const nextWeek = acum.add({ zile: 7 }); // RangeError: Eroare temporală: Cea mai mare unitate nu poate fi o unitate de dată
Acest lucru se datorează faptului că obiectele Instant reprezintă un anumit moment în timp în UTC și sunt independente de calendar. Deoarece durata unei zile se poate modifica în funcție de regulile fusului orar, cum ar fi ora de vară, acest calcul nu este disponibil pe un Instant. Puteți, totuși, să efectuați această operație pe alte tipuri de obiecte, cum ar fi PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
const nextWeek = acum.add({ zile: 7 });
// Rețineți că PlainDateTime original rămâne neschimbat console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
De asemenea, puteți calcula cât timp este între două obiecte Moment sau Temporal. Cu funcția de diferență a Momentului, trebuie să furnizați o unitate pentru granularitate, altfel va returna diferența în milisecunde. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(data2.diff(data1)); // 91800000
console.log(data2.diff(data1, 'zile')); // 1
Pentru a face acest lucru cu un obiect Temporal, puteți trece un alt obiect Temporal la metodele sale până sau după. Aceasta returnează un obiect Temporal.Duration care conține informații despre diferența de timp. Obiectul Duration are proprietăți pentru fiecare componentă a diferenței și, de asemenea, poate genera un șir de durată ISO 8601 reprezentând diferența de timp.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// cea mai mare unitate specifică cea mai mare unitate de timp de reprezentat // în calculul duratei const diff = data2.de la (data1, { cea mai mareUnitate: 'zi' });
console.log(zile diferite); // 1
console.log(diff.hours); // 1
console.log(dif.minute); // 30
console.log(diff.toString()); // P1DT1H30M // (șir de durată ISO 8601: 1 zi, 1 oră, 30 de minute)
Compararea datelor și orelor Ambele Moment și Temporal vă permit să comparați datele și orele pentru a determina care este înaintea celuilalt, dar luați abordări diferite cu API. Moment oferă metode precum isBefore, isAfter și isSame pentru a compara două obiecte Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(data1.isBefore(data2)); // adevărat
Temporal folosește o metodă de comparare statică pentru a efectua o comparație între două obiecte de același tip. Returnează -1 dacă prima dată vine înainte de a doua, 0 dacă sunt egale sau 1 dacă prima dată vine după a doua. Următorul exemplu arată cum să comparați două obiecte PlainDate. Ambele argumente pentru Temporal.PlainDate.compare trebuie să fie obiecte PlainDate.
const date1 = Temporal.PlainDate.from({ year: 2026, month: 2, day: 24 }); const date2 = Temporal.PlainDate.from({ year: 2026, month: 3, day: 24 });
// data1 vine înaintea datei2, deci -1 console.log(Temporal.PlainDate.compare(data1, data2));
// Eroare dacă încercăm să comparăm două obiecte de tipuri diferite console.log(Temporal.PlainDate.compare(data1, Temporal.Now.instant())); // TypeError: Eroare temporală: Câmpuri PlainDate nevalide furnizate.
În special, acest lucru facilitează sortarea cronologică a unei serii de obiecte temporale. // O matrice de obiecte Temporal.PlainDate date const = [ ... ];
// folosiți Temporal.PlainDate.compare ca funcție de comparație date.sort(Temporal.PlainDate.compare);
Conversii de fus orar Biblioteca de bază Moment nu acceptă conversii de fus orar. Dacă aveți nevoie de această funcționalitate, trebuie să instalați și pachetul moment-timezone. Acest pachet nu poate fi agitat și, prin urmare, se poate adăuga semnificativ la dimensiunea pachetului. După ce ați instalat moment-timezone, puteți converti obiectele Moment în diferite fusuri orare cu metoda tz. Ca și în cazul altor operațiuni Moment, aceasta modifică subiacentulobiect. // Presupunând ora de est a SUA const acum = moment(); console.log(acum); // Moment<2026-02-28T20:08:20-05:00>
// Convertiți la ora Pacificului. // Timpul originar estic este pierdut. now.tz('America/Los_Angeles'); console.log(acum); // Moment<2026-02-28T17:08:20-08:00>
Funcționalitatea fusului orar este încorporată în API-ul Temporal atunci când se utilizează un obiect Temporal.ZonedDateTime. Aceste obiecte includ o metodă withTimeZone care returnează un nou ZonedDateTime reprezentând același moment în timp, dar în fusul orar specificat. // Din nou, presupunând ora de est a SUA const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
// Convertiți la ora Pacificului const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28.02.2026, 17:12:02 PST
// Obiectul original rămâne neschimbat console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
Notă: Valorile formatate returnate de toLocaleString sunt, după cum sugerează și numele, dependente de local. Exemplul de cod a fost dezvoltat în localitatea en-US, deci formatul este astfel: 2/28/2026, 5:12:02 PM PST. Într-o altă locație, acest lucru poate fi diferit. De exemplu, în localitatea en-GB, veți obține ceva de genul 28/2/2026, 17:12:02 GMT-8. O refactorizare din lumea reală Să presupunem că construim o aplicație pentru programarea evenimentelor pe fusurile orare. O parte a acestei aplicații este o funcție, getEventTimes, care are un șir ISO 8601 reprezentând ora și data evenimentului, un fus orar local și un fus orar țintă. Funcția creează șiruri formatate de oră și dată pentru eveniment în ambele fusuri orare. Dacă funcției i se dă un șir de intrare care nu este un șir de oră/dată valid, va genera o eroare. Iată implementarea originală, folosind Moment (care necesită și utilizarea pachetului moment-fus orar).
import moment din „moment-timezone”;
funcția getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Creați momentul inițial în fusul orar al utilizatorului const eventTime = moment.tz( inputString, moment.ISO_8601, // Așteptați un șir ISO 8601 adevărat, // Parsare strictă userTimeZone );
// Aruncă o eroare dacă inputString nu a reprezentat o dată validă dacă (!eventTime.isValid()) { throw new Error('Intrare data/ora nevalidă'); }
// 2. Calculați timpul țintă // CRITIC: Trebuie să clonăm, sau „eventTime” se schimbă pentru totdeauna! const targetTime = eventTime.clone().tz(targetTimeZone);
întoarce { local: eventTime.format(timeFormat), target: targetTime.format(timeFormat), }; }
const program = getEventTimes( „2026-03-05T15:00-05:00”, „America/New_York”, „Europa/Londra”, );
console.log(schedule.local); // 5 martie 2026, 3:00:00 pm EST
console.log(schedule.target); // 5 martie 2026, 20:00:00 GMT
În acest exemplu, folosim un format de dată așteptat ISO 8601, care este încorporat util în Moment. De asemenea, folosim o analiză strictă, ceea ce înseamnă că Moment nu va încerca să ghicească cu un șir de dată care nu se potrivește cu formatul. Dacă este trecut un șir de date non-ISO, va avea ca rezultat un obiect de dată nevalid și vom arunca o eroare. Implementarea temporală arată similară, dar are câteva diferențe cheie.
funcția getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analizați intrarea direct într-un Instant, apoi creați // un ZonedDateTime în zona utilizatorului. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Convertiți în zona țintă // Aceasta returnează automat un obiect NOU; „eventTime” este sigur. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatați folosind Intl (încorporat) opțiuni const = { anul: „numeric”, luna: „scurtă”, zi: „numeric”, oră: „numeric”, minut: „2 cifre”, a doua: „2 cifre”, timeZoneName: „scurt” };
întoarce { local: eventTime.toLocaleString(navigator.language, opțiuni), target: targetTime.toLocaleString(navigator.language, options) }; }
const program = getEventTimes( „2026-03-05T15:00-05:00”, „America/New_York”, „Europa/Londra”, );
console.log(schedule.local); // 5 martie 2026, 3:00:00 PM EST
console.log(schedule.target); // 5 martie 2026, 20:00:00 GMT
Cu Moment, trebuie să specificăm în mod explicit un șir de format pentru șirurile de date rezultate. Indiferent de locația sau locația utilizatorului, orele evenimentului vor fi întotdeauna formatate ca 5 martie 2026, 3:00:00pm EST. De asemenea, nu trebuie să aruncăm în mod explicit o excepție. Dacă un șir nevalid este transmis către Temporal.Instant.from, Temporal va arunca excepția pentru noi. Un lucru de remarcat este că, chiar și cu o analiză strictă, versiunea Moment este încă mai îngăduitoare. Temporal necesită decalajul fusului orar la sfârșitul șirului. De asemenea, trebuie să rețineți că, deoarece folosim navigator.language, acest cod va rula doar într-un mediu de browser, deoarece navigatorul nu este definit într-un mediu Node.js. Implementarea Temporal folosește localitatea curentă a browserului (navigator.language), astfel încât utilizatorul va primi automat orele evenimentelor formatate în formatul de timp local. În localitatea en-US, aceasta este 5 martie 2026, ora 3:00:00 EST. Cu toate acestea, dacă utilizatorul se află în Londra, de exemplu, orele evenimentului vor fi formatate ca 5 martie 2026, 15:00:00 GMT-5. Rezumat
Acțiune Moment.js Temporal Ora curentă moment() Temporal.Now.zonedDateTimeISO() Analizarea ISO moment(str) Temporal.Instant.from(str) Adăugați timp .add(7, „zile”) (modifică) .add({ zile: 7 }) (obiect nou) Diferența .diff(altele, „ore”) .de când(altele).ore Fus orar .tz(„Zonă/Nume”) .withTimeZone('Zona/Nume')
La prima vedere, diferența poate fi ușor diferită (și în cazul Sintaxei Temporal, uneori mai pronunțată și mai strictă), dar există mai multe avantaje cheie în utilizarea Temporal față de Moment.js:
A fi mai explicit înseamnă mai puține surprize și erori neintenționate. Momentul poate părea mai blând, dar implică „ghiciri”, care uneori poate duce la date incorecte. Dacă îi dai lui Temporal ceva invalid, se afișează o eroare. Dacă codul rulează, știi că ai o dată validă. Moment poate adăuga o dimensiune semnificativă pachetului aplicației, mai ales dacă utilizați pachetul moment-fus orar. Temporal nu adaugă nimic (odată ce este livrat în browserele țintă). Imuabilitatea vă oferă încrederea că nu veți pierde și nu veți suprascrie niciodată date atunci când efectuați conversii de date și operațiuni. Diferite reprezentări ale timpului (Instant, PlainDateTime, ZonedDateTime) în funcție de cerințele dvs., unde Moment este întotdeauna un înveliș în jurul unei mărci de timp UTC. Temporal folosește API-urile Intl pentru formatarea datei, ceea ce înseamnă că puteți avea formatare care ține cont de localitate fără a fi necesar să specificați în mod explicit token-uri.
Note despre Polyfill După cum am menționat mai devreme, există un Polyfill temporal disponibil, distribuit ca un pachet npm numit @js-temporal/polyfill. Dacă doriți să utilizați Temporal astăzi, veți avea nevoie de acest polyfill pentru a accepta browsere precum Safari care nu au livrat încă API-ul. Vestea proastă cu aceasta este că se va adăuga la dimensiunea pachetului dvs. Vestea bună este că încă adaugă mult mai puțin decât moment sau moment-fus orar. Iată o comparație a dimensiunilor pachetelor raportate de Bundlephobia.com, un site web care prezintă informații despre dimensiunile pachetelor npm (faceți clic pe numele fiecărui pachet pentru a vedea analiza Bundlephobia):
Pachet Minimizat Minimizat și arhivat @js-temporal/polyfill 154,1 kB 44,1 kB moment 294,4 kB 75,4 kB moment-fus orar 1 MB 114,2 kB
Polifill-ul a avut istoric și unele probleme de performanță în ceea ce privește utilizarea memoriei și, la momentul scrierii, este considerat a fi într-o stare alfa. Din acest motiv, este posibil să nu doriți să-l utilizați în producție până când nu ajunge la o stare mai matură. Cealaltă veste bună este că sperăm că polifill-ul nu va mai fi nevoie de mult (cu excepția cazului în care trebuie să suportați browsere mai vechi, desigur). La momentul scrierii, Temporal a fost livrat în Chrome, Edge și Firefox. Nu este încă gata în Safari, deși pare să fie disponibil cu un semnalizator de rulare în cea mai recentă previzualizare tehnologică.
