Даты

Модуль 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 и Periods

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

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

END_OF_DOCUMENT_MARKER

Теперь представьте, что вместо 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

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

Насколько удобна арифметика дат и периодов, часто для вычислений с датами требуется календарный или временной характер, а не фиксированное количество периодов. Праздники — идеальный пример; большинство из них следуют правилам, таким как «День памяти = Последний понедельник мая» или «День благодарения = 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 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). Дополнительные сведения об доступных режимах округления можно найти в справочнике 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 и Periods

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

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

Округление

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

Справочник 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`Функция