Даты

Модуль 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 соответствует «Янв», «Фев», «Март» и т.д. А 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}(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 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)
Date("2014-01-29"):Day(1):Date("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)
Date("2014-01-29"):Month(1):Date("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 одного и того же типа ведет себя как целые числа, и доступна ограниченная арифметика 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
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	Совпадает с годом, месяцем и днем фиксированной ширины

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