Даты

Модуль 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 конкретен относительно дат до нашей эры/до новой эры. В общем случае последним днём эры до нашей эры/до новой эры, 1-12-31 до н. э./до н. э., следует 1-1-1 н. э./н. э., поэтому года ноль не существует. Однако стандарт ISO указывает, что 1 до н. э./до н. э. — это год ноль, поэтому 0000-12-31 — это день перед 0001-01-01, а год -0001 (да, минус один для года) — это 2 до н. э./до н. э., год -0002 — это 3 до н. э./до н. э. и т. д.

[1]

Понятие секунды UT на самом деле довольно фундаментально. В целом приняты в основном два разных понятия времени, одно основано на физическом вращении Земли (полное вращение = 1 день), другое основано на секунде СИ (фиксированное, постоянное значение). Это кардинально разные вещи! Подумайте об этом, "секунда UT", определённая относительно вращения Земли, может иметь различную абсолютную длительность в зависимости от дня! Так или иначе, тот факт, что Date и DateTime основаны на секундах UT, является упрощающим, но честным предположением, чтобы избежать таких сложностей, как високосные секунды и все связанные с ними сложности. Эта основа времени формально называется UT или UT1. Основание типов на секунде UT фактически означает, что каждая минута имеет 60 секунд, а каждый день — 24 часа, что приводит к более естественным расчётам при работе с календарными датами.

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

Типы 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","y-m-d") или DateTime("20150101","yyyymmdd").

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

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

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

Примечание о производительности парсинга: использование функции Date(date_string,format_string) приемлемо, если она вызывается несколько раз. Однако, если необходимо обработать много строк дат в аналогичном формате, значительно эффективнее сначала создать Dates.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

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

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

Полный набор тестов и примеров парсинга и форматирования доступен в 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}(735264 days)

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 Array{String,1} 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)
2014-01-29:1 day:2014-02-03

julia> collect(dr)
6-element Array{Date,1}:
 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)
2014-01-29:1 month:2014-07-29

julia> collect(dr)
7-element Array{Date,1}:
 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 Array{Date,1}:
 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 одного типа ведут себя как целые числа, и доступна ограниченная арифметика периодов. Вы можете извлечь базовое целое число с помощью 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
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`	Jan	Совпадает с сокращенными названиями месяцев в соответствии с ключевым словом `locale`
`U`	January	Совпадает с полными названиями месяцев в соответствии с ключевым словом `locale`
`d`	1, 01	Совпадает с днями от 1 до 2 цифр
`H`	00	Совпадает с часами (24-часовой формат)
`I`	00	Для вывода часов в 12-часовом формате
`M`	00	Совпадает с минутами
`S`	00	Совпадает со секундами
`s`	.500	Совпадает с миллисекундами
`e`	Mon, Tues	Совпадает с сокращенными названиями дней недели
`E`	Monday	Совпадает с полными названиями дней недели
`p`	AM	Совпадает с 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

Даты

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

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

Функции-акссесоры

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

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

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

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

Округление

Округление эпохи

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

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

Dates.PeriodТип

Dates.CompoundPeriodТип

Dates.InstantТип

Dates.UTInstantТип

Dates.TimeTypeТип

Dates.DateTimeТип

Dates.DateТип

Dates.TimeТип

Функции модуля Dates

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.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.Period`Тип

`Dates.CompoundPeriod`Тип

`Dates.Instant`Тип

`Dates.UTInstant`Тип

`Dates.TimeType`Тип

`Dates.DateTime`Тип

`Dates.Date`Тип

`Dates.Time`Тип

`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.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`Функция

`Dates.tonext`Метод

`Dates.toprev`Метод

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

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