Почти всеки вид приложение, написано на JavaScript, работи с часове или дати в някакъв капацитет. В началото това беше ограничено до вградения API за дати. Този API включва основна функционалност, но е доста ограничен в това, което може да прави. Библиотеки на трети страни като Moment.js и по-късно вградени API, като Intl API и новия Temporal API, добавят много по-голяма гъвкавост към работата с часове и дати. Възходът и падението на Moment.js Moment.js е JavaScript библиотека с мощни помощни програми за работа с часове и дати. Той включва липсващи функции от основния API за дати, като манипулиране на часови зони, и прави много общи операции по-лесни. Moment също така включва функции за форматиране на дати и часове. Тя стана широко използвана библиотека в много различни приложения. Въпреки това, Moment също имаше своя дял от проблемите. Това е голяма библиотека и може да увеличи значително размера на пакета на приложението. Тъй като библиотеката не поддържа дървовидно разклащане (функция на съвременните пакети, които могат да премахват неизползвани части от библиотеки), цялата библиотека Moment е включена дори ако използвате само една или две от нейните функции. Друг проблем с Moment е фактът, че обектите, които създава, са променливи. Извикването на определени функции на обект Moment има странични ефекти и променя стойността на този обект. Това може да доведе до неочаквано поведение или грешки. През 2020 г. поддържащите Moment решиха да поставят библиотеката в режим на поддръжка. Не се разработват нови функции и поддържащите препоръчват да не се използва за нови проекти. Има и други JavaScript библиотеки с дати, като date-fns, но има нов играч в града, API, вграден директно в JavaScript: Temporal. Това е нов стандарт, който запълва дупките на оригиналния API за дати, както и разрешава някои от ограниченията, открити в Moment и други библиотеки. Какво е темпорално? Temporal е нов API за време и дата, който се добавя към стандарта ECMAScript, който дефинира съвременния JavaScript. От март 2026 г. той достигна етап 4 от процеса TC39 (комитетът, който наблюдава предложенията и допълненията към езика JavaScript) и ще бъде включен в следващата версия на спецификацията на ECMAScript. Той вече е внедрен в няколко браузъра: Chrome 144+ и Firefox 139+, като Safari се очаква да последва скоро. Полифил също е наличен за неподдържани браузъри и Node.js. Temporal API създава обекти, които обикновено представляват моменти във времето. Те могат да бъдат печати за пълен работен ден и дата в дадена часова зона или могат да бъдат общ екземпляр на време „стенен часовник“ без информация за часова зона или дата. Някои от основните характеристики на Temporal включват:
Часове със или без дати. Времевият обект може да представлява конкретно време на конкретна дата или време без информация за дата. Може да бъде представена и конкретна дата без час. Поддръжка на часови зони. Временните обекти са напълно запознати с часовите зони и могат да бъдат конвертирани в различни часови зони. Moment поддържа и часови зони, но изисква допълнителната библиотека момент-часови зони. Неизменност. След като временен обект е създаден, той не може да бъде променен. Преобразуването на времева аритметика или часова зона не променя основния обект. Вместо това те генерират нов временен обект. Индексиране на база 1. Често срещан източник на грешки с API за дата (както и с Moment) е, че месеците са индексирани с нула. Това означава, че януари е месец 0, а не месец 1, както всички разбираме в реалния живот. Temporal коригира това чрез използване на индексиране на база 1 — януари е месец 1. Той е вграден в браузъра. Тъй като Temporal е API в самия браузър, той не добавя нищо към размера на пакета на вашето приложение.
Също така е важно да се отбележи, че API за дати няма да изчезне. Въпреки че Temporal заменя този API, той не се премахва или отхвърля. Много приложения биха се счупили, ако браузърите изведнъж премахнат API за дата. Имайте предвид обаче, че Moment вече се счита за наследен проект в режим на поддръжка. В останалата част от статията ще разгледаме някои „рецепти“ за мигриране на Moment-базиран код към новия Temporal API. Да започнем преработването! Създаване на обекти за дата и час Преди да можем да манипулираме датите и часовете, трябва да създадем обекти, които ги представят. За да създадете обект Moment, представящ текущата дата и час, използвайте функцията moment. const сега = момент(); console.log(сега); // Момент<2026-02-18T21:26:29-05:00>
Този обект вече може да бъде форматиран или манипулиран според нуждите.
// конвертиране в UTC //предупреждение: Това мутира обекта Moment и го поставя в UTC режим! console.log(now.utc()); // Момент<2026-02-19T02:26:29Z>
// отпечатване на форматиран низ - имайте предвид, че сега използва UTC времето console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 19.02.2026 г. 02:27:07 ч
Ключовото нещо, което трябва да запомните за Moment е, че обект Moment винаги включва информация за часа и датата. Ако трябва да работите само с информация за времето, това обикновено е добре, но може да причини неочаквано поведение в ситуации като лятно часово време или високосни години, където датата може да има ефект върху изчисленията на времето. Темпоралната е по-гъвкава. Можете да създадете обект, представящ текущата дата и час, като създадете обект Temporal.Instant. Това представлява момент от време, определен от времето от „епохата“ (полунощ UTC на 1 януари 1970 г.). Temporal може да посочи този момент във времето с точност на ниво наносекунда. const сега = Temporal.Now.instant();
// вижте сурови наносекунди от епохата console.log(now.epochNanoseconds); // 1771466342612000000n
// формат за UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// формат за определена часова зона console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Обектите Temporal.Instant също могат да бъдат създадени за определен час и дата с помощта на метода from static.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Форматиране на момента в местната часова зона. Имайте предвид, че това контролира само // форматирането - то не променя обекта, както прави moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Можете също да създавате други типове временни обекти, включително:
Temporal.PlainDate: Дата без информация за часа. Temporal.PlainTime: Час без информация за дата. Temporal.ZonedDateTime: Дата и час в конкретна часова зона.
Всеки от тях има метод от, който може да бъде извикан с обект, указващ датата и/или часа, или низ от дата за анализиране. // Просто среща const днес = Temporal.PlainDate.from({ година: 2026, месец: 2, // имайте предвид, че използваме 2 за февруари ден: 18 }); console.log(today.toString()); // 2026-02-18
// Просто време const lunchTime = Temporal.PlainTime.from({ час: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Дата и час в източната часова зона на САЩ const dueAt = Temporal.ZonedDateTime.from({ часова зона: 'Америка/Ню_Йорк', година: 2026, месец: 3, ден: 1, час: 12, минута: 0, второ: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Америка/Ню_Йорк]
Разбор Разгледахме програмно създаване на информация за дата и час. Сега нека разгледаме анализирането. Парсирането е една област, в която Moment е по-гъвкав от вградения Temporal API. Можете да анализирате низ от дата, като го предадете на функцията момент. С един аргумент Moment очаква ISO низ за дата, но можете да използвате алтернативни формати, ако предоставите втори аргумент, указващ използвания формат на датата.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // Момент<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Момент<2026-02-21T09:00:00-05:00>
В по-старите версии Moment би направил най-доброто предположение, за да анализира всеки произволно форматиран низ от дата. Това може да доведе до непредвидими резултати. Например 02-03-2026 2 февруари ли е или 3 март? Поради тази причина по-новите версии на Moment показват изпъкващо предупреждение за оттегляне, ако се извика без ISO форматиран низ за дата (освен ако не е даден и вторият аргумент с желания формат). Temporal ще анализира само специално форматиран низ от дата. Низът трябва да е съвместим с формата ISO 8601 или неговото разширение, RFC 9557. Ако несъвместим низ с дата бъде предаден на метод от, Temporal ще изведе RangeError.
// Използване на низ за дата RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Америка/Ню_Йорк]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Използване на низ от неизвестна дата const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Грешка във времето: Невалиден знак при анализ на стойността на годината.
Точните изисквания на низа за дата зависят от вида на временния обект, който създавате. В горния пример Temporal.Instant изисква пълен ISO8601 или RFC 9557 низ за дата, указващ датата и часа с отместване на часовата зона, но можете също да създадете обекти PlainDate или PlainTime, като използвате само подмножество от формата на датата. 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ч
Обърнете внимание, че тези низове все още трябва да отговарят на очаквания формат или ще бъде изведена грешка.
// Използване на несъответстващи времеви низове. Всички те ще хвърлят RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 сутринта');
Професионален съвет: Работа с низове, различни от ISO Тъй като Temporal дава приоритет на надеждността, той няма да се опита да отгатне формата на низ като 02-01-2026. Ако вашият източник на данни използва такива низове, ще трябва да извършите известна манипулация на низове, за да пренаредите стойностите в ISO низ като 2026-02-01, преди да опитате да го използвате с Temporal.
Форматиране След като имате обект Moment или Temporal, вероятно ще искате да го конвертирате във форматиран низ в даден момент. Това е пример, в който Moment е малко по-кратък. Извиквате метода за форматиране на обекта с низ от токени, които описват желания формат на датата. const date = moment();
console.log(date.format('MM/DD/YYYY')); // 22.02.2026 г
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 февруари 2026 г., 20:18:30 ч
От друга страна, Temporal изисква да бъдете малко по-многословни. Временните обекти, като Instant, имат метод toLocaleString, който приема различни опции за форматиране, посочени като свойства на обект.
const date = Temporal.Now.instant();
// без аргументи ще получим формата по подразбиране за текущия локал console.log(date.toLocaleString()); // 2/22/2026, 20:23:36 (приемайки, че локалът е en-US)
// предаване на опции за форматиране за генериране на персонализиран низ за форматиране console.log(date.toLocaleString('en-US', { месец: 'дълъг', ден: 'числов', година: 'числово', час: '2-цифрен', минута: '2-цифрен' })); // 22 февруари 2026 г. в 20:23 ч
// предавайте само полетата, които искате във форматния низ console.log(date.toLocaleString('en-US', { месец: 'къс', ден: 'цифров' })); // 22 фев
Форматирането на временната дата всъщност използва API Intl.DateTimeFormat (който вече е лесно достъпен в съвременните браузъри) под капака. Това означава, че можете да създадете повторно използваем обект DateTimeFormat с вашите персонализирани опции за форматиране, след което да предадете Temporal обекти към неговия метод за форматиране. Поради това той не поддържа персонализирани формати за дата, както прави Moment. Ако имате нужда от нещо като „Q1 2026“ или друго специализирано форматиране, може да се нуждаете от персонализиран код за форматиране на дата или да посегнете към библиотека на трета страна. const formatter = new Intl.DateTimeFormat('en-US', { месец: '2-цифрен', ден: '2-цифрен', година: 'цифров' });
const date = Temporal.Now.instant(); console.log(formatter.format(дата)); // 22.02.2026 г
Токените за форматиране на Moment са по-лесни за писане, но не са удобни за локализиране. Форматът въвежда „твърд код“ неща като ред месец/ден. Предимството на използването на конфигурационен обект, както прави Temporal, е, че той автоматично ще се адаптира към всеки даден локал и ще използва правилния формат. const date = Temporal.Now.instant();
const formatOptions = { месец: 'числов', ден: 'числов', година: 'цифров' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.02.2026 г
console.log(date.toLocaleString('en-GB', formatOptions)); // 22.02.2026 г
Изчисления на дати В много приложения ще трябва да извършите някои изчисления на дадена дата. Може да искате да добавяте или изваждате единици за време (дни, часове, секунди и т.н.). Например, ако имате текущата дата, може да искате да покажете на потребителя датата след 1 седмица. Моментните обекти имат методи като добавяне и изваждане, които изпълняват тези операции. Тези функции приемат стойност и единица, например: add(7, 'days'). Една много важна разлика между Moment и Temporal обаче е, че когато се извършват тези изчисления на дата, основният обект се променя и първоначалната му стойност се губи. const сега = момент();
console.log(сега); // Момент<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'дни'); console.log(следващата седмица); // Момент<2026-03-03T20:08:36-05:00>
// Разбрах - оригиналният обект е мутиран console.log(сега); // Момент<2026-03-03T20:08:36-05:00>
За да избегнете загубата на оригиналната дата, можете да извикате клониране на обекта Moment, за да създадете копие. const сега= момент(); const nextWeek = now.clone().add(7, 'дни');
console.log(сега); // Момент<2026-02-24T20:12:55-05:00>
console.log(следващата седмица); // Момент<2026-03-03T20:12:55-05:00>
От друга страна, временните обекти са неизменни. След като създадете обект като Instant, PlainDate и т.н., стойността на този обект никога няма да се промени. Времевите обекти също имат методи за добавяне и изваждане. Temporal е малко придирчив относно това кои времеви единици могат да се добавят към кои типове обекти. Например не можете да добавяте дни към Instant:
const сега = Temporal.Now.instant(); const nextWeek = now.add({ дни: 7 }); // RangeError: Грешка във времето: Най-голямата единица не може да бъде единица за дата
Това е така, защото Instant обектите представляват конкретна точка от времето в UTC и са агностици на календара. Тъй като продължителността на деня може да се промени въз основа на правилата за часовата зона, като например лятно часово време, това изчисление не е налично в Instant. Можете обаче да извършите тази операция върху други типове обекти, като например PlainDateTime: const сега = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026 г., 20:23:59 ч
const nextWeek = now.add({ дни: 7 });
// Имайте предвид, че оригиналният PlainDateTime остава непроменен console.log(now.toLocaleString()); // 24.02.2026 г., 20:23:59 ч
console.log(nextWeek.toLocaleString()); // 03.03.2026 г., 20:23:59 ч
Можете също така да изчислите колко време е между два моментни или временни обекта. С функцията diff на Moment трябва да предоставите единица за детайлност, в противен случай тя ще върне разликата в милисекунди. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
За да направите това с Temporal обект, можете да предадете друг Temporal обект към неговите методи до или оттогава. Това връща обект Temporal.Duration, съдържащ информация за часовата разлика. Обектът Duration има свойства за всеки компонент на разликата и също така може да генерира низ за продължителност ISO 8601, представящ часовата разлика.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largeUnit указва най-голямата единица време за представяне // при изчисляването на продължителността const diff = date2.since(date1, { largeUnit: 'day' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 низ за продължителност: 1 ден, 1 час, 30 минути)
Сравняване на дати и часове Moment и Temporal ви позволяват да сравнявате дати и часове, за да определите кое е преди другото, но предприемат различни подходи с API. Moment предоставя методи като isBefore, isAfter и isSame за сравняване на два обекта Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // вярно
Temporal използва статичен метод за сравнение, за да извърши сравнение между два обекта от един и същи тип. Връща -1, ако първата дата е преди втората, 0, ако са равни, или 1, ако първата дата е след втората. Следващият пример показва как да сравните два обекта PlainDate. И двата аргумента на Temporal.PlainDate.compare трябва да са PlainDate обекти.
const date1 = Temporal.PlainDate.from({ година: 2026, месец: 2, ден: 24 }); const date2 = Temporal.PlainDate.from({ година: 2026, месец: 3, ден: 24 });
// дата1 идва преди дата2, така че -1 console.log(Temporal.PlainDate.compare(date1, date2));
// Грешка, ако се опитаме да сравним два обекта от различни типове console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Грешка във времето: Предоставени са невалидни полета PlainDate.
По-специално, това улеснява хронологичното сортиране на масив от временни обекти. // Масив от обекти Temporal.PlainDate const дати = [ ... ];
// използвайте Temporal.PlainDate.compare като функция за сравнение dates.sort(Temporal.PlainDate.compare);
Преобразуване на часови зони Основната библиотека на Moment не поддържа преобразуване на часови зони. Ако имате нужда от тази функционалност, трябва също да инсталирате пакета moment-timezone. Този пакет не се разклаща в дърво и следователно може да увеличи значително размера на вашия пакет. След като инсталирате моментна часова зона, можете да конвертирате обектите на Moment в различни часови зони с метода tz. Както при други операции на Moment, това променя основнияобект. // Приемайки източно време на САЩ const сега = момент(); console.log(сега); // Момент<2026-02-28T20:08:20-05:00>
// Преобразуване в тихоокеанско време. // Оригиналното източно време е загубено. now.tz('Америка/Лос_Анджелис'); console.log(сега); // Момент<2026-02-28T17:08:20-08:00>
Функционалността на часовата зона е вградена в Temporal API, когато се използва обект Temporal.ZonedDateTime. Тези обекти включват метод withTimeZone, който връща нов ZonedDateTime, представляващ същия момент във времето, но в указаната часова зона. // Отново, приемайки източно време на САЩ const сега = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.02.2026 г., 20:12:02 EST
// Преобразуване в тихоокеанско време const nowPacific = now.withTimeZone('Америка/Лос_Анджелис'); console.log(nowPacific.toLocaleString()); // 28.02.2026 г., 17:12:02 PST
// Оригиналният обект остава непроменен console.log(now.toLocaleString()); // 28.02.2026 г., 20:12:02 EST
Забележка: Форматираните стойности, върнати от toLocaleString, както подсказва името, зависят от локала. Примерният код е разработен в локала на en-US, така че форматът е следният: 2/28/2026, 17:12:02 PST. В друг локал това може да е различно. Например, в локала en-GB ще получите нещо като 28/2/2026, 17:12:02 GMT-8. Рефакторинг в реалния свят Да предположим, че изграждаме приложение за планиране на събития в различни часови зони. Част от това приложение е функция getEventTimes, която приема низ ISO 8601, представляващ часа и датата на събитието, местна часова зона и целева часова зона. Функцията създава форматирани низове за час и дата за събитието и в двете часови зони. Ако на функцията бъде даден входен низ, който не е валиден низ за час/дата, тя ще изведе грешка. Ето оригиналната реализация, използваща Moment (също изискваща използването на пакета moment-timezone).
импортиране на момент от 'moment-timezone';
функция getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'D MMM, YYYY, h:mm:ss a z';
// 1. Създайте началния момент в часовата зона на потребителя const eventTime = moment.tz( inputString, moment.ISO_8601, // Очаквайте ISO 8601 низ true, // Строго анализиране userTimeZone );
// Извежда грешка, ако inputString не представлява валидна дата if (!eventTime.isValid()) { хвърля нова грешка ('Невалидно въвеждане на дата/час'); }
// 2. Изчислете целевото време // КРИТИЧНО: Трябва да клонираме или 'eventTime' се променя завинаги! const targetTime = eventTime.clone().tz(targetTimeZone);
връщане { локален: eventTime.format(timeFormat), цел: targetTime.format(timeFormat), }; }
const график = getEventTimes( „2026-03-05T15:00-05:00“, „Америка/Ню_Йорк“, "Европа/Лондон", );
console.log(schedule.local); // 5 март 2026 г., 15:00:00 EST
console.log(schedule.target); // 5 март 2026 г., 20:00:00 GMT
В този пример използваме очакван формат за дата на ISO 8601, който е полезно вграден в Moment. Също така използваме стриктно анализиране, което означава, че Moment няма да се опита да отгатне с низ от дата, който не съответства на формата. Ако бъде подаден низ за дата, различен от ISO, това ще доведе до невалиден обект за дата и ние извеждаме грешка. Времевата реализация изглежда подобно, но има няколко ключови разлики.
функция getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Анализирайте входа директно в Instant, след което създайте // ZonedDateTime в зоната на потребителя. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Преобразуване в целевата зона // Това автоматично връща НОВ обект; 'eventTime' е безопасно. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Форматиране чрез Intl (вградено) const options = { година: 'числово', месец: 'къс', ден: 'числов', час: 'цифров', минута: '2-цифрен', второ: '2-цифрен', timeZoneName: 'късо' };
връщане { локален: eventTime.toLocaleString(navigator.language, опции), цел: targetTime.toLocaleString(navigator.language, опции) }; }
const график = getEventTimes( „2026-03-05T15:00-05:00“, „Америка/Ню_Йорк“, "Европа/Лондон", );
console.log(schedule.local); // 5 март 2026 г., 15:00:00 EST
console.log(schedule.target); // 5 март 2026 г., 20:00:00 GMT
С Moment трябва изрично да посочим форматиращ низ за получените низове с дата. Независимо от местоположението или локала на потребителя, часовете на събитията винаги ще бъдат форматирани като 5 март 2026 г., 3:00:00следобед EST. Също така, не е нужно изрично да хвърляме изключение. Ако към Temporal.Instant.from бъде подаден невалиден низ, Temporal ще хвърли изключението вместо нас. Едно нещо, което трябва да се отбележи, е, че дори при стриктно анализиране, версията на Moment е все още по-снизходителна. Temporal изисква отместването на часовата зона в края на низа. Трябва също така да отбележите, че тъй като използваме navigator.language, този код ще се изпълнява само в среда на браузър, тъй като navigator не е дефиниран в среда на Node.js. Реализацията Temporal използва текущия локал на браузъра (navigator.language), така че потребителят автоматично ще получи часовете на събитията, форматирани в техния формат за местно време. В локала на en-US това е 5 март 2026 г., 15:00:00 EST. Въпреки това, ако потребителят е в Лондон, например, часовете на събитието ще бъдат форматирани като 5 март 2026 г., 15:00:00 GMT-5. Резюме
Действие Moment.js Темпорален Текущо време момент() Temporal.Now.zonedDateTimeISO() Анализ на ISO момент (str) Temporal.Instant.from(str) Добавете време .add(7, 'days') (мутира) .add({ дни: 7 }) (нов обект) Разлика .diff(друго, 'часове') .от (друго).часове Часова зона .tz('Зона/Име') .withTimeZone('Зона/Име')
На пръв поглед разликата може да е малко по-различен (а в случая на Temporal, понякога по-подробен и по-строг) синтаксис, но има няколко ключови предимства при използването на Temporal пред Moment.js:
Да бъдеш по-ясен означава по-малко изненади и непреднамерени грешки. Моментът може да изглежда по-снизходителен, но включва „догадки“, които понякога могат да доведат до неправилни дати. Ако дадете на Temporal нещо невалидно, то извежда грешка. Ако кодът се изпълнява, знаете, че имате валидна дата. Moment може да добави значителен размер към пакета на приложението, особено ако използвате пакета moment-timezone. Temporal не добавя нищо (след като бъде изпратено в целевите ви браузъри). Неизменността ви дава увереността, че никога няма да загубите или презапишете данни, когато извършвате преобразуване на дати и операции. Различни представяния на времето (Instant, PlainDateTime, ZonedDateTime) в зависимост от вашите изисквания, където Moment винаги е обвивка около UTC клеймо за време. Temporal използва Intl API за форматиране на дата, което означава, че можете да имате форматиране, съобразено с локала, без да се налага изрично да указвате токени.
Бележки за Polyfill Както бе споменато по-рано, има наличен Temporal polyfill, разпространяван като npm пакет с име @js-temporal/polyfill. Ако искате да използвате Temporal днес, ще ви трябва този polyfill, за да поддържате браузъри като Safari, които все още не са изпратили API. Лошата новина с това е, че ще увеличи размера на вашия пакет. Добрата новина е, че все още добавя значително по-малко от момент или моментна часова зона. Ето сравнение на размерите на пакетите, както се съобщава от Bundlephobia.com, уебсайт, който представя информация за размерите на пакети npm (щракнете върху всяко име на пакет, за да видите анализа на Bundlephobia):
Пакет Минимизиран Минимизирано и архивирано @js-temporal/polyfill 154,1 kB 44,1 kB момент 294,4 kB 75,4 kB момент-часова зона 1 MB 114,2 kB
Полифилът също е имал исторически проблеми с производителността около използването на паметта и към момента на писане се счита, че е в алфа състояние. Поради това може да не искате да го използвате в производството, докато не достигне по-зряло състояние. Другата добра новина е, че се надяваме, че полифилът няма да е необходим още дълго (освен ако не трябва да поддържате по-стари браузъри, разбира се). Към момента на писане Temporal е доставен в Chrome, Edge и Firefox. Все още не е напълно готово в Safari, въпреки че изглежда е налично с флаг за изпълнение в най-новия технологичен преглед.
