Даты

Модуль Dates предоставляет два типа для работы с датами: Date и DateTime, представляющие точность дня и миллисекунды соответственно; оба являются подтипами абстрактного TimeType. Мотивация для разных типов проста: некоторые операции намного проще, как с точки зрения кода, так и с точки зрения логического мышления, когда не нужно учитывать сложность большей точности. Например, так как тип Date разрешается только до точности одной даты (т.е. без часов, минут или секунд), обычные соображения по часовым поясам, летнему/зимнему времени и високосным секундам не нужны и не используются.

Оба типа Date и DateTime в основном являются неизменяемыми обёртками Int64. Единственное поле instant любого типа на самом деле является типом UTInstant{P}, который представляет непрерывно возрастающую временную шкалу машины, основанную на секунде UT ^[1]. Тип DateTime не учитывает часовые пояса (неявный, по терминологии Python), аналогично LocalDateTime в Java 8. Дополнительную функциональность часовых поясов можно добавить с помощью пакета TimeZones.jl, который компилирует базу данных часовых поясов IANA. Оба типа Date и DateTime основаны на стандарте ISO 8601, который следует пролептическому григорианскому календарю. Отметим, что стандарт ISO 8601 чётко определяет даты до н.э. / до н. э. В общем, последний день эпохи до н.э. / до н. э., 31-12-01 до н. э. / до н. э., был заменён на 01-01-01 н. э. / н. э., поэтому года нуль не существует. Однако стандарт ISO гласит, что 1 до н.э. / до н. э. – это год нуль, поэтому 0000-12-31 – это день перед 0001-01-01, а год -0001 (да, минус один для года) – это 2 до н.э. / до н. э., год -0002 – это 3 до н.э. / до н. э. и т.д.

Конструкторы

Date и DateTime типы могут быть созданы с помощью целых чисел или Period типов, путём парсинга или через корректоры (подробнее об этом позже):

julia> DateTime(2013)
2013-01-01T00:00:00

julia> DateTime(2013,7)
2013-07-01T00:00:00

julia> DateTime(2013,7,1)
2013-07-01T00:00:00

julia> DateTime(2013,7,1,12)
2013-07-01T12:00:00

julia> DateTime(2013,7,1,12,30)
2013-07-01T12:30:00

julia> DateTime(2013,7,1,12,30,59)
2013-07-01T12:30:59

julia> DateTime(2013,7,1,12,30,59,1)
2013-07-01T12:30:59.001

julia> Date(2013)
2013-01-01

julia> Date(2013,7)
2013-07-01

julia> Date(2013,7,1)
2013-07-01

julia> Date(Dates.Year(2013),Dates.Month(7),Dates.Day(1))
2013-07-01

julia> Date(Dates.Month(7),Dates.Year(2013))
2013-07-01

Date или DateTime парсинг выполняется с помощью форматов строк. Форматы строк работают путём определения разграниченных или фиксированных "слотов", содержащих период для парсинга, и передачей текста для парсинга и строку формата в конструктор Date или DateTime, в форме Date("2015-01-01",dateformat"y-m-d") или DateTime("20150101",dateformat"yyyymmdd").

Разграниченные слоты отмечаются указанием разделителя, который ожидается парсером между двумя последующими периодами; таким образом, "y-m-d" позволяет парсеру понять, что между первым и вторым слотом в строке даты, например, "2014-07-16", он должен найти символ -.

Символы y, m, и d позволяют парсеру понять, какие периоды необходимо обработать в каждом слоте.

Как и в случае с конструкторами выше, такими как Date(2013), разграниченные DateFormat позволяют пропускать части дат и времени, пока предыдущие части указаны. Другие части принимают значения по умолчанию. Например, Date("1981-03", dateformat"y-m-d") возвращает 1981-03-01, в то время как Date("31/12", dateformat"d/m/y") даёт 0001-12-31. (Обратите внимание, что значение года по умолчанию - 1 н. э.). Следовательно, пустая строка всегда возвращает 0001-01-01 для Date и 0001-01-01T00:00:00.000 для DateTime.

Фиксированные слоты задаются путём повторения символа периода количество раз, соответствующее ширине без разделителя между символами. Таким образом, dateformat"yyyymmdd" соответствует строке даты, например, "20140716". Парсер различает фиксированный слот отсутствием разделителя, отмечая переход "yyyymm" от одного символа периода к другому.

