Дата и время

Давайте познакомимся с новым встроенным объектом: Date. Он хранит дату, время и предоставляет методы для управления датой/временем.

Например, мы можем использовать его для хранения времени создания/изменения, измерения времени или просто для распечатки текущей даты.

Создание

Чтобы создать новый объект Date , вызовите new Date() с одним из следующих аргументов:

• new Date()

• Без аргументов — создайте объект Date для текущей даты и времени:

   пусть сейчас = новая дата();
  оповещение (сейчас); // показывает текущую дату/время

• new Date(milliseconds)

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

   // 0 означает 01.01.1970 UTC+0
  пусть Jan01_1970 = новая дата (0);
  предупреждение (01 января 1970 г.);
  
  // теперь добавляем 24 часа, получаем 01.02.1970 UTC+0
  пусть Jan02_1970 = новая дата (24 * 3600 * 1000);
  предупреждение (02 января 1970 г.);

  Целое число, представляющее количество миллисекунд, прошедших с начала 1970 года, называется меткой времени .

  Это упрощенное числовое представление даты. Мы всегда можем создать дату из метки времени, используя new Date(timestamp) , и преобразовать существующий объект Date в метку времени, используя метод date.getTime() (см. ниже).

  Даты до 01.01.1970 имеют отрицательные временные метки, например:

   // 31 декабря 1969 г.
  пусть Dec31_1969 = новая дата (-24 * 3600 * 1000);
  предупреждение (31 декабря 1969 г.);

• new Date(datestring)

• Если есть один аргумент и это строка, то она анализируется автоматически. Алгоритм тот же, что и Date.parse , мы рассмотрим его позже.

   let date = новая дата («26 января 2017 г.»);
  предупреждение (дата);
  // Время не установлено, поэтому предполагается, что это полночь по Гринвичу и
  // настраивается в соответствии с часовым поясом, в котором выполняется код
  // Таким образом, результат может быть
  // Четверг, 26 января 2017 г., 11:00:00 GMT+1100 (восточное летнее время Австралии)
  // или
  // Ср, 25 января 2017 г., 16:00:00 GMT-0800 (стандартное тихоокеанское время)

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

• Создайте дату с заданными компонентами в местном часовом поясе. Обязательными являются только первые два аргумента.

  • year должен состоять из 4 цифр. Для совместимости также принимаются 2 цифры и считаются 19xx , например, 98 здесь соответствует 1998 , но настоятельно рекомендуется всегда использовать 4 цифры.

  • Счет month начинается с 0 (январь) до 11 (декабрь).

  • Параметр date на самом деле является днем ​​месяца, если он отсутствует, предполагается 1 .

  • Если hours/minutes/seconds/ms отсутствуют, они считаются равными 0 .

  Например:

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

  Максимальная точность — 1 мс (1/1000 сек):

   пусть дата = новая дата (2011, 0, 1, 2, 3, 4, 567);
  предупреждение (дата); // 1.01.2011, 02:03:04.567

Доступ к компонентам даты

Существуют методы для доступа к году, месяцу и т. д. из объекта Date :

• getFullYear()

• Получить год (4 цифры)

• getMonth()

• Получите месяц от 0 до 11 .

• получить дату()

• Получите день месяца от 1 до 31, название метода выглядит немного странно.

• getHours(), getMinutes(), getSeconds(), getMilliсекунды()

• Получите соответствующие компоненты времени.

Не getYear() , а getFullYear()

Многие движки JavaScript реализуют нестандартный метод getYear() . Этот метод устарел. Иногда он возвращает двухзначный год. Пожалуйста, никогда не используйте его. Для года существует getFullYear() .

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

• getDay()

• Получите день недели от 0 (воскресенье) до 6 (суббота). Первым днем ​​всегда является воскресенье, в некоторых странах это не так, но это нельзя изменить.

Все приведенные выше методы возвращают компоненты относительно местного часового пояса.

Существуют также их аналоги в формате UTC, которые возвращают день, месяц, год и т. д. для часового пояса UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). Просто вставьте "UTC" сразу после "get" .

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

 // текущая дата
пусть дата = новая дата();

