Даты

Модуль 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}(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 одного и того же типа ведут себя как целые числа, и доступна ограниченная арифметика 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`	Янв	Совпадает с сокращенными названиями месяцев в соответствии с ключевым словом `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.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`Функция