Поддерживается также парсинг месяцев в текстовой форме с помощью символов u и U для сокращённых и полных названий месяцев соответственно. По умолчанию поддерживаются только английские названия месяцев, поэтому u соответствует "Янв", "Фев", "Март" и т. д. А U соответствует "Январь", "Февраль", "Март" и т. д. Аналогично другим функциям сопоставления имя => значение dayname и monthname, пользовательские языковые настройки могут быть загружены путём передачи сопоставления locale=>Dict{String,Int} в словари MONTHTOVALUEABBR и MONTHTOVALUE для сокращённых и полных названий месяцев соответственно.

В приведенных выше примерах использовалась макрос-строка dateformat"". Этот макрос создаёт объект DateFormat один раз при развёртывании макроса и использует тот же объект DateFormat даже если фрагмент кода выполняется несколько раз.

julia> for i = 1:10^5
           Date("2015-01-01", dateformat"y-m-d")
       end

Или вы можете создать объект DateFormat явно:

julia> df = DateFormat("y-m-d");

julia> dt = Date("2015-01-01",df)
2015-01-01

julia> dt2 = Date("2015-01-02",df)
2015-01-02

В качестве альтернативы, используйте трансляцию:

julia> years = ["2015", "2016"];

julia> Date.(years, DateFormat("yyyy"))
2-element Vector{Date}:
 2015-01-01
 2016-01-01

Для удобства вы можете передать строку формата напрямую (например, Date("2015-01-01","y-m-d")), хотя эта форма влечёт за собой затраты производительности, если вы повторно обрабатываете тот же формат, так как внутри создаётся новый объект DateFormat каждый раз.

Кроме как через конструкторы, объект Date или DateTime можно создать из строк, используя функции parse и tryparse, но с необязательным третьим аргументом типа DateFormat, задающим формат; например, parse(Date, "06.23.2013", dateformat"m.d.y"), или tryparse(DateTime, "1999-12-31T23:59:59"), который использует формат по умолчанию. Существенное различие между функциями заключается в том, что при использовании tryparse ошибка не возникает, если строка имеет неверный формат; вместо этого возвращается nothing. Тем не менее, как и в конструкторах выше, пустые части дат и времени предполагают значения по умолчанию, и, следовательно, пустая строка ("") действительна для любой DateFormat, давая, например, Date 0001-01-01. Код, полагающийся на parse или tryparse для Date и DateTime парсинга, поэтому должен проверять, пуста ли входная строка перед использованием результата.

Полный набор тестов и примеров парсинга и форматирования доступен в stdlib/Dates/test/io.jl.

Длительности/Сравнения

Нахождение длительности между двумя Date или DateTime простая задача, учитывая их внутреннее представление как UTInstant{Day} и UTInstant{Millisecond} соответственно. Разница между Date возвращается в количестве Day, а DateTime – в количестве Millisecond.

Аналогично, сравнение TimeType – это простая задача сравнения базовых временных моментов (которые в свою очередь сравнивают внутренние значения Int64).

julia> dt = Date(2012,2,29)
2012-02-29

julia> dt2 = Date(2000,2,1)
2000-02-01

julia> dump(dt)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 734562

julia> dump(dt2)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 730151

julia> dt > dt2
true

julia> dt != dt2
true

julia> dt + dt2
ERROR: MethodError: no method matching +(::Date, ::Date)
[...]

julia> dt * dt2
ERROR: MethodError: no method matching *(::Date, ::Date)
[...]

julia> dt / dt2
ERROR: MethodError: no method matching /(::Date, ::Date)

julia> dt - dt2
4411 days

julia> dt2 - dt
-4411 days

julia> dt = DateTime(2012,2,29)
2012-02-29T00:00:00

julia> dt2 = DateTime(2000,2,1)
2000-02-01T00:00:00

julia> dt - dt2
381110400000 milliseconds

Функции доступа

Поскольку типы Date и DateTime хранятся как одиночные значения Int64, части или поля даты могут быть извлечены с помощью функций доступа. Маленькие функции доступа возвращают поле как целое число:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.year(t)
2014

julia> Dates.month(t)
1

julia> Dates.week(t)
5

julia> Dates.day(t)
31

В то время как заглавные возвращают то же самое значение в соответствующем типе Period:

julia> Dates.Year(t)
2014 years

julia> Dates.Day(t)
31 days

Предлагаются составные методы, поскольку доступ к нескольким полям одновременно более эффективен, чем доступ к ним по отдельности:

julia> Dates.yearmonth(t)
(2014, 1)

julia> Dates.monthday(t)
(1, 31)

julia> Dates.yearmonthday(t)
(2014, 1, 31)

Также можно получить доступ к базовому значению UTInstant или целому числу:

julia> dump(t)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 735264

julia> t.instant
Dates.UTInstant{Day}(Day(735264))

julia> Dates.value(t)
735264

Функции запроса

Функции запроса предоставляют календарную информацию о TimeType. В них содержится информация о дне недели:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.dayofweek(t)
5

julia> Dates.dayname(t)
"Friday"

julia> Dates.dayofweekofmonth(t) # 5th Friday of January
5

Месяце года:

julia> Dates.monthname(t)
"January"

julia> Dates.daysinmonth(t)
31

А также информация о годе и квартале TimeType:

julia> Dates.isleapyear(t)
false

julia> Dates.dayofyear(t)
31

julia> Dates.quarterofyear(t)
1

julia> Dates.dayofquarter(t)
31

Методы dayname и monthname также могут принимать необязательный ключевой параметр locale, который может быть использован для возвращения названия дня или месяца года для других языков/региональных настроек. Также существуют версии этих функций, возвращающие сокращённые названия, а именно dayabbr и monthabbr. Сначала сопоставление загружается в переменную LOCALES:

julia> french_months = ["janvier", "février", "mars", "avril", "mai", "juin",
                        "juillet", "août", "septembre", "octobre", "novembre", "décembre"];

julia> french_monts_abbrev = ["janv","févr","mars","avril","mai","juin",
                              "juil","août","sept","oct","nov","déc"];

julia> french_days = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"];

julia> Dates.LOCALES["french"] = Dates.DateLocale(french_months, french_monts_abbrev, french_days, [""]);

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

julia> Dates.dayname(t;locale="french")
"vendredi"

julia> Dates.monthname(t;locale="french")
"janvier"

julia> Dates.monthabbr(t;locale="french")
"janv"

Так как сокращённые варианты дней не загружены, попытка использовать функцию dayabbr вызовет ошибку.

julia> Dates.dayabbr(t;locale="french")
ERROR: BoundsError: attempt to access 1-element Vector{String} at index [5]
Stacktrace:
[...]

Арифметика TimeType-Period

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

Модуль Dates пытается следовать простому принципу минимальных изменений при выполнении арифметических операций с Period. Этот подход также часто называют календарной арифметикой или тем, что вы, вероятно, предположили бы, если бы вас спросили о таком же расчёте в разговоре. В чём же суть? Рассмотрим классический пример: прибавьте 1 месяц к 31 января 2014 года. Какой будет ответ? Javascript ответит 3 марта (предполагает 31 день). PHP ответит 2 марта (предполагает 30 дней). Фактически, правильного ответа нет. В модуле Dates результат будет 28 февраля. Как это определяется? Представьте классическую игру в казино «7-7-7».

Теперь представьте, что вместо 7-7-7 на барабанах находятся значения Год-Месяц-День, или в нашем примере 2014-01-31. При добавлении 1 месяца к этой дате значение месяца увеличивается, теперь у нас 2014-02-31. Затем проверяется, больше ли число дня, чем последнее допустимое число дня в новом месяце; если это так (как в приведённом примере), число дня корректируется до последнего допустимого значения (28). Какие последствия имеет такой подход? Попробуйте добавить ещё один месяц к нашей дате, 2014-02-28 + Month(1) == 2014-03-28. Что? Вы ожидали последнее число марта? Нет, извините, помните барабаны 7-7-7. Меняется как можно меньше значений, поэтому мы сначала увеличиваем значение месяца на 1, 2014-03-28, и всё, мы закончили, так как это допустимая дата. С другой стороны, если мы добавим 2 месяца к исходной дате 2014-01-31, то получим 2014-03-31, как и ожидалось. Другим последствием этого подхода является потеря ассоциативности, когда определённый порядок действий принудителен (то есть, изменение порядка операций приводит к разным результатам). Например:

julia> (Date(2014,1,29)+Dates.Day(1)) + Dates.Month(1)
2014-02-28

julia> (Date(2014,1,29)+Dates.Month(1)) + Dates.Day(1)
2014-03-01

Что происходит? В первой строке мы добавляем 1 день к 29 января, что даёт 2014-01-30; затем мы добавляем 1 месяц, получив 2014-02-30, что затем корректируется до 2014-02-28. Во втором примере мы сначала добавляем 1 месяц, получив 2014-02-29, которое корректируется до 2014-02-28, а затем добавляем 1 день, что даёт 2014-03-01. Один из принципов проектирования в этом случае заключается в том, что при наличии нескольких периодов операции будут упорядочены по типам периодов, а не по их значениям или порядковому положению; это означает, что Year всегда будет добавляться первой, затем Month, затем Week и так далее. Таким образом, в следующем примере ассоциативность действительно сохраняется и всё работает как ожидается:

julia> Date(2014,1,29) + Dates.Day(1) + Dates.Month(1)
2014-03-01

julia> Date(2014,1,29) + Dates.Month(1) + Dates.Day(1)
2014-03-01

Сложно? Возможно. Что делать простому пользователю Dates? В итоге следует понимать, что явное принуждение к определённой ассоциативности при работе с месяцами может привести к некоторым неожиданным результатам, но в остальном всё должно работать как ожидается. К счастью, это в основном исчерпывает список необычных случаев в арифметике дат и периодов при работе со временем в UT (избегая «радостей» работы с переходом на летнее/зимнее время, високосных секунд и т. д.).

В качестве бонуса, все объекты арифметики периодов работают напрямую с диапазонами:

julia> dr = Date(2014,1,29):Day(1):Date(2014,2,3)
Date("2014-01-29"):Day(1):Date("2014-02-03")

julia> collect(dr)
6-element Vector{Date}:
 2014-01-29
 2014-01-30
 2014-01-31
 2014-02-01
 2014-02-02
 2014-02-03

julia> dr = Date(2014,1,29):Dates.Month(1):Date(2014,07,29)
Date("2014-01-29"):Month(1):Date("2014-07-29")

julia> collect(dr)
7-element Vector{Date}:
 2014-01-29
 2014-02-28
 2014-03-29
 2014-04-29
 2014-05-29
 2014-06-29
 2014-07-29

Функции коррекции

Хотя арифметика дат и периодов удобна, часто для вычислений с датами требуются календарные или временные особенности, а не фиксированное количество периодов. Праздники — идеальный пример; большинство из них следуют правилам, таким как «День памяти = последний понедельник мая» или «День благодарения = четвёртый четверг ноября». Эти виды временных выражений оперируют правилами, связанными с календарём, например, первым или последним числом месяца, следующим вторником или первым и третьим средами и т. д.

Модуль Dates предоставляет API коррекции через несколько удобных методов, которые помогают просто и кратко выражать временные правила. Первая группа методов коррекции относится к первому и последнему дню недели, месяца, квартала и года. Каждый из них принимает один TimeType в качестве входных данных и возвращает или корректирует до первого или последнего дня желаемого периода относительно входных данных.

julia> Dates.firstdayofweek(Date(2014,7,16)) # Adjusts the input to the Monday of the input's week
2014-07-14

julia> Dates.lastdayofmonth(Date(2014,7,16)) # Adjusts to the last day of the input's month
2014-07-31

julia> Dates.lastdayofquarter(Date(2014,7,16)) # Adjusts to the last day of the input's quarter
2014-09-30

Два следующих метода высшего порядка, tonext и toprev, обобщают работу с временными выражениями, принимая DateFunction в качестве первого аргумента вместе с начальным TimeType. DateFunction — это просто функция, обычно анонимная, которая принимает один TimeType в качестве входных данных и возвращает Bool, true указывающее, удовлетворяет ли критерий корректировки. Например:

julia> istuesday = x->Dates.dayofweek(x) == Dates.Tuesday; # Returns true if the day of the week of x is Tuesday

julia> Dates.tonext(istuesday, Date(2014,7,13)) # 2014-07-13 is a Sunday
2014-07-15

julia> Dates.tonext(Date(2014,7,13), Dates.Tuesday) # Convenience method provided for day of the week adjustments
2014-07-15

Это полезно для более сложных временных выражений с синтаксисом блока do:

julia> Dates.tonext(Date(2014,7,13)) do x
           # Return true on the 4th Thursday of November (Thanksgiving)
           Dates.dayofweek(x) == Dates.Thursday &&
           Dates.dayofweekofmonth(x) == 4 &&
           Dates.month(x) == Dates.November
       end
2014-11-27

Метод Base.filter может использоваться для получения всех допустимых дат/моментов в заданном диапазоне:

# Pittsburgh street cleaning; Every 2nd Tuesday from April to November
# Date range from January 1st, 2014 to January 1st, 2015
julia> dr = Dates.Date(2014):Day(1):Dates.Date(2015);

julia> filter(dr) do x
           Dates.dayofweek(x) == Dates.Tue &&
           Dates.April <= Dates.month(x) <= Dates.Nov &&
           Dates.dayofweekofmonth(x) == 2
       end
8-element Vector{Date}:
 2014-04-08
 2014-05-13
 2014-06-10
 2014-07-08
 2014-08-12
 2014-09-09
 2014-10-14
 2014-11-11

Дополнительные примеры и тесты доступны в stdlib/Dates/test/adjusters.jl.

Типы периодов

Периоды — это человеческое представление о дискретных, иногда нерегулярных промежутках времени. Рассмотрим 1 месяц; он может представлять, в днях, значение 28, 29, 30 или 31 в зависимости от года и месяца. Или год может представлять 365 или 366 дней в случае високосного года. Типы Period — это простые обёртки Int64 и создаются путём обёртывания любого типа, преобразуемого к Int64, то есть Year(1) или Month(3.0). Арифметика между Period одного типа ведёт себя как целые числа, и доступна ограниченная арифметика Period-Real. Вы можете извлечь базовое целое число с помощью Dates.value.

julia> y1 = Dates.Year(1)
1 year

julia> y2 = Dates.Year(2)
2 years

julia> y3 = Dates.Year(10)
10 years

julia> y1 + y2
3 years

julia> div(y3,y2)
5

julia> y3 - y2
8 years

julia> y3 % y2
0 years

julia> div(y3,3) # mirrors integer division
3 years

julia> Dates.value(Dates.Millisecond(10))
10

Округление

Date и DateTime могут быть округлены до заданной точности (например, 1 месяц или 15 минут) с помощью floor, ceil или round:

julia> floor(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:45:00

julia> round(DateTime(2016, 8, 6, 20, 15), Dates.Day)
2016-08-07T00:00:00

В отличие от числового метода round, который по умолчанию разрывает ничьи в сторону чётного числа, метод TimeTyperound использует режим округления RoundNearestTiesUp. (Сложно представить, что означало бы разбиение ничьих к ближайшему «чётному» TimeType). Более подробные сведения о доступных режимах округления можно найти в справочнике по API.

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

Эпоха округления

Во многих случаях точность, указанная для округления (например, Dates.Second(30)), делится без остатка на следующий больший период (в данном случае, Dates.Minute(1)). Однако поведение округления в случаях, когда это не так, может привести к путанице. Какой ожидаемый результат округления DateTime до ближайших 10 часов?

julia> round(DateTime(2016, 7, 17, 11, 55), Dates.Hour(10))
2016-07-17T12:00:00

Это может показаться запутанным, учитывая, что час (12) не делится на 10 без остатка. Причина, по которой выбран 2016-07-17T12:00:00, заключается в том, что это 17 676 660 часов после 0000-01-01T00:00:00, а 17 676 660 делится на 10.

Поскольку значения Julia Date и DateTime представлены в соответствии со стандартом ISO 8601, 0000-01-01T00:00:00 был выбран в качестве основы (или «эпохи округления») для начала подсчёта дней (и миллисекунд) при вычислениях округления. (Обратите внимание, что это несколько отличается от внутреннего представления Julia значений Date с использованием обозначения Rata Die; но поскольку стандарт ISO 8601 наиболее виден конечному пользователю, 0000-01-01T00:00:00 был выбран в качестве эпохи округления вместо 0000-12-31T00:00:00, используемого внутри, чтобы минимизировать путаницу.)

Единственным исключением из использования 0000-01-01T00:00:00 в качестве эпохи округления является округление до недель. Округление до ближайшей недели всегда вернёт понедельник (первый день недели, как определено стандартом ISO 8601). По этой причине мы используем 0000-01-03T00:00:00 (первый день первой недели года 0000, как определено стандартом ISO 8601) в качестве основы при округлении до числа недель.

Вот ещё один случай, в котором ожидаемое поведение не обязательно очевидно: что происходит при округлении до ближайшего P(2), где P — тип Period? В некоторых случаях (в частности, когда P <: Dates.TimePeriod) ответ очевиден:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Hour(2))
2016-07-17T08:00:00

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Minute(2))
2016-07-17T08:56:00