// час в вашем текущем часовом поясе
оповещение(date.getHours());

// час в часовом поясе UTC+0 (лондонское время без перехода на летнее время)
оповещение(date.getUTCHours());

Помимо приведенных методов, есть два специальных, не имеющих UTC-варианта:

• getTime()

• Возвращает временную метку даты – количество миллисекунд, прошедших с 1 января 1970 года по всемирному координированному времени (UTC+0).

• getTimezoneOffset()

• Возвращает разницу между UTC и местным часовым поясом в минутах:

   // если вы находитесь в часовом поясе UTC-1, выводится 60
  // если вы находитесь в часовом поясе UTC+3, выводится -180
  предупреждение (новая дата().getTimezoneOffset());

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

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

• 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 . Не упомянутые компоненты не изменяются.

Например:

 пусть сегодня = новая дата();

сегодня.setHours(0);
оповещение (сегодня); // все еще сегодня, но час изменен на 0

сегодня.setHours(0, 0, 0, 0);
оповещение (сегодня); // все еще сегодня, сейчас ровно 00:00:00.

Автокоррекция

Автокоррекция — очень удобная функция объектов Date . Мы можем установить значения, выходящие за пределы диапазона, и они автоматически настроятся.

Например:

 пусть дата = новая дата (2013, 0, 32); // 32 января 2013 ?!?
предупреждение (дата); // ...1 февраля 2013 г.!

Компоненты даты, выходящие за пределы диапазона, распределяются автоматически.

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

 пусть дата = новая дата (2016, 1, 28);
date.setDate(date.getDate() + 2);

предупреждение (дата); // 1 марта 2016 г.

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

 пусть дата = новая дата();
date.setSeconds(date.getSeconds() + 70);

предупреждение (дата); // показывает правильную дату

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

 пусть дата = новая дата (2016, 0, 2); // 2 января 2016 г.

дата.setDate(1); // устанавливаем первый день месяца
предупреждение (дата);

дата.setDate(0); // минимальный день равен 1, поэтому предполагается, что это последний день предыдущего месяца
предупреждение (дата); // 31 декабря 2015 г.

Дата по номеру, разница дат

Когда объект Date преобразуется в число, он становится такой же меткой времени, как date.getTime() :

 пусть дата = новая дата();
оповещение (+ дата); // количество миллисекунд, такое же, как date.getTime()

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

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

 пусть старт = новая дата(); // начинаем измерять время

// выполняем работу
для (пусть я = 0; я < 100000; я++) {
  пусть doSomething = я * я * я;
}

пусть конец = новая дата(); // окончание времени измерения

alert(`Цикл занял ${end - start} мс` );

Дата.сейчас()

Если мы хотим измерять только время, нам не нужен объект Date .

Существует специальный метод Date.now() , который возвращает текущую метку времени.

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

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

Так что это, вероятно, лучше:

 пусть старт = Date.now(); // отсчет миллисекунд с 1 января 1970 года

// выполняем работу
для (пусть я = 0; я < 100000; я++) {
  пусть doSomething = я * я * я;
}

пусть конец = Date.now(); // сделанный

alert(`Цикл занял ${end - start} мс` ); // вычитаем числа, а не даты

Бенчмаркинг

Если нам нужен надежный тест функции, требовательной к процессору, нам следует быть осторожными.

Например, давайте измерим две функции, вычисляющие разницу между двумя датами: какая из них быстрее?

Такие измерения производительности часто называют «бенчмарками».

 // у нас есть дата1 и дата2, какая функция быстрее вернет их разницу в мс?
функция diffSubtract(date1, date2) {
  дата возврата2 - дата1;
}

// или
функция diffGetTime(date1, date2) {
  вернуть date2.getTime() - date1.getTime();
}

Эти два делают одно и то же, но один из них использует явный метод date.getTime() для получения даты в мс, а другой использует преобразование даты в число. Их результат всегда один и тот же.

Итак, кто из них быстрее?

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

Давайте измерим:

 функция diffSubtract(date1, date2) {
  дата возврата2 - дата1;
}

функция diffGetTime(date1, date2) {
  вернуть date2.getTime() - date1.getTime();
}

