Как перевести timestamp в дату время js
Перейти к содержимому

Как перевести timestamp в дату время js

  • автор:

Как конвертировать Unix timestamp в дату в Moment.js

Чтобы преобразовать UNIX-время в человеческую дату с помощью moment.js , воспользуйтесь следующим кодом:

Скопировать код

var date = moment.unix(UNIX_TIMESTAMP).format("YYYY-MM-DD HH:mm");

Замените UNIX_TIMESTAMP на конкретное числовое значение временной метки, чтобы получить отформатированную дату в виде строки.

Для использования формата по умолчанию, подходящего под текущую локаль, применяйте:

Скопировать код

var localDate = moment.unix(UNIX_TIMESTAMP).format('L');

Помните, что moment.js работает с временными метками UNIX, измеряемыми в секундах. Убедитесь в корректности ваших меток для точного преобразования.

Некоторые тонкости: временные метки UNIX и часовые пояса

Важность секунд

Временные метки UNIX отсчитывают секунды с начала эпохи UNIX, т.е. с 1 января 1970 года (UTC). В то время как объекты Date в JavaScript работают с миллисекундами. Это основное различие важно при использовании moment.unix() :

Скопировать код

// У нас есть 99 проблем, но преобразование времени уже не одна из них! var jsDate = new Date(UNIX_TIMESTAMP * 1000);

Часовые пояса и их особенности

Переход от одного часового пояса к другому может быть сравним с танцем. К счастью, в библиотеке moment.js есть функция tz() , которая с лёгкостью помогает это сделать:

Скопировать код

// Нежный танец между часовыми поясами var zonedDate = moment.unix(UNIX_TIMESTAMP).tz('America/New_York').format("YYYY-MM-DD HH:mm");

Дельный совет: Всегда удостоверяйтесь в точности временной метки перед её преобразованием, чтобы избежать ошибки, связанной с «Неверной датой».

Основы преобразования: обработка и валидация входных данных

Проверка входных данных

Перед началом преобразования уделите время (игра слов преднамеренна!) на проверку временной метки. Несколько базовых проверок могут предотвратить множество проблем:

  • Есть ли уверенность, что входное значение является числом, а не строкой?
  • Измеряется ли оно в секундах с начала эпохи UNIX (а не в миллисекундах или чем-то ещё)?
  • Не выходит ли оно за рамки разумных временных пределов?

Особенности и непредвиденные ситуации

Надежда на лучшее, но всегда быть готовым к худшему – этот принцип наиболее подходит для работы с временными метками, когда встречаются крайние значения, неопределённые или пустые входные данные. Ваш код должен быть способен эффективно обработать все такие случаи.

Дата и Время

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

Более новая информация по этой теме находится на странице https://learn.javascript.ru/date.

Для работы с датой и временем в JavaScript используются объекты Date.

Создание

Для создания нового объекта типа Date используется один из синтаксисов:

Создаёт объект Date с текущей датой и временем:

var now = new Date(); alert( now );

new Date(milliseconds)

Создаёт объект Date , значение которого равно количеству миллисекунд (1/1000 секунды), прошедших с 1 января 1970 года GMT+0.

// 24 часа после 01.01.1970 GMT+0 var Jan02_1970 = new Date(3600 * 24 * 1000); alert( Jan02_1970 );

new Date(datestring)

Если единственный аргумент – строка, используется вызов Date.parse (см. далее) для чтения даты из неё.

new Date(year, month, date, hours, minutes, seconds, ms)

Дату можно создать, используя компоненты в местной временной зоне. Для этого формата обязательны только первые два аргумента. Отсутствующие параметры, начиная с hours считаются равными нулю, а date – единице.

  • Год year должен быть из 4 цифр.
  • Отсчёт месяцев month начинается с нуля 0. Например:

new Date(2011, 0, 1, 0, 0, 0, 0); // // 1 января 2011, 00:00:00 new Date(2011, 0, 1); // то же самое, часы/секунды по умолчанию равны 0

Дата задана с точностью до миллисекунд:

var date = new Date(2011, 0, 1, 2, 3, 4, 567); alert( date ); // 1.01.2011, 02:03:04.567

Получение компонентов даты

Для доступа к компонентам даты-времени объекта Date используются следующие методы:

getFullYear() Получить год (из 4 цифр) getMonth() Получить месяц, от 0 до 11. getDate() Получить число месяца, от 1 до 31. getHours(), getMinutes(), getSeconds(), getMilliseconds() Получить соответствующие компоненты.

Не getYear() , а getFullYear()

Некоторые браузеры реализуют нестандартный метод getYear() . Где-то он возвращает только две цифры из года, где-то четыре. Так или иначе, этот метод отсутствует в стандарте JavaScript. Не используйте его. Для получения года есть getFullYear() .

Дополнительно можно получить день недели:

getDay() Получить номер дня в неделе. Неделя в JavaScript начинается с воскресенья, так что результат будет числом от 0(воскресенье) до 6(суббота).

Все методы, указанные выше, возвращают результат для местной временной зоны.

Существуют также UTC-варианты этих методов, возвращающие день, месяц, год и т.п. для зоны GMT+0 (UTC): getUTCFullYear() , getUTCMonth() , getUTCDay() . То есть, сразу после «get» вставляется «UTC» .

Если ваше локальное время сдвинуто относительно UTC, то следующий код покажет разные часы:

// текущая дата var date = new Date(); // час в текущей временной зоне alert( date.getHours() ); // сколько сейчас времени в Лондоне? // час в зоне GMT+0 alert( date.getUTCHours() );

Кроме описанных выше, существуют два специальных метода без UTC-варианта:

Возвращает число миллисекунд, прошедших с 1 января 1970 года GMT+0, то есть того же вида, который используется в конструкторе new Date(milliseconds) .

Возвращает разницу между местным и UTC-временем, в минутах.

alert( new Date().getTimezoneOffset() ); // Для GMT-1 выведет 60

Установка компонентов даты

Следующие методы позволяют устанавливать компоненты даты и времени:

  • setFullYear(year [, month, date])
  • setMonth(month [, date])
  • setDate(date)
  • setHours(hour [, min, sec, ms])
  • setMinutes(min [, sec, ms])
  • setSeconds(sec [, ms])
  • setMilliseconds(ms)
  • setTime(milliseconds) (устанавливает всю дату по миллисекундам с 01.01.1970 UTC)

Все они, кроме setTime() , обладают также UTC-вариантом, например: setUTCHours() .

Как видно, некоторые методы могут устанавливать несколько компонентов даты одновременно, в частности, setHours . При этом если какая-то компонента не указана, она не меняется. Например:

var today = new Date; today.setHours(0); alert( today ); // сегодня, но час изменён на 0 today.setHours(0, 0, 0, 0); alert( today ); // сегодня, ровно 00:00:00.

Автоисправление даты

Автоисправление – очень удобное свойство объектов Date . Оно заключается в том, что можно устанавливать заведомо некорректные компоненты (например 32 января), а объект сам себя поправит.

var d = new Date(2013, 0, 32); // 32 января 2013 . alert(d); // . это 1 февраля 2013!

Неправильные компоненты даты автоматически распределяются по остальным.

Например, нужно увеличить на 2 дня дату «28 февраля 2011». Может быть так, что это будет 2 марта, а может быть и 1 марта, если год високосный. Но нам обо всем этом думать не нужно. Просто прибавляем два дня. Остальное сделает Date :

var d = new Date(2011, 1, 28); d.setDate(d.getDate() + 2); alert( d ); // 2 марта, 2011

Также это используют для получения даты, отдалённой от имеющейся на нужный промежуток времени. Например, получим дату на 70 секунд большую текущей:

var d = new Date(); d.setSeconds(d.getSeconds() + 70); alert( d ); // выведет корректную дату

Можно установить и нулевые, и даже отрицательные компоненты. Например:

var d = new Date; d.setDate(1); // поставить первое число месяца alert( d ); d.setDate(0); // нулевого числа нет, будет последнее число предыдущего месяца alert( d );
var d = new Date; d.setDate(-1); // предпоследнее число предыдущего месяца alert( d );

Преобразование к числу, разность дат

Когда объект Date используется в числовом контексте, он преобразуется в количество миллисекунд:

alert(+new Date) // +date то же самое, что: +date.valueOf()

Важный побочный эффект: даты можно вычитать, результат вычитания объектов Date – их временная разница, в миллисекундах.

Это используют для измерения времени:

var start = new Date; // засекли время // что-то сделать for (var i = 0; i < 100000; i++) < var doSomething = i * i * i; >var end = new Date; // конец измерения alert( "Цикл занял " + (end - start) + " ms" );

Бенчмаркинг

Допустим, у нас есть несколько вариантов решения задачи, каждый описан функцией.

Как узнать, какой быстрее?

Для примера возьмём две функции, которые бегают по массиву:

function walkIn(arr) < for (var key in arr) arr[key]++ >function walkLength(arr)

Чтобы померить, какая из них быстрее, нельзя запустить один раз walkIn , один раз walkLength и замерить разницу. Одноразовый запуск ненадёжен, любая мини-помеха исказит результат.

Для правильного бенчмаркинга функция запускается много раз, чтобы сам тест занял существенное время. Это сведёт влияние помех к минимуму. Сложную функцию можно запускать 100 раз, простую – 1000 раз…

Померяем, какая из функций быстрее:

var arr = []; for (var i = 0; i < 1000; i++) arr[i] = 0; function walkIn(arr) < for (var key in arr) arr[key]++; >function walkLength(arr) < for (var i = 0; i < arr.length; i++) arr[i]++; >function bench(f) < var date = new Date(); for (var i = 0; i < 10000; i++) f(arr); return new Date() - date; >alert( 'Время walkIn: ' + bench(walkIn) + 'мс' ); alert( 'Время walkLength: ' + bench(walkLength) + 'мс' );

Теперь представим себе, что во время первого бенчмаркинга bench(walkIn) компьютер что-то делал параллельно важное (вдруг) и это занимало ресурсы, а во время второго – перестал. Реальная ситуация? Конечно реальна, особенно на современных ОС, где много процессов одновременно.

Гораздо более надёжные результаты можно получить, если весь пакет тестов прогнать много раз.

var arr = []; for (var i = 0; i < 1000; i++) arr[i] = 0; function walkIn(arr) < for (var key in arr) arr[key]++; >function walkLength(arr) < for (var i = 0; i < arr.length; i++) arr[i]++; >function bench(f) < var date = new Date(); for (var i = 0; i < 1000; i++) f(arr); return new Date() - date; >// bench для каждого теста запустим много раз, чередуя var timeIn = 0, timeLength = 0; for (var i = 0; i < 100; i++) < timeIn += bench(walkIn); timeLength += bench(walkLength); >alert( 'Время walkIn: ' + timeIn + 'мс' ); alert( 'Время walkLength: ' + timeLength + 'мс' );

Более точное время с performance.now()

В современных браузерах (кроме IE9-) вызов performance.now() возвращает количество миллисекунд, прошедшее с начала загрузки страницы. Причём именно с самого начала, до того, как загрузился HTML-файл, если точнее – с момента выгрузки предыдущей страницы из памяти.

Так что это время включает в себя всё, включая начальное обращение к серверу.

Его можно посмотреть в любом месте страницы, даже в , чтобы узнать, сколько времени потребовалось браузеру, чтобы до него добраться, включая загрузку HTML.

Возвращаемое значение измеряется в миллисекундах, но дополнительно имеет точность 3 знака после запятой (до миллионных долей секунды!), поэтому можно использовать его и для более точного бенчмаркинга в том числе.

console.time(метка) и console.timeEnd(метка)

Для измерения с одновременным выводом результатов в консоли есть методы:

  • console.time(метка) – включить внутренний хронометр браузера с меткой.
  • console.timeEnd(метка) – выключить внутренний хронометр браузера с меткой и вывести результат.