Это кажется очевидным, потому что две единицы каждого из этих периодов по-прежнему делятся без остатка на следующий больший период. Но в случае двух месяцев (которые по-прежнему делятся без остатка на один год) ответ может быть неожиданным:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Month(2))
2016-07-01T00:00:00

Почему округляется до первого числа июля, даже если это месяц 7 (нечётное число)? Ключ в том, что месяцы нумеруются с 1 (первый месяц — 1), в отличие от часов, минут, секунд и миллисекунд (первые из которых нумеруются с 0).

Это означает, что округление DateTime до чётного числа секунд, минут, часов или лет (потому что спецификация ISO 8601 включает ноль года) приведёт к DateTime с чётным значением в этом поле, в то время как округление DateTime до чётного числа месяцев приведёт к значению месяца, имеющему нечётное значение. Так как и месяцы, и годы могут содержать нечётное число дней, то чётно ли значение в поле дней при округлении до чётного числа дней — неопределённо.

Дополнительную информацию о методах, экспортируемых из модуля Dates , см. в справочнике по API.

Справочник по API

Типы дат и времени

`Dates.Period`Тип

Period
Year
Quarter
Month
Week
Day
Hour
Minute
Second
Millisecond
Microsecond
Nanosecond

Period типы представляют собой дискретные, человекочитаемые представления времени.

Код	Примеры	Комментарий
`y`	6	Числовой год с фиксированной шириной
`Y`	1996	Числовой год с минимальной шириной
`m`	1, 12	Числовой месяц с минимальной шириной
`u`	Янв	Сокращенное название месяца до 3 символов в соответствии с `locale`
`U`	Январь	Полное название месяца в соответствии с ключевым словом `locale`
`d`	1, 31	День месяца с минимальной шириной
`H`	0, 23	Час (24-часовой формат) с минимальной шириной
`M`	0, 59	Минута с минимальной шириной
`S`	0, 59	Секунда с минимальной шириной
`s`	000, 500	Миллисекунда с минимальной шириной 3
`e`	Пн, Вт	Сокращенные дни недели
`E`	Понедельник	Полное название дня недели

Код	Совпадения	Комментарий
`y`	1996, 96	Возвращает год 1996, 0096
`Y`	1996, 96	Возвращает год 1996, 0096. Эквивалентно `y`
`m`	1, 01	Совпадение с месяцами из 1 или 2 цифр
`u`	Янв	Совпадение с сокращенными названиями месяцев в соответствии с ключевым словом `locale`
`U`	Январь	Совпадение с полными названиями месяцев в соответствии с ключевым словом `locale`
`d`	1, 01	Совпадение с днями из 1 или 2 цифр
`H`	00	Совпадение с часами (24-часовой формат)
`I`	00	Для вывода часов в 12-часовом формате
`M`	00	Совпадение с минутами
`S`	00	Совпадение с секундами
`s`	.500	Совпадение с миллисекундами
`e`	Пн, Вт	Совпадение с сокращенными днями недели
`E`	Понедельник	Совпадение с полными названиями дней недели
`p`	ДОП	Совпадение с AM/PM (регистронезависимо)
`yyyymmdd`	19960101	Совпадение с годом, месяцем и днем фиксированной ширины

Переменная	Сокр.	Значение (Int)
`Monday`	`Mon`	1
`Tuesday`	`Tue`	2
`Wednesday`	`Wed`	3
`Thursday`	`Thu`	4
`Friday`	`Fri`	5
`Saturday`	`Sat`	6
`Sunday`	`Sun`	7

Переменная	Сокр.	Значение (Int)
`January`	`Jan`	1
`February`	`Feb`	2
`March`	`Mar`	3
`April`	`Apr`	4
`May`	`May`	5
`June`	`Jun`	6
`July`	`Jul`	7
`August`	`Aug`	8
`September`	`Sep`	9
`October`	`Oct`	10
`November`	`Nov`	11
`December`	`Dec`	12