функциональный стенд(f) {
  пусть date1 = новая дата (0);
  пусть date2 = новая дата();

  пусть старт = Date.now();
  for (пусть я = 0; я <100000; я++) f(date1, date2);
  вернуть Date.now() - начать;
}

alert( 'Время diffSubtract: ' + Bench(diffSubtract) + 'мс');
alert( 'Время diffGetTime: ' + Bench(diffGetTime) + 'мс');

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

Хорошо, у нас есть кое-что. Но это еще не лучший показатель.

Представьте себе, что в момент запуска bench(diffSubtract) ЦП что-то делал параллельно и потреблял ресурсы. И к моменту запуска bench(diffGetTime) эта работа уже завершена.

Вполне реальный сценарий для современной многопроцессной ОС.

В результате первый тест будет иметь меньше ресурсов ЦП, чем второй. Это может привести к неверным результатам.

Для более надежного сравнительного анализа весь пакет тестов следует повторить несколько раз.

Например, вот так:

 функция diffSubtract(date1, date2) {
  дата возврата2 - дата1;
}

функция diffGetTime(date1, date2) {
  вернуть date2.getTime() - date1.getTime();
}

функциональный стенд(f) {
  пусть date1 = новая дата (0);
  пусть date2 = новая дата();

  пусть старт = Date.now();
  for (пусть я = 0; я <100000; я++) f(date1, date2);
  вернуть Date.now() - начать;
}

пусть время1 = 0;
пусть время2 = 0;

// запускаем Bench(diffSubtract) и Bench(diffGetTime) по 10 раз попеременно
для (пусть я = 0; я < 10; я++) {
  время1 += скамейка (diffSubtract);
  время2 += скамейка (diffGetTime);
}

alert( 'Общее время для diffSubtract: ' + time1 );
alert( 'Общее время для diffGetTime: ' + time2 );

Современные движки JavaScript начинают применять расширенные оптимизации только к «горячему коду», который выполняется много раз (нет необходимости оптимизировать редко исполняемые вещи). Итак, в приведенном выше примере первые исполнения не оптимизированы должным образом. Возможно, мы захотим добавить разогрев:

 // добавлено для "разогрева" перед основным циклом
скамейка (diffSubtract);
скамейка (diffGetTime);

// теперь эталон
для (пусть я = 0; я < 10; я++) {
  время1 += скамейка (diffSubtract);
  время2 += скамейка (diffGetTime);
}

Будьте осторожны при проведении микробенчмаркинга

Современные движки JavaScript выполняют множество оптимизаций. Они могут подстраивать результаты «искусственных тестов» по ​​сравнению с «обычным использованием», особенно когда мы тестируем что-то очень маленькое, например, работу оператора или встроенную функцию. Так что, если вы серьезно хотите разобраться в производительности, изучите, как работает движок JavaScript. И тогда вам, вероятно, вообще не понадобятся микробенчмарки.

Большой пакет статей о V8 можно найти на https://mrale.ph.

Date.parse из строки

Метод Date.parse(str) может читать дату из строки.

Строковый формат должен быть следующим: YYYY-MM-DDTHH:mm:ss.sssZ , где:

• YYYY-MM-DD – дата: год-месяц-день.

• В качестве разделителя используется символ "T" .

• HH:mm:ss.sss – время: часы, минуты, секунды и миллисекунды.

• Необязательная часть 'Z' обозначает часовой пояс в формате +-hh:mm . Одна буква Z будет означать UTC+0.

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

Вызов Date.parse(str) анализирует строку в заданном формате и возвращает метку времени (количество миллисекунд с 1 января 1970 года по UTC+0). Если формат недействителен, возвращает NaN .

Например:

 let ms = Date.parse('2012-01-26T13:51:50.417-07:00');

оповещение (мс); // 1327611110417 (метка времени)

Мы можем мгновенно создать new Date из отметки времени:

 let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00') );

предупреждение (дата);

Краткое содержание

• Дата и время в JavaScript представлены объектом Date. Мы не можем создать «только дату» или «только время»: объекты Date всегда содержат и то, и другое.

• Месяцы отсчитываются с нуля (да, январь — нулевой месяц).

• Дни недели в getDay() также отсчитываются с нуля (это воскресенье).

• Date автоматически корректируется, если установлены компоненты, выходящие за пределы диапазона. Подходит для сложения/вычитания дней/месяцев/часов.

• Даты можно вычесть, получив их разницу в миллисекундах. Это потому, что Date становится меткой времени при преобразовании в число.

• Используйте Date.now() чтобы быстро получить текущую метку времени.

Обратите внимание, что в отличие от многих других систем временные метки в JavaScript измеряются в миллисекундах, а не в секундах.

Иногда нам нужны более точные измерения времени. Сам по себе JavaScript не имеет возможности измерять время в микросекундах (1 миллионная доля секунды), но большинство сред предоставляют такую ​​возможность. Например, в браузере есть функция Performance.now(), которая выдает количество миллисекунд от начала загрузки страницы с точностью до микросекунды (3 цифры после точки):

 alert(`Загрузка началась ${ Performance.now()} мс назад`);
// Что-то вроде: «Загрузка началась 34731.26000000001 мс назад»
// .26 — микросекунды (260 микросекунд)
// более 3 цифр после запятой являются ошибками точности, верными являются только первые 3

В Node.js есть модуль microtime и другие способы. Технически почти любое устройство и среда позволяют добиться большей точности, просто в Date этого нет.

Задачи

Создать дату

важность: 5

Создайте объект Date для даты: 20 февраля 2012 г., 3:12. Часовой пояс местный.

Покажите это, используя alert .

решение

new Date использует местный часовой пояс. Поэтому единственное, что важно помнить, это то, что месяцы начинаются с нуля.

Итак, февраль имеет номер 1.

Вот пример с числами в качестве компонентов даты:

 //новая дата(год, месяц, дата, час, минута, секунда, миллисекунда)
пусть d1 = новая дата (2012, 1, 20, 3, 12);
предупреждение (d1);

Мы также могли бы создать дату из строки, например:

 //новая дата (строка данных)
let d2 = новая дата("2012-02-20T03:12");
предупреждение (d2);

Показать будний день

важность: 5

Напишите функцию getWeekDay(date) для отображения дня недели в кратком формате: «МО», «ВТ», «МЫ», «ЧТ», «ПТ», «СА», «ВС».

Например:

 пусть дата = новая дата (2012, 0, 3);  // 3 января 2012 г.
оповещение(getWeekDay(дата));        // должен вывести "TU"

Откройте песочницу с тестами.

решение

Метод date.getDay() возвращает номер дня недели, начиная с воскресенья.

Давайте создадим массив дней недели, чтобы мы могли получить правильное название дня по его номеру:

 функция getWeekDay(дата) {
  пусть дни = ['ВС', 'МО', 'ВТ', 'МЫ', 'ЧТ', 'ПТ', 'СА'];

  возврат дней[date.getDay()];
}

пусть дата = новая дата (2014, 0, 3); // 3 января 2014 г.
оповещение(getWeekDay(дата)); // Франция

Откройте решение с тестами в песочнице.

Европейский будний день

важность: 5

В европейских странах дни недели начинаются с понедельника (цифра 1), затем вторника (цифра 2) и до воскресенья (цифра 7). Напишите функцию getLocalDay(date) , которая возвращает «европейский» день недели для date .

 пусть дата = новая дата (2012, 0, 3);  // 3 января 2012 г.
Предупреждение (getLocalDay (дата));       // вторник, должно показать 2

Откройте песочницу с тестами.

решение

 функция getLocalDay(дата) {

  пусть день = date.getDay();

  if (day == 0) { // день недели 0 (воскресенье) равен 7 в европейском языке
    день = 7;
  }

  день возвращения;
}

Откройте решение с тестами в песочнице.

Какой день месяца был много дней назад?

важность: 4

Создайте функцию getDateAgo(date, days) для возврата дня месяца, days назад из date .

Например, если сегодня 20-е число, то getDateAgo(new Date(), 1) должно быть 19-м, а getDateAgo(new Date(), 2) должно быть 18-м.

Должно работать надежно в течение days=365 или более:

 пусть дата = новая дата (2015, 0, 2);

оповещение( getDateAgo(дата, 1)); // 1, (1 января 2015 г.)
предупреждение( getDateAgo(дата, 2)); // 31, (31 декабря 2014 г.)
оповещение( getDateAgo(дата, 365)); // 2, (2 января 2014 г.)

PS Функция не должна изменять данную date .

Откройте песочницу с тестами.

решение

Идея проста: вычесть заданное количество дней из date :

 функция getDateAgo(дата, дни) {
  date.setDate(date.getDate() - дни);
  вернуть дату.getDate();
}

…Но функция не должна менять date . Это важная вещь, потому что внешний код, сообщающий нам дату, не ожидает ее изменения.

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

 функция getDateAgo(дата, дни) {
  пусть dateCopy = новая дата (дата);

  dateCopy.setDate(date.getDate() - дни);
  вернуть датуCopy.getDate();
}

пусть дата = новая дата (2015, 0, 2);

оповещение( getDateAgo(дата, 1)); // 1, (1 января 2015 г.)
предупреждение( getDateAgo(дата, 2)); // 31, (31 декабря 2014 г.)
оповещение( getDateAgo(дата, 365)); // 2, (2 января 2014 г.)

Откройте решение с тестами в песочнице.

Последний день месяца?

важность: 5

Напишите функцию getLastDayOfMonth(year, month) которая возвращает последний день месяца. Иногда это 30, 31 или даже 28/29 февраля.

Параметры:

• year – четырехзначный год, например 2012.

• month – месяц, от 0 до 11.

Например, getLastDayOfMonth(2012, 1) = 29 (високосный год, февраль).

Откройте песочницу с тестами.

решение

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

 функция getLastDayOfMonth(год, месяц) {
  пусть дата = новая дата (год, месяц + 1, 0);
  вернуть дату.getDate();
}

оповещение( getLastDayOfMonth(2012, 0)); // 31
оповещение( getLastDayOfMonth(2012, 1)); // 29
Предупреждение( getLastDayOfMonth(2013, 1) ); // 28

Обычно даты начинаются с 1, но технически мы можем передать любое число, дата настроится автоматически. Итак, когда мы передаем 0, это означает «за один день до 1-го числа месяца», другими словами: «последний день предыдущего месяца».

Откройте решение с тестами в песочнице.

Сколько секунд прошло сегодня?

важность: 5

Напишите функцию getSecondsToday() , которая возвращает количество секунд с начала сегодняшнего дня.

Например, если сейчас 10:00 am и не было перехода на летнее время, то:

 getSecondsToday() == 36000 // (3600 * 10)

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

решение

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

Разница заключается в количестве миллисекунд от начала дня, которое нам нужно разделить на 1000, чтобы получить секунды:

 функция getSecondsToday() {
  пусть сейчас = новая дата();

  // создаем объект, используя текущий день/месяц/год
  пусть сегодня = новая дата(now.getFullYear(), now.getMonth(), now.getDate());

  let diff = now – сегодня; // разница в мс
  вернуть Math.round(diff/1000); // делаем секунды
}

Оповещение (getSecondsToday());

Альтернативным решением было бы получить часы/минуты/секунды и преобразовать их в секунды:

 функция getSecondsToday() {
  пусть d = новая дата();
  return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}

Оповещение (getSecondsToday());

Сколько секунд до завтра?

важность: 5

Создайте функцию getSecondsToTomorrow() , которая возвращает количество секунд до завтра.

Например, если сейчас 23:00 , то:

 getSecondsToTomorrow() == 3600

PS Функция должна работать в любой день, «сегодня» не запрограммировано.

решение

Чтобы получить количество миллисекунд до завтра, мы можем из «завтра 00:00:00» вычесть текущую дату.

Сначала мы генерируем это «завтра», а затем делаем это:

 функция getSecondsToTomorrow() {
  пусть сейчас = новая дата();

  // завтрашняя дата
  пусть завтра = новая дата(now.getFullYear(), now.getMonth(), now.getDate()+1);

  пусть diff = завтра — сейчас; // разница в мс
  вернуть Math.round(diff/1000); // конвертируем в секунды
}

Альтернативное решение:

 функция getSecondsToTomorrow() {
  пусть сейчас = новая дата();
  пусть час = now.getHours();
  пусть минуты = now.getMinutes();
  пусть секунды = now.getSeconds();
  пусть totalSecondsToday = (час * 60 + минуты) * 60 + секунды;
  пусть TotalSecondsInADay = 86400;

  вернуть TotalSecondsInADay - totalSecondsToday;
}

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

Форматировать относительную дату

важность: 4

Напишите функцию formatDate(date) которая должна форматировать date следующим образом:

• Если с date прошло менее 1 секунды, то "right now" .

• В противном случае, если с date прошло менее 1 минуты, то "n sec. ago" .

• В противном случае, если меньше часа, то "m min. ago" .

• В противном случае полная дата в формате "DD.MM.YY HH:mm" . То есть: "day.month.year hours:minutes" , все в двузначном формате, например 31.12.16 10:00 .

Например:

 alert( formatDate(новая дата(новая дата - 1)) ); // "прямо сейчас"

alert( formatDate(новая дата(новая дата - 30 * 1000)) ); // "30 секунд назад"

alert( formatDate(новая дата(новая дата - 5 * 60 * 1000)) ); // "5 минут назад"

// вчерашняя дата, например, 31.12.16 20:00
alert( formatDate(новая дата(новая дата - 86400 * 1000)) );

Откройте песочницу с тестами.

решение

Чтобы получить время от date до настоящего момента – давайте вычтем даты.

 функция formatDate(дата) {
  пусть diff = новая дата() - дата; // разница в миллисекундах

  if (diff < 1000) { // менее 1 секунды
    вернуть «прямо сейчас»;
  }

  let sec = Math.floor(diff / 1000); // конвертируем разницу в секунды

  если (сек < 60) {
    возврат сек + 'сек. назад';
  }

  пусть min = Math.floor(diff/60000); // конвертируем разницу в минуты
  если (мин < 60) {
    вернуть мин + 'мин. назад';
  }

  // форматируем дату
  // добавляем ведущие нули к однозначным числам дня/месяца/часов/минут
  пусть d = дата;
  д = [
    '0' + d.getDate(),
    '0' + (d.getMonth() + 1),
    '' + d.getFullYear(),
    '0' + d.getHours(),
    '0' + d.getMinutes()
  ].map(компонент => компонент.slice(-2)); // берем последние 2 цифры каждого компонента

  // объединяем компоненты в дату
  return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}

alert( formatDate(новая дата(новая дата - 1)) ); // "прямо сейчас"

alert( formatDate(новая дата(новая дата - 30 * 1000)) ); // "30 секунд назад"

alert( formatDate(новая дата(новая дата - 5 * 60 * 1000)) ); // "5 минут назад"

// вчерашняя дата, например, 31.12.2016 20:00
alert( formatDate(новая дата(новая дата - 86400 * 1000)) );

Альтернативное решение:

 функция formatDate(дата) {
  пусть dayOfMonth = date.getDate();
  пусть месяц = ​​date.getMonth() + 1;
  пусть год = date.getFullYear();
  пусть час = date.getHours();
  пусть минуты = date.getMinutes();
  пусть diffMs = новая дата() - дата;
  пусть diffSec = Math.round(diffMs/1000);
  пусть diffMin = diffSec/60;
  пусть diffHour = diffMin/60;

  // форматирование
  год = год.toString().slice(-2);
  месяц = ​​месяц <10? '0' + месяц: месяц;
  деньOfMonth = деньOfMonth <10? '0' + деньOfMonth: деньOfMonth;
  час = час < 10 ? '0' + час: час;
  минуты = минуты < 10 ? '0' + минуты: минуты;

  если (diffSec < 1) {
    вернуть «прямо сейчас»;
  } еще если (diffMin < 1) {
    вернуть `${diffSec} сек. назад`
  } еще если (diffHour < 1) {
    вернуть `${diffMin} мин. назад`
  } еще {
    return `${dayOfMonth}.${месяц}.${год} ${час}:${минуты}`
  }
}

Откройте решение с тестами в песочнице.