Даты

Модуль 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 день), другое — на SI-секунде (фиксированное, постоянное значение). Это радикально разные вещи! Подумайте об этом: «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 соответствует «Янв», «Фев», «Март» и т. д. А U соответствует «Январь», «Февраль», «Март» и т. д. Аналогично другим функциям сопоставления имя=>значение 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.

Поскольку значения Date и DateTime в Julia представлены в соответствии со стандартом ISO 8601, 0000-01-01T00:00:00 был выбран в качестве базового (или «эпохи округления») для начала подсчета дней (и миллисекунд) используемых в вычислениях округления. (Обратите внимание, что это немного отличается от внутренней интерпретации Date в Julia с использованием обозначений 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`	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	Совпадения с часами
`M`	00	Совпадения с минутами
`S`	00	Совпадения с секундами
`s`	.500	Совпадения с миллисекундами
`e`	Mon, Tues	Совпадения с сокращёнными названиями дней недели
`E`	Monday	Совпадения с полными названиями дней недели
`yyyymmdd`	19960101	Совпадения с фиксированной шириной года, месяца и дня

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

Переменная	Сокр.	Значение (Целое)
`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`Функция