Параметр «метка» используется для идентификации таймера, чтобы можно было делать много замеров одновременно и даже вкладывать измерения друг в друга.

В коде ниже таймеры walkIn , walkLength – конкретные тесты, а таймер «All Benchmarks» – время «на всё про всё»:

var arr = []; for (var i = 0; i < 1000; i++) arr[i] = 0; function walkIn(arr) < for (var key in arr) arr[key]++; >function walkLength(arr) < for (var i = 0; i < arr.length; i++) arr[i]++; >function bench(f) < for (var i = 0; i < 10000; i++) f(arr); >console.time("All Benchmarks"); console.time("walkIn"); bench(walkIn); console.timeEnd("walkIn"); console.time("walkLength"); bench(walkLength); console.timeEnd("walkLength"); console.timeEnd("All Benchmarks");

При запуске этого примера нужно открыть консоль, иначе вы ничего не увидите.

Внимание, оптимизатор!

Современные интерпретаторы JavaScript делают массу оптимизаций, например:

  1. Автоматически выносят инвариант, то есть постоянное в цикле значение типа arr.length , за пределы цикла.
  2. Стараются понять, значения какого типа хранит данная переменная или массив, какую структуру имеет объект и, исходя из этого, оптимизировать внутренние алгоритмы.
  3. Выполняют простейшие операции, например сложение явно заданных чисел и строк, на этапе компиляции.
  4. Могут обнаружить, что некий код, например присваивание к неиспользуемой локальной переменной, ни на что не влияет и вообще исключить его из выполнения, хотя делают это редко.

Эти оптимизации могут влиять на результаты тестов, поэтому измерять скорость базовых операций JavaScript («проводить микробенчмаркинг») до того, как вы изучите внутренности JavaScript-интерпретаторов и поймёте, что они реально делают на таком коде, не рекомендуется.

Форматирование и вывод дат

Во всех браузерах, кроме IE10-, поддерживается новый стандарт Ecma 402, который добавляет специальные методы для форматирования дат.

Это делается вызовом date.toLocaleString(локаль, опции) , в котором можно задать много настроек. Он позволяет указать, какие параметры даты нужно вывести, и ряд настроек вывода, после чего интерпретатор сам сформирует строку.

Пример с почти всеми параметрами даты и русским, затем английским (США) форматированием:

var date = new Date(2014, 11, 31, 12, 30, 0); var options = < era: 'long', year: 'numeric', month: 'long', day: 'numeric', weekday: 'long', timezone: 'UTC', hour: 'numeric', minute: 'numeric', second: 'numeric' >; alert( date.toLocaleString("ru", options) ); // среда, 31 декабря 2014 г. н.э. 12:30:00 alert( date.toLocaleString("en-US", options) ); // Wednesday, December 31, 2014 Anno Domini 12:30:00 PM

Вы сможете подробно узнать о них в статье Intl: интернационализация в JavaScript, которая посвящена этому стандарту.

Методы вывода без локализации:

toString() , toDateString() , toTimeString() Возвращают стандартное строчное представление, не заданное жёстко в стандарте, а зависящее от браузера. Единственное требование к нему – читаемость человеком. Метод toString возвращает дату целиком, toDateString() и toTimeString() – только дату и время соответственно.

var d = new Date(); alert( d.toString() ); // вывод, похожий на 'Wed Jan 26 2011 16:40:50 GMT+0300'

toUTCString() То же самое, что toString() , но дата в зоне UTC.

toISOString() Возвращает дату в формате ISO Детали формата будут далее. Поддерживается современными браузерами, не поддерживается IE8-.

var d = new Date(); alert( d.toISOString() ); // вывод, похожий на '2011-01-26T13:51:50.417Z'

Если хочется иметь большую гибкость и кросс-браузерность, то также можно воспользоваться специальной библиотекой, например Moment.JS или написать свою функцию форматирования.

Разбор строки, Date.parse

Все современные браузеры, включая IE9+, понимают даты в упрощённом формате ISO 8601 Extended.