Даты

Dates.PeriodТип

Dates.CompoundPeriodТип

Dates.InstantТип

Dates.UTInstantТип

Dates.TimeTypeТип

Dates.DateTimeТип

Dates.DateТип

Dates.TimeТип

Dates.TimeZoneТип

Dates.UTCТип

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.formatМетод

Dates.DateFormatТип

Dates.@dateformat_strМакрос

Dates.DateTimeМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.nowМетод

Dates.nowМетод

Base.epsМетод

Dates.yearФункция

Dates.monthФункция

Dates.weekФункция

Dates.dayФункция

Dates.hourФункция

Dates.minuteФункция

Dates.secondФункция

Dates.millisecondФункция

Dates.microsecondФункция

Dates.nanosecondФункция

Dates.YearМетод

Dates.MonthМетод

Dates.WeekМетод

Dates.DayМетод

Dates.HourМетод

Dates.MinuteМетод

Dates.SecondМетод

Dates.MillisecondМетод

Dates.MicrosecondМетод

Dates.NanosecondМетод

Dates.yearmonthФункция

Dates.monthdayФункция

Dates.yearmonthdayФункция

Dates.daynameФункция

Dates.dayabbrФункция

Dates.dayofweekФункция

Dates.dayofmonthФункция

Dates.dayofweekofmonthФункция

Dates.daysofweekinmonthФункция

Dates.monthnameФункция

Dates.monthabbrФункция

Dates.daysinmonthФункция

Dates.isleapyearФункция

Dates.dayofyearФункция

Dates.daysinyearФункция

Dates.quarterofyearФункция

Dates.dayofquarterФункция

Base.truncМетод

Dates.firstdayofweekФункция

Dates.lastdayofweekФункция

Dates.firstdayofmonthФункция

Dates.lastdayofmonthФункция

Dates.firstdayofyearФункция

Dates.lastdayofyearФункция

Dates.firstdayofquarterФункция

`Dates.Period`Тип

`Dates.CompoundPeriod`Тип

`Dates.Instant`Тип

`Dates.UTInstant`Тип

`Dates.TimeType`Тип

`Dates.DateTime`Тип

`Dates.Date`Тип

`Dates.Time`Тип

`Dates.TimeZone`Тип

`Dates.UTC`Тип

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.format`Метод

`Dates.DateFormat`Тип

`Dates.@dateformat_str`Макрос

`Dates.DateTime`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.now`Метод

`Dates.now`Метод

`Base.eps`Метод

`Dates.year`Функция

`Dates.month`Функция

`Dates.week`Функция

`Dates.day`Функция

`Dates.hour`Функция

`Dates.minute`Функция

`Dates.second`Функция

`Dates.millisecond`Функция

`Dates.microsecond`Функция

`Dates.nanosecond`Функция

`Dates.Year`Метод

`Dates.Month`Метод

`Dates.Week`Метод

`Dates.Day`Метод

`Dates.Hour`Метод

`Dates.Minute`Метод

`Dates.Second`Метод

`Dates.Millisecond`Метод

`Dates.Microsecond`Метод

`Dates.Nanosecond`Метод

`Dates.yearmonth`Функция

`Dates.monthday`Функция

`Dates.yearmonthday`Функция

`Dates.dayname`Функция

`Dates.dayabbr`Функция

`Dates.dayofweek`Функция

`Dates.dayofmonth`Функция

`Dates.dayofweekofmonth`Функция

`Dates.daysofweekinmonth`Функция

`Dates.monthname`Функция

`Dates.monthabbr`Функция

`Dates.daysinmonth`Функция

`Dates.isleapyear`Функция

`Dates.dayofyear`Функция

`Dates.daysinyear`Функция

`Dates.quarterofyear`Функция

`Dates.dayofquarter`Функция

`Base.trunc`Метод

`Dates.firstdayofweek`Функция

`Dates.lastdayofweek`Функция

`Dates.firstdayofmonth`Функция

`Dates.lastdayofmonth`Функция

`Dates.firstdayofyear`Функция

`Dates.lastdayofyear`Функция

`Dates.firstdayofquarter`Функция

`Dates.lastdayofquarter`Функция