Даты

Модуль 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 до н.э./до н.э. и т.д.

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

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}(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

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

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

Модуль 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.) Дополнительные сведения о доступных режимах RoundingMode можно найти в справочнике 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
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	Соответствует AM/PM (регистр не учитывается)
`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

Даты

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.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.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.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`Метод