Этот формат выглядит так: YYYY-MM-DDTHH:mm:ss.sssZ , где:

  • YYYY-MM-DD – дата в формате год-месяц-день.
  • Обычный символ T используется как разделитель.
  • HH:mm:ss.sss – время: часы-минуты-секунды-миллисекунды.
  • Часть ‘Z’ обозначает временную зону – в формате +-hh:mm , либо символ Z , обозначающий UTC. По стандарту её можно не указывать, тогда UTC, но в Safari с этим ошибка, так что лучше указывать всегда.

Также возможны укороченные варианты, например YYYY-MM-DD или YYYY-MM или даже только YYYY .

Метод Date.parse(str) разбирает строку str в таком формате и возвращает соответствующее ей количество миллисекунд. Если это невозможно, Date.parse возвращает NaN .

var msUTC = Date.parse('2012-01-26T13:51:50.417Z'); // зона UTC alert( msUTC ); // 1327571510417 (число миллисекунд)

С таймзоной -07:00 GMT :

var ms = Date.parse('2012-01-26T13:51:50.417-07:00'); alert( ms ); // 1327611110417 (число миллисекунд)

Формат дат для IE8-

До появления спецификации ECMAScript 5 формат не был стандартизован, и браузеры, включая IE8-, имели свои собственные форматы дат. Частично, эти форматы пересекаются.

Например, код ниже работает везде, включая старые IE:

var ms = Date.parse("January 26, 2011 13:51:50"); alert( ms );

Вы также можете почитать о старых форматах IE в документации к методу MSDN Date.parse.

Конечно же, сейчас лучше использовать современный формат. Если же нужна поддержка IE8-, то метод Date.parse , как и ряд других современных методов, добавляется библиотекой es5-shim.

Метод Date.now()

Метод Date.now() возвращает дату сразу в виде миллисекунд.

Технически, он аналогичен вызову +new Date() , но в отличие от него не создаёт промежуточный объект даты, а поэтому – во много раз быстрее.

Его использование особенно рекомендуется там, где производительность при работе с датами критична. Обычно это не на веб-страницах, а, к примеру, в разработке игр на JavaScript.

Итого

  • Дата и время представлены в JavaScript одним объектом: Date. Создать «только время» при этом нельзя, оно должно быть с датой. Список методов Date вы можете найти в справочнике Date или выше.
  • Отсчёт месяцев начинается с нуля.
  • Отсчёт дней недели (для getDay() ) тоже начинается с нуля (и это воскресенье).
  • Объект Date удобен тем, что автокорректируется. Благодаря этому легко сдвигать даты.
  • При преобразовании к числу объект Date даёт количество миллисекунд, прошедших с 1 января 1970 UTC. Побочное следствие – даты можно вычитать, результатом будет разница в миллисекундах.
  • Для получения текущей даты в миллисекундах лучше использовать Date.now() , чтобы не создавать лишний объект Date (кроме IE8-)
  • Для бенчмаркинга лучше использовать performance.now() (кроме IE9-), он в 1000 раз точнее.

Задачи

Вывести дату в формате дд.мм.гг

важность: 3

Напишите функцию formatDate(date) , которая выводит дату date в формате дд.мм.гг :

var d = new Date(2014, 0, 30); // 30 января 2014 alert( formatDate(d) ); // '30.01.14'

P.S. Обратите внимание, ведущие нули должны присутствовать, то есть 1 января 2001 должно быть 01.01.01, а не 1.1.1.

Получим компоненты один за другим.

    День можно получить как date.getDate() . При необходимости добавим ведущий ноль:

var dd = date.getDate(); if (dd < 10) dd = '0' + dd;
var mm = date.getMonth() + 1; // месяц 1-12 if (mm < 10) mm = '0' + mm;
var yy = date.getFullYear() % 100; if (yy < 10) yy = '0' + yy;

Как перевести unix timestamp в обычную дату/время(с секундами)

