Даты

Модуль 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}(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-block для более сложных временных выражений:

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.

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

Округление

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 представляют собой дискретные, человеко-ориентированные представления времени.

Dates.CompoundPeriodТип

CompoundPeriod

CompoundPeriod полезен для выражения временных периодов, которые не являются фиксированным кратным меньших периодов. Например, «год и день» — это не фиксированное количество дней, но его можно выразить с помощью CompoundPeriod. Фактически, CompoundPeriod автоматически генерируется путём сложения разных типов периодов, например Year(1) + Day(1) даёт результат CompoundPeriod.

Dates.InstantТип

Instant

Типы Instant представляют целочисленные, машиночитаемые представления времени как непрерывные временные линии, начиная с эпохи.

Dates.UTInstantТип

UTInstant{T}

Тип UTInstant представляет временную шкалу машины на основе времени UT (1 день = одно вращение Земли). T — это Period параметр, который указывает разрешение или точность момента.

Dates.TimeTypeТип

TimeType

Типы TimeType обертывают Instant экземпляры машин, чтобы предоставить человекопонятные представления о машинном моменте. Time, DateTime и Date являются подтипами TimeType.

Dates.DateTimeТип

DateTime

DateTime оборачивает UTInstant{Millisecond} и интерпретирует его в соответствии с пролептическим григорианским календарём.

Dates.DateТип

Date

Date оборачивает UTInstant{Day} и интерпретирует его в соответствии с пролептическим григорианским календарём.

Dates.TimeТип

Time

Time оборачивает Nanosecond и представляет конкретный момент в 24-часовом дне.

Функции Dates

Dates.DateTimeМетод

DateTime(y, [m, d, h, mi, s, ms]) -> DateTime

Создать тип DateTime по частям. Аргументы должны быть преобразуемы в Int64.

Dates.DateTimeМетод

DateTime(periods::Period...) -> DateTime

Создать тип DateTime по частям типа Period. Аргументы могут быть в любом порядке. Части DateTime, которые не указаны, будут по умолчанию равны значению Dates.default(period).

Dates.DateTimeМетод

DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), limit=10000) -> DateTime

Создать DateTime с помощью API корректировки. Точка отсчёта будет построена из предоставленных аргументов y, m, d..., и будет корректироваться до тех пор, пока f::Function не вернёт true. Размер шага при корректировке можно указать вручную через ключевое слово step. limit устанавливает ограничение на максимальное количество итераций, которые API корректировки будет пытаться выполнить, прежде чем сгенерировать ошибку (в случае, если f::Function никогда не будет удовлетворён).

Примеры

julia> DateTime(dt -> Dates.second(dt) == 40, 2010, 10, 20, 10; step = Dates.Second(1))
2010-10-20T10:00:40

julia> DateTime(dt -> Dates.hour(dt) == 20, 2010, 10, 20, 10; step = Dates.Hour(1), limit = 5)
ERROR: ArgumentError: Adjustment limit reached: 5 iterations
Stacktrace:
[...]

Dates.DateTimeМетод

DateTime(dt::Date) -> DateTime

Преобразовать Date в DateTime. Части часа, минуты, секунды и миллисекунды нового DateTime предполагаются равными нулю.

Dates.DateTimeМетод

DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime

Создать DateTime, разобрав строку даты и времени dt по шаблону, заданному в строке format.

Этот метод создаёт объект DateFormat каждый раз при вызове. Если вы разбираете много строк дат и времени одного и того же формата, подумайте о создании объекта DateFormat один раз и использовании его вместо второй строки аргумента.

Dates.formatФункция

format(io::IO, tok::AbstractDateToken, dt::TimeType, locale)

Отформатировать tok токен из dt и записать его в io. Форматирование может основываться на locale.

Все подтипы AbstractDateToken должны определить этот метод, чтобы иметь возможность вывести объект Date / DateTime в соответствии с DateFormat содержащим этот токен.

Dates.DateFormatТип

DateFormat(format::AbstractString, locale="english") -> DateFormat

Создать объект форматирования даты, который может использоваться для разбора строк дат или форматирования объекта даты в строку. Следующие кодовые символы можно использовать для построения строки format:

Символы, не перечисленные выше, обычно обрабатываются как разделители между слотами даты и времени. Например, строка dt "1996-01-15T00:00:00.0" будет иметь строку format "y-m-dTH:M:S.s". Если вам нужно использовать символ кода как разделитель, вы можете экранировать его с помощью обратного слэша. Дата "1995y01m" будет иметь формат "y\ym\m".

Создание объекта DateFormat дорого. Всякий раз, когда это возможно, создавайте его один раз и используйте его многократно или попробуйте макрос строки dateformat"". Использование этого макроса создаёт объект DateFormat один раз во время макрорасширения и повторно использует его позже. см. @dateformat_str.

См. DateTime и format, чтобы узнать, как использовать объект DateFormat для разбора и записи строк Date соответственно.

Dates.@dateformat_strМакрос

dateformat"Y-m-d H:M:S"

Создать объект DateFormat. Аналогично DateFormat("Y-m-d H:M:S") , но создаёт объект DateFormat один раз во время макрорасширения.

См. DateFormat для получения подробной информации о спецификаторах формата.

Dates.DateTimeМетод

DateTime(dt::AbstractString, df::DateFormat) -> DateTime

Создать DateTime, разобрав строку даты и времени dt по шаблону, заданному в объекте DateFormat. Аналогично DateTime(::AbstractString, ::AbstractString) , но более эффективно при многократном разборе строк дат и времени аналогичного формата с предварительно созданным объектом DateFormat.

Dates.DateМетод

Date(y, [m, d]) -> Date

Создать тип Date по частям. Аргументы должны быть преобразуемы в Int64.

Dates.DateМетод

Date(period::Period...) -> Date

Создать тип Date по частям типа Period. Аргументы могут быть в любом порядке. Части Date , которые не указаны, будут по умолчанию равны значению Dates.default(period).

Dates.DateМетод

Date(f::Function, y[, m, d]; step=Day(1), limit=10000) -> Date

Создайте Date с помощью API корректировки. Точка начала будет построена из предоставленных y, m, d аргументов и будет корректироваться до тех пор, пока f::Function не вернёт true. Размер шага корректировки можно указать вручную через ключевое слово step. limit устанавливает ограничение на максимальное количество итераций, которое API корректировки будет выполнять перед выбросом ошибки (при условии, что f::Function никогда не будет выполнено).

Примеры

julia> Date(date -> Dates.week(date) == 20, 2010, 01, 01)
2010-05-17

julia> Date(date -> Dates.year(date) == 2010, 2000, 01, 01)
2010-01-01

julia> Date(date -> Dates.month(date) == 10, 2000, 01, 01; limit = 5)
ERROR: ArgumentError: Adjustment limit reached: 5 iterations
Stacktrace:
[...]

Dates.DateМетод

Date(dt::DateTime) -> Date

Преобразовать DateTime в Date. Части часа, минуты, секунды и миллисекунды DateTime усекаются, поэтому при построении используются только год, месяц и день.

Dates.DateМетод

Date(d::AbstractString, format::AbstractString; locale="english") -> Date

Построить Date, разобрав строку даты d по шаблону, заданному в строке format.

Этот метод создаёт объект DateFormat каждый раз при вызове. Если вы обрабатываете много строк дат с одинаковым форматом, рассмотрите создание объекта DateFormat один раз и использование его в качестве второго аргумента вместо этого.

Dates.DateМетод

Date(d::AbstractString, df::DateFormat) -> Date

Разбор даты из строки даты d с помощью объекта DateFormat df.

Dates.TimeМетод

Time(h, [mi, s, ms, us, ns]) -> Time

Построение типа Time по частям. Аргументы должны быть преобразуемы в Int64.

Dates.TimeМетод

Time(period::TimePeriod...) -> Time

Построение типа Time по частям типа Period. Аргументы могут быть в любом порядке. Time части, не предоставленные, будут по умолчанию равны значению Dates.default(period).

Dates.TimeМетод

Time(f::Function, h, mi=0; step::Period=Second(1), limit::Int=10000)
Time(f::Function, h, mi, s; step::Period=Millisecond(1), limit::Int=10000)
Time(f::Function, h, mi, s, ms; step::Period=Microsecond(1), limit::Int=10000)
Time(f::Function, h, mi, s, ms, us; step::Period=Nanosecond(1), limit::Int=10000)

Создайте Time с помощью API корректировки. Точка начала будет построена из предоставленных h, mi, s, ms, us аргументов и будет корректироваться до тех пор, пока f::Function не вернёт true. Размер шага корректировки можно указать вручную с помощью ключевого слова step . limit устанавливает предел максимального количества итераций, которые API корректировки будет выполнять перед выбросом ошибки (в случае, если f::Function никогда не будет выполнено). Обратите внимание, что значение по умолчанию для шага корректировки будет настроено для обеспечения большей точности для заданных аргументов; например, если предоставлены аргументы часа, минуты и секунды, шаг по умолчанию будет Millisecond(1), а не Second(1).

Примеры

julia> Dates.Time(t -> Dates.minute(t) == 30, 20)
20:30:00

julia> Dates.Time(t -> Dates.minute(t) == 0, 20)
20:00:00

julia> Dates.Time(t -> Dates.hour(t) == 10, 3; limit = 5)
ERROR: ArgumentError: Adjustment limit reached: 5 iterations
Stacktrace:
[...]

Dates.TimeМетод

Time(dt::DateTime) -> Time

Преобразовать DateTime в Time. Части часа, минуты, секунды и миллисекунды DateTime используются для создания новой Time. Микросекунды и наносекунды по умолчанию равны нулю.

Dates.nowМетод

now() -> DateTime

Возвращает DateTime соответствующую системному времени пользователя, включая локаль системной временной зоны.

Dates.nowМетод

now(::Type{UTC}) -> DateTime

Возвращает DateTime, соответствующую системному времени пользователя в формате UTC/GMT.

Base.epsФункция

eps(::DateTime) -> Millisecond
eps(::Date) -> Day
eps(::Time) -> Nanosecond

Возвращает Millisecond(1) для значений DateTime, Day(1) для значений Date и Nanosecond(1) для значений Time.

Функции доступа

Dates.yearФункция

year(dt::TimeType) -> Int64

Год Date или DateTime как Int64.

Dates.monthФункция

month(dt::TimeType) -> Int64

Месяц Date или DateTime как Int64.

Dates.weekФункция

week(dt::TimeType) -> Int64

Возвращает номер недели по ISO Date или DateTime как Int64. Обратите внимание, что первой неделя года является неделя, содержащая первую четверг года, что может привести к тому, что даты до 4 января будут в последнюю неделю предыдущего года. Например, week(Date(2005, 1, 1)) - 53-я неделя 2004 года.

Примеры

julia> Dates.week(Date(1989, 6, 22))
25

julia> Dates.week(Date(2005, 1, 1))
53

julia> Dates.week(Date(2004, 12, 31))
53

Dates.dayФункция

day(dt::TimeType) -> Int64

День месяца Date или DateTime как Int64.

Dates.hourФункция

hour(dt::DateTime) -> Int64

Час дня DateTime как Int64.

hour(t::Time) -> Int64

Час Time как Int64.

Dates.minuteФункция

minute(dt::DateTime) -> Int64

Минута DateTime как Int64.

minute(t::Time) -> Int64

Минута Time как Int64.

Dates.secondФункция

second(dt::DateTime) -> Int64

Секунда DateTime как Int64.

second(t::Time) -> Int64

Секунда Time как Int64.

Dates.millisecondФункция

millisecond(dt::DateTime) -> Int64

Миллисекунда DateTime как Int64.

millisecond(t::Time) -> Int64

Миллисекунда Time в виде Int64.

Dates.microsecondФункция

microsecond(t::Time) -> Int64

Микросекунда Time в виде Int64.

Dates.nanosecondФункция

nanosecond(t::Time) -> Int64

Наносекунда Time в виде Int64.

Dates.YearМетод

Year(v)

Создать объект Year с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.

Dates.MonthМетод

Month(v)

Создать объект Month с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.

Dates.WeekМетод

Week(v)

Создать объект Week с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.

Dates.DayМетод

Day(v)

Создать объект Day с заданным значением v. Входное значение должно быть без потерь преобразуемо в Int64.

Dates.HourМетод

Hour(dt::DateTime) -> Hour

Час в DateTime в виде Hour.

Dates.MinuteМетод

Minute(dt::DateTime) -> Minute

Минута в DateTime в виде Minute.

Dates.SecondМетод

Second(dt::DateTime) -> Second

Секунда в DateTime в виде Second.

Dates.MillisecondМетод

Millisecond(dt::DateTime) -> Millisecond

Миллисекунда в DateTime в виде Millisecond.

Dates.MicrosecondМетод

Microsecond(dt::Time) -> Microsecond

Микросекунда в Time в виде Microsecond.

Dates.NanosecondМетод

Nanosecond(dt::Time) -> Nanosecond

Наносекунда в Time в виде Nanosecond.

Dates.yearmonthФункция

yearmonth(dt::TimeType) -> (Int64, Int64)

Одновременный возврат года и месяца для Date или DateTime.

Dates.monthdayФункция

monthday(dt::TimeType) -> (Int64, Int64)

Одновременный возврат месяца и дня для Date или DateTime.

Dates.yearmonthdayФункция

yearmonthday(dt::TimeType) -> (Int64, Int64, Int64)

Одновременный возврат года, месяца и дня для Date или DateTime.

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

Dates.daynameФункция

dayname(dt::TimeType; locale="english") -> String

Возвращает полное имя дня недели для Date или DateTime в заданном locale.

Примеры

julia> Dates.dayname(Date("2000-01-01"))
"Saturday"

Dates.dayabbrФункция

dayabbr(dt::TimeType; locale="english") -> String

Возвращает сокращенное имя дня недели для Date или DateTime в заданном locale.

Примеры

julia> Dates.dayabbr(Date("2000-01-01"))
"Sat"

Dates.dayofweekФункция

dayofweek(dt::TimeType) -> Int64

Возвращает день недели в виде Int64 с 1 = Monday, 2 = Tuesday, etc..

Примеры

julia> Dates.dayofweek(Date("2000-01-01"))
6

Dates.dayofmonthФункция

dayofmonth(dt::TimeType) -> Int64

День месяца Date или DateTime в виде Int64.

Dates.dayofweekofmonthФункция

dayofweekofmonth(dt::TimeType) -> Int

Для дня недели dt, возвращает его номер в месяце dt. Если день недели dt — понедельник, то 1 = First Monday of the month, 2 = Second Monday of the month, etc. В диапазоне 1:5.

Примеры

```jldoctest julia> Dates.dayofweekofmonth(Date("2000-02-01")) 1

julia> Dates.dayofweekofmonth(Date("2000-02-08")) 2

julia> Dates.dayofweekofmonth(Date("2000-02-15")) 3 ````

Dates.daysofweekinmonthФункция

daysofweekinmonth(dt::TimeType) -> Int

Для дня недели dt, возвращает общее количество этого дня недели в месяце dt . Возвращает 4 или 5. Полезно в временных выражениях для указания последнего дня недели в месяце, включая dayofweekofmonth(dt) == daysofweekinmonth(dt) в функцию корректировки.

Примеры

julia> Dates.daysofweekinmonth(Date("2005-01-01"))
5

julia> Dates.daysofweekinmonth(Date("2005-01-04"))
4

Dates.monthnameФункция

monthname(dt::TimeType; locale="english") -> String

Возвращает полное имя месяца Date или DateTime в заданном locale.

Примеры

julia> Dates.monthname(Date("2005-01-04"))
"January"

Dates.monthabbrФункция

monthabbr(dt::TimeType; locale="english") -> String

Возвращает сокращенное имя месяца Date или DateTime в заданном locale.

Примеры

julia> Dates.monthabbr(Date("2005-01-04"))
"Jan"

Dates.daysinmonthФункция

daysinmonth(dt::TimeType) -> Int

Возвращает количество дней в месяце dt. Значение будет 28, 29, 30 или 31.

Примеры

julia> Dates.daysinmonth(Date("2000-01"))
31

julia> Dates.daysinmonth(Date("2001-02"))
28

julia> Dates.daysinmonth(Date("2000-02"))
29

Dates.isleapyearФункция

isleapyear(dt::TimeType) -> Bool

Возвращает true, если год dt является високосным.

Примеры

julia> Dates.isleapyear(Date("2004"))
true

julia> Dates.isleapyear(Date("2005"))
false

Dates.dayofyearФункция

dayofyear(dt::TimeType) -> Int

Возвращает день года для dt, где 1 января — день 1.

Dates.daysinyearФункция

daysinyear(dt::TimeType) -> Int

Возвращает 366, если год dt високосный, в противном случае возвращает 365.

Примеры

julia> Dates.daysinyear(1999)
365

julia> Dates.daysinyear(2000)
366

Dates.quarterofyearФункция

quarterofyear(dt::TimeType) -> Int

Возвращает квартал, в котором находится dt. Диапазон значений от 1 до 4.

Dates.dayofquarterФункция

dayofquarter(dt::TimeType) -> Int

Возвращает день текущего квартала dt. Диапазон значений от 1 до 92.

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

Base.truncМетод

trunc(dt::TimeType, ::Type{Period}) -> TimeType

Округляет значение dt в соответствии с указанным типом Period.

Примеры

julia> trunc(Dates.DateTime("1996-01-01T12:30:00"), Dates.Day)
1996-01-01T00:00:00

Dates.firstdayofweekФункция

firstdayofweek(dt::TimeType) -> TimeType

Корректирует dt до понедельника своей недели.

Примеры

julia> Dates.firstdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-01T00:00:00

Dates.lastdayofweekФункция

lastdayofweek(dt::TimeType) -> TimeType

Корректирует dt до воскресенья своей недели.

Примеры

julia> Dates.lastdayofweek(DateTime("1996-01-05T12:30:00"))
1996-01-07T00:00:00

Dates.firstdayofmonthФункция

firstdayofmonth(dt::TimeType) -> TimeType

Корректирует dt до первого дня своего месяца.

Примеры

julia> Dates.firstdayofmonth(DateTime("1996-05-20"))
1996-05-01T00:00:00

Dates.lastdayofmonthФункция

lastdayofmonth(dt::TimeType) -> TimeType

Корректирует dt до последнего дня своего месяца.

Примеры

julia> Dates.lastdayofmonth(DateTime("1996-05-20"))
1996-05-31T00:00:00

Dates.firstdayofyearФункция

firstdayofyear(dt::TimeType) -> TimeType

Корректирует dt до первого дня своего года.

Примеры

julia> Dates.firstdayofyear(DateTime("1996-05-20"))
1996-01-01T00:00:00

Dates.lastdayofyearФункция

lastdayofyear(dt::TimeType) -> TimeType

Корректирует dt до последнего дня своего года.

Примеры

julia> Dates.lastdayofyear(DateTime("1996-05-20"))
1996-12-31T00:00:00

Dates.firstdayofquarterФункция

firstdayofquarter(dt::TimeType) -> TimeType

Корректирует dt до первого дня своего квартала.

Примеры

julia> Dates.firstdayofquarter(DateTime("1996-05-20"))
1996-04-01T00:00:00

julia> Dates.firstdayofquarter(DateTime("1996-08-20"))
1996-07-01T00:00:00

Dates.lastdayofquarterФункция

lastdayofquarter(dt::TimeType) -> TimeType

Корректирует dt до последнего дня своего квартала.

Примеры

julia> Dates.lastdayofquarter(DateTime("1996-05-20"))
1996-06-30T00:00:00

julia> Dates.lastdayofquarter(DateTime("1996-08-20"))
1996-09-30T00:00:00

Dates.tonextМетод

tonext(dt::TimeType, dow::Int; same::Bool=false) -> TimeType

Корректирует dt до следующего дня недели, соответствующего dow, с 1 = Monday, 2 = Tuesday, etc. Установка same=true позволяет рассматривать текущий dt как следующий dow, что исключает корректировку.

Dates.toprevМетод

toprev(dt::TimeType, dow::Int; same::Bool=false) -> TimeType

Корректирует dt до предыдущего дня недели, соответствующего dow, с 1 = Monday, 2 = Tuesday, etc. Установка same=true позволяет рассматривать текущий dt как предыдущий dow, что исключает корректировку.

Dates.tofirstФункция

tofirst(dt::TimeType, dow::Int; of=Month) -> TimeType

Корректирует dt до первого dow своего месяца. В качестве альтернативы, of=Year будет скорректировано до первого dow года.

Dates.tolastФункция

tolast(dt::TimeType, dow::Int; of=Month) -> TimeType

Корректирует dt до последнего dow своего месяца. В качестве альтернативы, of=Year будет скорректировано до последнего dow года.

Dates.tonextМетод

tonext(func::Function, dt::TimeType; step=Day(1), limit=10000, same=false) -> TimeType

Корректирует dt путём итерации не более limit раз с шагом step до тех пор, пока func не вернёт true. func должен принимать один аргумент TimeType и возвращать Bool. same позволяет рассматривать dt при выполнении func.

Dates.toprevМетод

toprev(func::Function, dt::TimeType; step=Day(-1), limit=10000, same=false) -> TimeType

Корректирует dt путём итерации не более limit раз с шагом step до тех пор, пока func не вернёт true. func должен принимать один аргумент TimeType и возвращать Bool. same позволяет рассматривать dt при выполнении func.

Периоды

Dates.PeriodМетод

Year(v)
Month(v)
Week(v)
Day(v)
Hour(v)
Minute(v)
Second(v)
Millisecond(v)
Microsecond(v)
Nanosecond(v)

Создаёт тип Period со значением v. Входное значение должно быть без потерь преобразуемо в Int64.

Dates.CompoundPeriodМетод

CompoundPeriod(periods) -> CompoundPeriod

Создаёт CompoundPeriod из массива Vector Period. Все Period одного типа будут сложены вместе.

Примеры

julia> Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13))
25 hours

julia> Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1))
-1 hour, 1 minute

julia> Dates.CompoundPeriod(Dates.Month(1), Dates.Week(-2))
1 month, -2 weeks

julia> Dates.CompoundPeriod(Dates.Minute(50000))
50000 minutes

Dates.defaultФункция

default(p::Period) -> Period

Возвращает разумное значение по умолчанию для входного периода, возвращая T(1) для года, месяца и дня и T(0) для часа, минуты, секунды и миллисекунды.

Функции округления

Date и DateTime значения могут быть округлены до указанного разрешения (например, 1 месяц или 15 минут) с помощью floor, ceil, или round.

Base.floorМетод

floor(dt::TimeType, p::Period) -> TimeType

Возвращает ближайшее Date или DateTime значение, меньшее или равное dt с разрешением p.

Для удобства, p может быть типом вместо значения: floor(dt, Dates.Hour) — сокращение для floor(dt, Dates.Hour(1)).

julia> floor(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> floor(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:30:00

julia> floor(DateTime(2016, 8, 6, 12, 0, 0), Dates.Day)
2016-08-06T00:00:00

Base.ceilМетод

ceil(dt::TimeType, p::Period) -> TimeType

Возвращает ближайшее Date или DateTime значение, большее или равное dt с разрешением p.

Для удобства, p может быть типом вместо значения: ceil(dt, Dates.Hour) — сокращение для ceil(dt, Dates.Hour(1)).

julia> ceil(Date(1985, 8, 16), Dates.Month)
1985-09-01

julia> ceil(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:45:00

julia> ceil(DateTime(2016, 8, 6, 12, 0, 0), Dates.Day)
2016-08-07T00:00:00

Base.roundМетод

round(dt::TimeType, p::Period, [r::RoundingMode]) -> TimeType

Возвращает Date или DateTime значение, ближайшее к dt с разрешением p. По умолчанию (RoundNearestTiesUp) значения с одинаковым расстоянием (например, округление 9:30 до ближайшего часа) округляются вверх.

Для удобства, p может быть типом вместо значения: round(dt, Dates.Hour) — сокращение для round(dt, Dates.Hour(1)).

julia> round(Date(1985, 8, 16), Dates.Month)
1985-08-01

julia> round(DateTime(2013, 2, 13, 0, 31, 20), Dates.Minute(15))
2013-02-13T00:30:00

julia> round(DateTime(2016, 8, 6, 12, 0, 0), Dates.Day)
2016-08-07T00:00:00

Допустимые режимы округления для round(::TimeType, ::Period, ::RoundingMode) — RoundNearestTiesUp (по умолчанию), RoundDown (floor) и RoundUp (ceil).

Большинство Period значений также можно округлить до указанного разрешения:

Base.floorМетод

floor(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T

Округляет x вниз до ближайшего кратного precision. Если x и precision являются разными подтипами Period, значение результата будет иметь тот же тип, что и precision.

Для удобства, precision может быть типом вместо значения: floor(x, Dates.Hour) — сокращение для floor(x, Dates.Hour(1)).

julia> floor(Dates.Day(16), Dates.Week)
2 weeks

julia> floor(Dates.Minute(44), Dates.Minute(15))
30 minutes

julia> floor(Dates.Hour(36), Dates.Day)
1 day

Округление до кратного precision Month или Year не поддерживается, так как эти Period имеют несогласованную длину.

Base.ceilМетод

ceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> T

Округляет x вверх до ближайшего кратного precision. Если x и precision являются разными подтипами Period, значение результата будет иметь тот же тип, что и precision.

Для удобства, precision может быть типом вместо значения: ceil(x, Dates.Hour) — сокращение для ceil(x, Dates.Hour(1)).

julia> ceil(Dates.Day(16), Dates.Week)
3 weeks

julia> ceil(Dates.Minute(44), Dates.Minute(15))
45 minutes

julia> ceil(Dates.Hour(36), Dates.Day)
2 days

Округление до кратного precision Month или Year не поддерживается, так как эти Period имеют несогласованную длину.

Base.roundМетод

round(x::Period, precision::T, [r::RoundingMode]) where T <: Union{TimePeriod, Week, Day} -> T

Округляет x до ближайшего кратного precision. Если x и precision являются разными подтипами Period, значение результата будет иметь тот же тип, что и precision. По умолчанию (RoundNearestTiesUp) значения с одинаковым расстоянием (например, округление 90 минут до ближайшего часа) округляются вверх.

Для удобства, precision может быть типом вместо значения: round(x, Dates.Hour) — сокращение для round(x, Dates.Hour(1)).

julia> round(Dates.Day(16), Dates.Week)
2 weeks

julia> round(Dates.Minute(44), Dates.Minute(15))
45 minutes

julia> round(Dates.Hour(36), Dates.Day)
2 days

Допустимые режимы округления для round(::Period, ::T, ::RoundingMode) — RoundNearestTiesUp (по умолчанию), RoundDown (floor) и RoundUp (ceil).

Округление до кратного precision Month или Year не поддерживается, так как эти Period имеют несогласованную длину.

Следующие функции не экспортируются:

Dates.floorceilФункция

floorceil(dt::TimeType, p::Period) -> (TimeType, TimeType)

Одновременно возвращает floor и ceil значения Date или DateTime с разрешением p. Более эффективно, чем вызывать floor и ceil по отдельности.

floorceil(x::Period, precision::T) where T <: Union{TimePeriod, Week, Day} -> (T, T)

Одновременно возвращает floor и ceil значения Period с разрешением p. Более эффективно, чем вызывать floor и ceil по отдельности.

Dates.epochdays2dateФункция

epochdays2date(days) -> Date

Принимает количество дней с эпохи округления (0000-01-01T00:00:00) и возвращает соответствующую Date.

Dates.epochms2datetimeФункция

epochms2datetime(milliseconds) -> DateTime

Принимает количество миллисекунд с эпохи округления (0000-01-01T00:00:00) и возвращает соответствующую DateTime.

Dates.date2epochdaysФункция

date2epochdays(dt::Date) -> Int64

Принимает заданную Date и возвращает количество дней с эпохи округления (0000-01-01T00:00:00) как Int64.

Dates.datetime2epochmsФункция

datetime2epochms(dt::DateTime) -> Int64

Принимает заданную DateTime и возвращает количество миллисекунд с эпохи округления (0000-01-01T00:00:00) как Int64.

Функции преобразования

Dates.todayФункция

today() -> Date

Возвращает часть даты из now().

Dates.unix2datetimeФункция

unix2datetime(x) -> DateTime

Принимает количество секунд с эпохи Unix 1970-01-01T00:00:00 и преобразует в соответствующую DateTime.

Dates.datetime2unixФункция

datetime2unix(dt::DateTime) -> Float64

Принимает заданную DateTime и возвращает количество секунд с эпохи Unix 1970-01-01T00:00:00 как Float64.

Dates.julian2datetimeФункция

julian2datetime(julian_days) -> DateTime

Принимает количество дней юлианского календаря с эпохи -4713-11-24T12:00:00 и возвращает соответствующую DateTime.

Dates.datetime2julianФункция

datetime2julian(dt::DateTime) -> Float64

Принимает заданную DateTime и возвращает количество дней юлианского календаря с эпохи -4713-11-24T12:00:00 как Float64.

Dates.rata2datetimeФункция

rata2datetime(days) -> DateTime

Принимает количество дней Rata Die с эпохи 0000-12-31T00:00:00 и возвращает соответствующую DateTime.

Dates.datetime2rataФункция

datetime2rata(dt::TimeType) -> Int64

Возвращает количество дней Rata Die с эпохи от заданной Date или DateTime.

Константы

Дни недели:

Месяцы года: