Даты

Модуль Dates предоставляет два типа для работы с датами: Date и DateTime, представляющие точность дня и миллисекунды соответственно; оба являются подтипами абстрактного TimeType. Мотивация для отдельных типов проста: некоторые операции значительно проще, как с точки зрения кода, так и с точки зрения логики, когда не нужно учитывать сложность большей точности. Например, поскольку тип Date разрешается только до точности одной даты (т. е. без часов, минут или секунд), обычные соображения по часовым поясам, переходу на летнее время и високосным секундам не нужны и не учитываются.

Оба Date и DateTime по сути представляют собой неизменяемые обёртки над Int64. Единственное поле любого типа instant фактически является типом UTInstant{P}, который представляет непрерывно возрастающую машинную временную шкалу, основанную на UT-секунде [1]. Тип DateTime не учитывает часовые пояса (наивный, по терминологии Python), аналогично LocalDateTime в Java 8. Дополнительную функциональность часовых поясов можно добавить с помощью пакета TimeZones.jl, который компилирует базу данных часовых поясов IANA. Оба Date и DateTime основаны на стандарте ISO 8601, который следует пролептическому григорианскому календарю. Отметим, что стандарт ISO 8601 специфичен по отношению к датам до н. э. В общем, последний день эры до нашей эры, 1-12-31 до н. э., следовал за 1-1-1 н. э., поэтому года нуль не существует. Однако стандарт ISO утверждает, что 1 г. до н. э. — это год ноль, поэтому 0000-12-31 — это день до 0001-01-01, а год -0001 (да, минус один для года) — это 2 г. до н. э., год -0002 — это 3 г. до н. э. и т. д.

[1]

Понятие UT-секунды на самом деле довольно фундаментально. В общих чертах существуют два различных понятия времени, которые обычно принимаются: одно основано на физическом вращении Земли (полный оборот = 1 день), другое — на SI-секунде (фиксированное, постоянное значение). Это радикально разные вещи! Подумайте об этом: «UT-секунда», определённая относительно вращения Земли, может иметь разную абсолютную длину в зависимости от дня! В любом случае, тот факт, что Date и DateTime основаны на UT-секундах, является упрощающим, но честным предположением, чтобы избежать таких вещей, как високосные секунды и их всей сложности. Эта основа времени формально называется UT или UT1. Основание типов на UT-секунде фактически означает, что каждая минута имеет 60 секунд, а каждый день — 24 часа, что приводит к более естественным расчётам при работе с календарными датами.

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

Типы Date и DateTime могут быть построены с использованием целых чисел или типов Period, путём разбора или с помощью корректоров (подробнее об этом позже):

julia> DateTime(2013)
2013-01-01T00:00:00

julia> DateTime(2013,7)
2013-07-01T00:00:00

julia> DateTime(2013,7,1)
2013-07-01T00:00:00

julia> DateTime(2013,7,1,12)
2013-07-01T12:00:00

julia> DateTime(2013,7,1,12,30)
2013-07-01T12:30:00

julia> DateTime(2013,7,1,12,30,59)
2013-07-01T12:30:59

julia> DateTime(2013,7,1,12,30,59,1)
2013-07-01T12:30:59.001

julia> Date(2013)
2013-01-01

julia> Date(2013,7)
2013-07-01

julia> Date(2013,7,1)
2013-07-01

julia> Date(Dates.Year(2013),Dates.Month(7),Dates.Day(1))
2013-07-01

julia> Date(Dates.Month(7),Dates.Year(2013))
2013-07-01

Разбор Date или DateTime осуществляется с помощью строковых шаблонов форматирования. Строки форматирования работают путём определения «слотов» с разделителями или фиксированной шириной, содержащих период для разбора, и передачи текстового значения для разбора и строки форматирования в конструктор Date или DateTime, в форме Date("2015-01-01","y-m-d") или DateTime("20150101","yyyymmdd").

Разделительные слоты помечаются указанием разделителя, который анализатор должен ожидать между двумя последующими периодами; поэтому "y-m-d" сообщает анализатору, что между первым и вторым слотами в строке даты, такой как "2014-07-16", он должен найти символ -. Символы y, m, и d сообщают анализатору, какие периоды нужно анализировать в каждом слоте.

Слоты с фиксированной шириной задаются путём повторения символа периода количество раз, соответствующее ширине, без разделителей между символами. Так, "yyyymmdd" соответствует строке даты, такой как "20140716". Анализатор различает слот фиксированной ширины по отсутствию разделителя, отмечая переход "yyyymm" от одного символа периода к следующему.

Поддержка разбора месяцев в текстовой форме также поддерживается символами u и U для сокращённых и полных названий месяцев соответственно. По умолчанию поддерживаются только английские названия месяцев, поэтому u соответствует «Янв», «Фев», «Март» и т. д. А U соответствует «Январь», «Февраль», «Март» и т. д. Аналогично другим функциям сопоставления имя=>значение dayname и monthname, пользовательские локали можно загрузить, передав в словарь locale=>Dict{String,Int} в словари MONTHTOVALUEABBR и MONTHTOVALUE для сокращённых и полных имён месяцев соответственно.

Примечание по производительности разбора: использование функции Date(date_string,format_string) приемлемо, если она вызывается несколько раз. Однако, если необходимо разобрать много строк дат с одинаковым форматом, намного эффективнее предварительно создать Dates.DateFormat и передать его вместо строки форматирования.

julia> df = DateFormat("y-m-d");

julia> dt = Date("2015-01-01",df)
2015-01-01

julia> dt2 = Date("2015-01-02",df)
2015-01-02

Также можно использовать макрос строки dateformat"". Этот макрос создаёт объект DateFormat один раз при развёртывании макроса и использует тот же объект DateFormat даже если фрагмент кода выполняется несколько раз.

julia> for i = 1:10^5
           Date("2015-01-01", dateformat"y-m-d")
       end

Полный набор тестов и примеров разбора и форматирования доступен в stdlib/Dates/test/io.jl.

Длительности/Сравнения

Вычисление длительности между двумя Date или DateTime является простым, учитывая их внутреннее представление как UTInstant{Day} и UTInstant{Millisecond} соответственно. Разница между Date возвращается в количестве Day, а разница между DateTime — в количестве Millisecond. Аналогично, сравнение TimeType — это просто сравнение внутренних мгновений машины (что, в свою очередь, сравнивает внутренние значения Int64).

julia> dt = Date(2012,2,29)
2012-02-29

julia> dt2 = Date(2000,2,1)
2000-02-01

julia> dump(dt)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 734562

julia> dump(dt2)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 730151

julia> dt > dt2
true

julia> dt != dt2
true

julia> dt + dt2
ERROR: MethodError: no method matching +(::Date, ::Date)
[...]

julia> dt * dt2
ERROR: MethodError: no method matching *(::Date, ::Date)
[...]

julia> dt / dt2
ERROR: MethodError: no method matching /(::Date, ::Date)

julia> dt - dt2
4411 days

julia> dt2 - dt
-4411 days

julia> dt = DateTime(2012,2,29)
2012-02-29T00:00:00

julia> dt2 = DateTime(2000,2,1)
2000-02-01T00:00:00

julia> dt - dt2
381110400000 milliseconds

Функции-акссесоры

Поскольку типы Date и DateTime хранятся как одиночные значения Int64, части или поля даты можно извлечь с помощью функций-акссесоров. Функции-акссесоры в нижнем регистре возвращают поле в виде целого числа:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.year(t)
2014

julia> Dates.month(t)
1

julia> Dates.week(t)
5

julia> Dates.day(t)
31

В то время как функции-акссесоры в верхнем регистре возвращают то же значение в соответствующем типе Period:

julia> Dates.Year(t)
2014 years

julia> Dates.Day(t)
31 days

Предоставляются составные методы, так как они обеспечивают эффективность, если требуется несколько полей одновременно:

julia> Dates.yearmonth(t)
(2014, 1)

julia> Dates.monthday(t)
(1, 31)

julia> Dates.yearmonthday(t)
(2014, 1, 31)

Также можно получить доступ к внутреннему значению UTInstant или целочисленному значению:

julia> dump(t)
Date
  instant: Dates.UTInstant{Day}
    periods: Day
      value: Int64 735264

julia> t.instant
Dates.UTInstant{Day}(735264 days)

julia> Dates.value(t)
735264

Функции запроса

Функции запроса предоставляют календарную информацию о TimeType. Они включают информацию о дне недели:

julia> t = Date(2014, 1, 31)
2014-01-31

julia> Dates.dayofweek(t)
5

julia> Dates.dayname(t)
"Friday"

julia> Dates.dayofweekofmonth(t) # 5th Friday of January
5

Месяц года:

julia> Dates.monthname(t)
"January"

julia> Dates.daysinmonth(t)
31

А также информацию о годе и квартале TimeType:

julia> Dates.isleapyear(t)
false

julia> Dates.dayofyear(t)
31

julia> Dates.quarterofyear(t)
1

julia> Dates.dayofquarter(t)
31

Методы dayname и monthname также могут принимать необязательный ключевой параметр locale, который можно использовать для возврата имени дня или месяца для других языков/локалей. Также существуют версии этих функций, возвращающие сокращённые названия, а именно dayabbr и monthabbr. Сначала отображение загружается в переменную LOCALES.

julia> french_months = ["janvier", "février", "mars", "avril", "mai", "juin",
                        "juillet", "août", "septembre", "octobre", "novembre", "décembre"];

julia> french_monts_abbrev = ["janv","févr","mars","avril","mai","juin",
                              "juil","août","sept","oct","nov","déc"];

julia> french_days = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"];

julia> Dates.LOCALES["french"] = Dates.DateLocale(french_months, french_monts_abbrev, french_days, [""]);

Затем указанные выше функции можно использовать для выполнения запросов:

julia> Dates.dayname(t;locale="french")
"vendredi"

julia> Dates.monthname(t;locale="french")
"janvier"

julia> Dates.monthabbr(t;locale="french")
"janv"

Поскольку сокращённые версии дней не загружены, попытка использовать функцию dayabbr приведёт к ошибке.

julia> Dates.dayabbr(t;locale="french")
ERROR: BoundsError: attempt to access 1-element Array{String,1} at index [5]
Stacktrace:
[...]

Арифметика TimeType-Period

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

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

Теперь представьте, что вместо 7-7-7, поля содержат Год-Месяц-День, или, в нашем примере, 2014-01-31. Когда вы попросите добавить 1 месяц к этой дате, поле месяца увеличивается, и теперь у нас 2014-02-31. Затем проверяется число дня, чтобы убедиться, что оно не больше последнего дня нового месяца; если это так (как в случае выше), число дня корректируется до последнего дня (28). К каким последствиям приводит этот подход? Попробуйте добавить ещё один месяц к нашей дате, 2014-02-28 + Month(1) == 2014-03-28. Что? Вы ожидали последний день марта? Нет, извините, помните поля 7-7-7. Как можно меньше полей будет изменено, поэтому мы сначала увеличиваем поле месяца на 1, 2014-03-28, и всё, мы закончили, потому что это корректная дата. С другой стороны, если мы добавим 2 месяца к нашей исходной дате, 2014-01-31, то получим 2014-03-31, как и ожидалось. Другим последствием этого подхода является потеря ассоциативности, когда принудительно задаётся определённый порядок (т. е. добавление элементов в разном порядке приводит к разным результатам). Например:

julia> (Date(2014,1,29)+Dates.Day(1)) + Dates.Month(1)
2014-02-28

julia> (Date(2014,1,29)+Dates.Month(1)) + Dates.Day(1)
2014-03-01

Что там происходит? В первой строке мы добавляем 1 день к 29 января, что приводит к 2014-01-30; затем мы добавляем 1 месяц, и получаем 2014-02-30, которое корректируется до 2014-02-28. Во втором примере мы сначала добавляем 1 месяц, получаем 2014-02-29, которое корректируется до 2014-02-28, и затем добавляем 1 день, что приводит к 2014-03-01. Один из принципов проектирования, который помогает в этом случае, заключается в том, что при наличии нескольких периодов операции будут упорядочены по типам периодов, а не по их значению или порядковому номеру; это означает, что Year всегда будет добавляться первой, затем Month, затем Week, и так далее. Таким образом, следующее действительно приводит к ассоциативности и просто работает:

julia> Date(2014,1,29) + Dates.Day(1) + Dates.Month(1)
2014-03-01

julia> Date(2014,1,29) + Dates.Month(1) + Dates.Day(1)
2014-03-01

Сложно? Возможно. Что должен делать обычный Dates пользователь? В итоге, важно помнить, что явное принуждение к определённой ассоциативности при работе с месяцами может привести к некоторым непредвиденным результатам, но в противном случае всё должно работать как ожидается. К счастью, это почти все необычные случаи в арифметике дат-периодов при работе с временем в UT (избегая «радостей» работы с переходом на летнее время, високосных секунд и т. д.).

В качестве бонуса, все объекты арифметики периодов работают непосредственно с диапазонами:

julia> dr = Date(2014,1,29):Day(1):Date(2014,2,3)
2014-01-29:1 day:2014-02-03

julia> collect(dr)
6-element Array{Date,1}:
 2014-01-29
 2014-01-30
 2014-01-31
 2014-02-01
 2014-02-02
 2014-02-03

julia> dr = Date(2014,1,29):Dates.Month(1):Date(2014,07,29)
2014-01-29:1 month:2014-07-29

julia> collect(dr)
7-element Array{Date,1}:
 2014-01-29
 2014-02-28
 2014-03-29
 2014-04-29
 2014-05-29
 2014-06-29
 2014-07-29

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

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

Поскольку значения Julia Date и DateTime представляются в соответствии со стандартом ISO 8601, 0000-01-01T00:00:00 был выбран в качестве базового (или «эпохи округления»), с которого начинается подсчёт дней (и миллисекунд), используемых в вычислениях округления. (Обратите внимание, что это немного отличается от внутреннего представления Julia значений Date с использованием нотации Рата Дие; но поскольку стандарт 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 до чётного кратного месяцев приведёт к тому, что поле месяца будет иметь нечётное значение. Поскольку и месяцы, и годы могут содержать нерегулярное количество дней, не ясно, приведёт ли округление до чётного числа дней к чётному значению в поле дней.

См. справочник API для получения дополнительной информации о методах, экспортируемых из модуля Dates.

Справочник 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	Совпадение фиксированной ширины года, месяца и дня

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

Переменная	Сокр.	Значение (Int)
`January`	`Jan`	1
`February`	`Feb`	2
`March`	`Mar`	3
`April`	`Apr`	4
`May`	`May`	5
`June`	`Jun`	6
`July`	`Jul`	7
`August`	`Aug`	8
`September`	`Sep`	9
`October`	`Oct`	10
`November`	`Nov`	11
`December`	`Dec`	12

Даты

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

Длительности/Сравнения

Функции-акссесоры

Функции запроса

Арифметика TimeType-Period

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

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

Округление

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

Справочник API

Типы дат и времени

Dates.PeriodТип

Dates.CompoundPeriodТип

Dates.InstantТип

Dates.UTInstantТип

Dates.TimeTypeТип

Dates.DateTimeТип

Dates.DateТип

Dates.TimeТип

Функции модуля Dates

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.DateTimeМетод

Dates.formatФункция

Dates.DateFormatТип

Dates.@dateformat_strМакрос

Dates.DateTimeМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.DateМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.TimeМетод

Dates.nowМетод

Dates.nowМетод

Base.epsФункция

Функции-аксессоры

Dates.yearФункция

Dates.monthФункция

Dates.weekФункция

Dates.dayФункция

Dates.hourФункция

Dates.minuteФункция

Dates.secondФункция

Dates.millisecondФункция

Dates.microsecondФункция

Dates.nanosecondФункция

Dates.YearМетод

Dates.MonthМетод

Dates.WeekМетод

Dates.DayМетод

Dates.HourМетод

Dates.MinuteМетод

Dates.SecondМетод

Dates.MillisecondМетод

Dates.MicrosecondМетод

Dates.NanosecondМетод

Dates.yearmonthФункция

Dates.monthdayФункция

Dates.yearmonthdayФункция

Функции запроса

Dates.daynameФункция

Dates.dayabbrФункция

Dates.dayofweekФункция

Dates.dayofmonthФункция

Dates.dayofweekofmonthФункция

Dates.daysofweekinmonthФункция

Dates.monthnameФункция

Dates.monthabbrФункция

Dates.daysinmonthФункция

Dates.isleapyearФункция

Dates.dayofyearФункция

Dates.daysinyearФункция

`Dates.Period`Тип

`Dates.CompoundPeriod`Тип

`Dates.Instant`Тип

`Dates.UTInstant`Тип

`Dates.TimeType`Тип

`Dates.DateTime`Тип

`Dates.Date`Тип

`Dates.Time`Тип

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.DateTime`Метод

`Dates.format`Функция

`Dates.DateFormat`Тип

`Dates.@dateformat_str`Макрос

`Dates.DateTime`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Date`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.Time`Метод

`Dates.now`Метод

`Dates.now`Метод

`Base.eps`Функция

`Dates.year`Функция

`Dates.month`Функция

`Dates.week`Функция

`Dates.day`Функция

`Dates.hour`Функция

`Dates.minute`Функция

`Dates.second`Функция

`Dates.millisecond`Функция

`Dates.microsecond`Функция

`Dates.nanosecond`Функция

`Dates.Year`Метод

`Dates.Month`Метод

`Dates.Week`Метод

`Dates.Day`Метод

`Dates.Hour`Метод

`Dates.Minute`Метод

`Dates.Second`Метод

`Dates.Millisecond`Метод

`Dates.Microsecond`Метод

`Dates.Nanosecond`Метод

`Dates.yearmonth`Функция

`Dates.monthday`Функция

`Dates.yearmonthday`Функция

`Dates.dayname`Функция

`Dates.dayabbr`Функция

`Dates.dayofweek`Функция

`Dates.dayofmonth`Функция

`Dates.dayofweekofmonth`Функция

`Dates.daysofweekinmonth`Функция

`Dates.monthname`Функция

`Dates.monthabbr`Функция

`Dates.daysinmonth`Функция

`Dates.isleapyear`Функция

`Dates.dayofyear`Функция

`Dates.daysinyear`Функция

`Dates.quarterofyear`Функция

`Dates.dayofquarter`Функция

`Base.trunc`Метод

`Dates.firstdayofweek`Функция

`Dates.lastdayofweek`Функция

`Dates.firstdayofmonth`Функция

`Dates.lastdayofmonth`Функция

`Dates.firstdayofyear`Функция

`Dates.lastdayofyear`Функция

`Dates.firstdayofquarter`Функция

`Dates.lastdayofquarter`Функция

`Dates.tonext`Метод

`Dates.toprev`Метод

`Dates.tofirst`Функция

`Dates.tolast`Функция