Здравствуйте, пишу код на Javascript. Задача такая - надо перевести время из unix timestamp в обычную дату/время (с секундами) и желательно получить каждое значение по отдельности(день, год, месяц, час и т.д.)

Отслеживать

задан 2 янв 2017 в 18:06

Markovskij Markovskij

43 1 1 серебряный знак 5 5 бронзовых знаков

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Нашел на англ Stackoverflow:

function timeConverter(UNIX_timestamp)

Отслеживать

15.9k 8 8 золотых знаков 52 52 серебряных знака 100 100 бронзовых знаков

Как работать с датой и временем в JavaScript

Для создания объекта Date используется конструктор new Date() с разными аргументами:

  1. Без аргументов — получается объект Date с текущими датой и временем:
let now = new Date();

С одним числовым аргументом — создается объект с временем, которое равно числу миллисекунд, которые прошли с 1 января 1970 года UTC+0:

let Jan01_1970 = new Date(0); 
  1. С одним строковым аргументом — объект Date формируется из строки, содержащей дату в одном из форматов, распознаваемых методом Date.parse():
let Jan01_1970 = new Date(0); 

С несколькими числовыми аргументами — конструируется объект Date с указанными компонентами(год, месяц, дата, час, минута, секунда, миллисекунда) в местном часовом поясе:

let date = new Date(2021, 4, 26, 11, 35, 55); 

UTC (англ. «Coordinated Universal Time») — это стандарт времени, который используется во всем мире для синхронизации часов. Время UTC является точкой отсчета для всех временных зон.

Методы для получения компонентов даты-времени:

  1. getFullYear() — год (4 цифры)
  2. getMonth() — месяц (с 0 до 11)
  3. getDate() — день месяца (с 1 до 31)
  4. getHours() — час (с 0 до 23)
  5. getMinutes() — минута (с 0 до 59)
  6. getSeconds() — секунда (с 0 до 59)
  7. getMilliseconds() — миллисекунда (с 0 до 999)
  8. getTime() — количество миллисекунд, прошедших с полуночи 1 января 1970 года до настоящего времени

Работа с компонентами

Чтобы поменять отдельные компоненты даты-времени, используйте методы установки:

*Жирным шрифтом указаны обязательные параметры, курсивом — дополнительные.

Как получить из строки дату и как указать временную зону?

Для получения объекта Date из строки, содержащей дату в одном из стандартных форматов, используется конструктор new Date(строка) или метод Date.parse(строка), который возвращает таймстамп[1]:

// В конструктор new Date передается строка в формате ISO 8601 let wedding_day = new Date("2022-02-22T22:02:02+06:00"); console.log(wedding_day); // Tue Feb 22 2022 22:02:02 GMT+0300 (Москва, стандартное время) // Строка в формате RFC 2822 let birthday_son = "28 May 2021 13:50:48 GMT+0300"; // Получаем таймстамп из строки даты const timestamp = Date.parse(birthday_son); console.log(timestamp) // 1622199048000 // Создаем объект из таймстампа const date = new Date(timestamp); console.log(date) //Fri May 28 2021 13:50:48 GMT+0300 (Москва, стандартное время) 

Временная зона указывается с помощью суффикса Z (обозначение UTC) или смещения от UTC в формате ±hh:mm, например:

// Время по UTC let open_day = new Date("2023-05-28T11:35:55Z") console.log(vacation_day) // Wed May 28 2023 14:35:55 GMT+0300 (Москва, стандартное время) // Время по Москве let open_day = new Date("2023-05-28T11:35:55+03:00") console.log(open_day) // Wed May 28 2023 11:35:55 GMT+0300 (Москва, стандартное время) // Время по Париж let open_day = new Date("2023-05-28T11:35:55+02:00") console.log(open_day) // Wed May 28 2023 12:35:55 GMT+0300 (Москва, стандартное время)

Если временная зона не указана в строке, то используется местная временная зона.

Как получить текущее время и как сравнить две даты?

Чтобы получить актуальные дату-время, следует применять конструктор new Date() без аргументов:

// Создание объекта Date с текущими датой и временем let now = new Date(); console.log(now); // Mon May 08 2023 23:43:36 GMT+0300 (Москва, стандартное время)

Для сравнения двух дат используются операторы сравнения (>,

// Создание объекта Date из строки let first_date = new Date("2023-09-20T12:35:20+03:00") // Создание объекта Date из компонентов let last_date = new Date(2023, 11, 30, 14, 36, 56) // Сравнение дат с помощью операторов сравнения console.log(first_date > last_date) // false console.log(first_date < last_date) // true console.log(first_date == last_date) // false console.log(first_date != last_date) // true // Сравнение дат с помощью метода getTime() console.log(first_date.getTime() >last_date.getTime()) // false console.log(first_date.getTime() < last_date.getTime()) // true console.log(first_date.getTime() == last_date.getTime()) // false console.log(first_date.getTime() != last_date.getTime()) // true

Стоит помнить, что две даты с одинаковыми компонентами могут быть не равными, если они имеют разные часовые пояса. В примере выше first_date имеет часовой пояс +03:00, а last_date имеет местный часовой пояс. Для того чтобы сравнить даты по UTC используется метод toUTCString():

let date_moscow = new Date("2023-09-20T12:35:20+03:00"); let date_paris = new Date("2023-09-20T11:35:20+02:00"); console.log(date_moscow.toUTCString() == date_paris.toUTCString()); // true

Форматирование даты

Для вывода даты в соответствии с местным временем и языком применяется метод toLocaleString() с аргументами locales и options, которые позволяют приложениям определить тип форматирования даты:

let date = new Date(2023, 4, 20, 45, 30); //Выводим местные дату и время без дополнительных параметров console.log(date.toLocaleString()); //21.05.2023, 21:30:00 //Выводим различные стандарты даты и времени, используя параметр locales //Россия console.log(date.toLocaleString("ru-RU")); // 21.05.2023, 21:30:00 //Китай console.log(date.toLocaleString("zh-CN")); // 2023/5/21 21:30:00 //Америка console.log(date.toLocaleString("en-US")); // 5/21/2023, 9:30:00 PM

Использование параметра options помогает скорректировать общие настройки, например, когда для США нужен 24 часовой формат времени:

//Выводим Американские стандарты даты и времени c параметром options console.log(date.toLocaleString("en-US", < hour12: false >)); // 5/21/2023, 21:30:00

Можно задать свои параметры форматирования в виде объекта таким образом:

let options = < weekday: "short", // день недели в коротком формате year: "numeric", // год в числовом формате month: "long", // месяц в длинном формате day: "numeric", // день в числовом формате hour: "2-digit", // часы в двузначном формате minute: "2-digit" // минуты в двузначном формате >; // Выводим дату с кастомными параметрами в Американском стиле console.log(date.toLocaleString("en-US", options)); // Sun, May 21, 2023 at 09:30 PM // Выводим дату с кастомными параметрами в Китайском стиле console.log(date.toLocaleString("zh-CN", options)); // 2023年5月21日周日 21:30 

Как использовать библиотеку Day.js для работы с датой и временем

Day.js — это легковесная JavaScript библиотека, которая предоставляет удобные методы для парсинга, валидации, манипулирования и отображения дат и времени. Она имеет тот же API, что и популярная библиотека Moment.js, но весит всего 2 КБ и поддерживает иммутабельность[2] и интернационализацию[3].

Day.js подключается в проект через CDN или устанавливается с помощью менеджеров пакетов, таких как:

После подключения библиотеки cоздаются объекты Day.js с помощью функции dayjs() с нужными аргументами:

  • Без аргументов — получается объект Day.js с текущими датой и временем:
let now = dayjs();

Синтаксис JavaScript: основные концепции

  • С одним числовым аргументом — объект Day.js с временем, равным числу миллисекунд, которые прошли с 1 января 1970 года UTC+0:

Синтаксис JavaScript: основные концепции

Литералы в JavaScript

14 февр. 2024 г.

Литералы в JavaScript

Ключевые слова Javascript

13 февр. 2024 г.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *