Spec-Zone.ru › Julia 1.9

Даты

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

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

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

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",dateformat"y-m-d") или DateTime("20150101",dateformat"yyyymmdd").

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

Как и в случае с конструкторами выше, например, Date(2013), разделители DateFormat позволяют пропускать части дат и времени, если заданы предыдущие части. Другие части принимают обычные значения по умолчанию. Например, Date("1981-03", dateformat"y-m-d") возвращает 1981-03-01, в то время как Date("31/12", dateformat"d/m/y") дает 0001-12-31. (Обратите внимание, что год по умолчанию — 1 AD/CE.) Однако пустая строка всегда вызывает ArgumentError.

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

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

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

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

Или вы можете создать объект 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

В качестве альтернативы используйте вещание:

julia> years = ["2015", "2016"];

julia> Date.(years, DateFormat("yyyy"))
2-element Vector{Date}:
 2015-01-01
 2016-01-01

Для удобства вы можете передать строку формата напрямую (например, Date("2015-01-01","y-m-d")), хотя эта форма влечет за собой потери производительности, если вы неоднократно анализируете один и тот же формат, так как она создает новый объект DateFormat каждый раз.

Помимо конструкторов, объект Date или DateTime может быть создан из строк с помощью функций parse и tryparse, но с необязательным третьим аргументом типа DateFormat , определяющим формат; например, parse(Date, "06.23.2013", dateformat"m.d.y"), или tryparse(DateTime, "1999-12-31T23:59:59"), который использует формат по умолчанию. Отличительная особенность функций заключается в том, что с tryparse ошибка не возникает, если строка пустая или имеет неправильный формат; вместо этого возвращается nothing.

До Julia 1.9, пустые строки могли передаваться в конструкторы и parse без ошибок, возвращая соответствующим образом DateTime(1), Date(1) или Time(0). Аналогично, tryparse не возвращало nothing.

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

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

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

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

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

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

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

julia> dt > dt2
true

julia> dt != dt2
true

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

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

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

julia> dt - dt2
4411 days

julia> dt2 - dt
-4411 days

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

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

julia> dt - dt2
381110400000 milliseconds

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

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

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

julia> Dates.year(t)
2014

julia> Dates.month(t)
1

julia> Dates.week(t)
5

julia> Dates.day(t)
31

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

julia> Dates.Year(t)
2014 years

julia> Dates.Day(t)
31 days

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

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

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

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

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

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

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

julia> Dates.value(t)
735264

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

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

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

julia> Dates.dayofweek(t)
5

julia> Dates.dayname(t)
"Friday"

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

Месяце года:

julia> Dates.monthname(t)
"January"

julia> Dates.daysinmonth(t)
31

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

julia> Dates.isleapyear(t)
false

julia> Dates.dayofyear(t)
31

julia> Dates.quarterofyear(t)
1

julia> Dates.dayofquarter(t)
31

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

julia> collect(dr)
7-element Vector{Date}:
 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 Vector{Date}:
 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

Представление периодов или интервалов, которые не являются целыми кратными базовым типам, может быть достигнуто с помощью типа Dates.CompoundPeriod. Составные периоды могут быть построены вручную из простых типов Period. Кроме того, функция canonicalize может использоваться для разбиения периода на Dates.CompoundPeriod. Это особенно полезно для преобразования длительности, например, разницы между двумя DateTime, в более удобное представление.

julia> cp = Dates.CompoundPeriod(Day(1),Minute(1))
1 day, 1 minute

julia> t1 = DateTime(2018,8,8,16,58,00)
2018-08-08T16:58:00

julia> t2 = DateTime(2021,6,23,10,00,00)
2021-06-23T10:00:00

julia> canonicalize(t2-t1) # creates a CompoundPeriod
149 weeks, 6 days, 17 hours, 2 minutes

Округление

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 с использованием обозначения 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 до чётного кратного месяцев приведёт к нечётного значения в поле месяца. Поскольку и месяцы, и годы могут содержать неравное число дней, не известно, приведёт ли округление до чётного числа дней к чётному значению в поле дней.

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

Справочник API

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

Dates.PeriodТип

Period
Year
Quarter
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.TimeZoneТип

TimeZone

Географическая зона, обычно основанная на долготе, определяющая время в определенном месте. Некоторые часовые пояса соблюдают летнее время (например, EST -> EDT). Для реализации и большей поддержки обратитесь к пакету TimeZones.jl

Dates.UTCТип

UTC

UTC, или Координированное универсальное время, является TimeZone, от которого отсчитываются все остальные. Он связан со временем на 0° долготы. Он не корректируется на летнее время.

Функции дат

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 -> second(dt) == 40, 2010, 10, 20, 10; step = Second(1))
2010-10-20T10:00:40

julia> DateTime(dt -> hour(dt) == 20, 2010, 10, 20, 10; step = 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 каждый раз при вызове. Рекомендуется создать объект DateFormat и использовать его как второй аргумент, чтобы избежать потери производительности при многократном использовании одного и того же формата.

Пример

julia> DateTime("2020-01-01", "yyyy-mm-dd")
2020-01-01T00:00:00

julia> a = ("2020-01-01", "2020-01-02");

julia> [DateTime(d, dateformat"yyyy-mm-dd") for d ∈ a] # preferred
2-element Vector{DateTime}:
 2020-01-01T00:00:00
 2020-01-02T00:00:00

Dates.formatМетод

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

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

Код Примеры Комментарий
y 6 Числовой год с фиксированной шириной
Y 1996 Числовой год с минимальной шириной
m 1, 12 Числовой месяц с минимальной шириной
u Jan Сокращенное название месяца до 3 символов в соответствии с locale
U January Полное название месяца в соответствии с ключевым словом locale
d 1, 31 День месяца с минимальной шириной
H 0, 23 Час (24-часовой формат) с минимальной шириной
M 0, 59 Минута с минимальной шириной
S 0, 59 Секунда с минимальной шириной
s 000, 500 Миллисекунда с минимальной шириной 3
e Mon, Tue Сокращенные дни недели
E Monday Полное название дня недели

Количество последовательных символов кода указывает ширину кода. Формат yyyy-mm указывает, что код y должен иметь ширину четыре, а m - ширину два. Коды, которые возвращают числовые цифры, имеют связанный режим: фиксированная или минимальная ширина. Режим фиксированной ширины заполняет слева нулями значение, если оно короче заданной ширины, и обрезает значение, если оно длиннее. Режим минимальной ширины работает так же, как режим фиксированной ширины, за исключением того, что он не обрезает значения, которые длиннее заданной ширины.

При создании format вы можете использовать любые символы, не являющиеся кодом, в качестве разделителя. Например, чтобы сгенерировать строку «1996-01-15T00:00:00», вы можете использовать format: «yyyy-mm-ddTHH:MM:SS». Обратите внимание, что если вам нужно использовать символ кода как литерный символ, вы можете использовать символ экранирования обратный слэш. Строка «1996y01m» может быть получена с помощью формата «yyyy\ymm\m».

Dates.DateFormatТип

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

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

Код Совпадения Комментарий
Y 1996, 96 Возвращает год 1996, 0096
y 1996, 96 То же, что и Y в parse, но отбрасывает лишние цифры в format
m 1, 01 Соответствует месяцам из 1 или 2 цифр
u Jan Соответствует сокращенным названиям месяцев в соответствии с ключевым словом locale
U January Соответствует полным названиям месяцев в соответствии с ключевым словом locale
d 1, 01 Соответствует дням из 1 или 2 цифр
H 00 Соответствует часам (24-часовой формат)
I 00 Для вывода часов в 12-часовом формате
M 00 Соответствует минутам
S 00 Соответствует секундам
s .500 Соответствует миллисекундам
e Mon, Tues Соответствует сокращенным названиям дней недели
E Monday Соответствует полным названиям дней недели
p AM Соответствует AM/PM (регистр не учитывается)
yyyymmdd 19960101 Соответствует году, месяцу и дню с фиксированной шириной

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

Обратите внимание, что 12:00 AM соответствует 00:00 (полночь), а 12:00 PM соответствует 12:00 (полдень). При анализе времени со спецификатором p, любая цифра часа (как H, так и I) интерпретируется как 12-часовой формат, поэтому код I в основном полезен для вывода.

Создание объекта DateFormat требует ресурсов. Всякий раз, когда это возможно, создайте его один раз и используйте многократно или попробуйте использовать макрос строки dateformat"". Использование этого макроса создает объект DateFormat один раз во время расширения макроса и повторно использует его позже. Также доступны несколько предопределенных форматировщиков, перечисленных позже.

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

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=ISODateTimeFormat) -> DateTime

Создайте объект DateTime, проанализировав строку даты и времени dt по шаблону, заданному объектом DateFormat, или "yyyy-mm-dd\THH:MM:SS.s" по умолчанию.

Аналогично 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 -> week(date) == 20, 2010, 01, 01)
2010-05-17

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

julia> Date(date -> 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 каждый раз при вызове. Рекомендуется создавать объект DateFormat вместо этого и использовать его в качестве второго аргумента, чтобы избежать потери производительности при многократном использовании одного и того же формата.

Пример

julia> Date("2020-01-01", "yyyy-mm-dd")
2020-01-01

julia> a = ("2020-01-01", "2020-01-02");

julia> [Date(d, dateformat"yyyy-mm-dd") for d ∈ a] # preferred
2-element Vector{Date}:
 2020-01-01
 2020-01-02

Dates.DateМетод

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

Создайте Date, проанализировав строку даты d по шаблону, заданному объектом DateFormat, или по умолчанию "yyyy-mm-dd".

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

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> Time(t -> minute(t) == 30, 20)
20:30:00

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

julia> Time(t -> 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.TimeМетод

Time(t::AbstractString, format::AbstractString; locale="english") -> Time

Создайте Time, разобрав строку времени t по шаблону, заданному в строке format (см. DateFormat для синтаксиса).

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

Пример

julia> Time("12:34pm", "HH:MMp")
12:34:00

julia> a = ("12:34pm", "2:34am");

julia> [Time(d, dateformat"HH:MMp") for d ∈ a] # preferred
2-element Vector{Time}:
 12:34:00
 02:34:00

Dates.TimeМетод

Time(t::AbstractString, df::DateFormat=ISOTimeFormat) -> Time

Создайте Time, разобрав строку даты и времени t по шаблону, указанному в объекте DateFormat, или «HH:MM:SS.s», если он опущен.

Аналогично Time(::AbstractString, ::AbstractString), но более эффективен при многократном разборе строк времени с подобным форматом с помощью предварительно созданного объекта DateFormat.

Dates.nowМетод

now() -> DateTime

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

Dates.nowМетод

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

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

Base.epsМетод

eps(::Type{DateTime}) -> Millisecond
eps(::Type{Date}) -> Day
eps(::Type{Time}) -> Nanosecond
eps(::TimeType) -> Period

Возвращает наименьшее значение единицы, поддерживаемое TimeType.

Примеры

julia> eps(DateTime)
1 millisecond

julia> eps(Date)
1 day

julia> eps(Time)
1 nanosecond

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

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> week(Date(1989, 6, 22))
25

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

julia> 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
dayname(day::Integer; locale="english") -> String

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

Примеры

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

julia> dayname(4)
"Thursday"

Dates.dayabbrФункция

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

Возвращает сокращённое имя дня недели Date или DateTime в указанном locale. Также принимает Integer.

Примеры

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

julia> dayabbr(3)
"Wed"

Dates.dayofweekФункция

dayofweek(dt::TimeType) -> Int64

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

Примеры

julia> 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.

Примеры

julia> dayofweekofmonth(Date("2000-02-01"))
1

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

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

Dates.daysofweekinmonthФункция

daysofweekinmonth(dt::TimeType) -> Int

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

Примеры

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

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

Dates.monthnameФункция

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

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

Примеры

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

julia> monthname(2)
"February"

Dates.monthabbrФункция

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

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

Примеры

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

julia> monthabbr(2)
"Feb"

Dates.daysinmonthФункция

daysinmonth(dt::TimeType) -> Int

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

Примеры

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

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

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

Dates.isleapyearФункция

isleapyear(dt::TimeType) -> Bool

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

Примеры

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

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

Dates.dayofyearФункция

dayofyear(dt::TimeType) -> Int

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

Dates.daysinyearФункция

daysinyear(dt::TimeType) -> Int

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

Примеры

julia> daysinyear(1999)
365

julia> 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(DateTime("1996-01-01T12:30:00"), Day)
1996-01-01T00:00:00

Dates.firstdayofweekФункция

firstdayofweek(dt::TimeType) -> TimeType

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

Примеры

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

Dates.lastdayofweekФункция

lastdayofweek(dt::TimeType) -> TimeType

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

Примеры

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

Dates.firstdayofmonthФункция

firstdayofmonth(dt::TimeType) -> TimeType

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

Примеры

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

Dates.lastdayofmonthФункция

lastdayofmonth(dt::TimeType) -> TimeType

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

Примеры

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

Dates.firstdayofyearФункция

firstdayofyear(dt::TimeType) -> TimeType

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

Примеры

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

Dates.lastdayofyearФункция

lastdayofyear(dt::TimeType) -> TimeType

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

Примеры

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

Dates.firstdayofquarterФункция

firstdayofquarter(dt::TimeType) -> TimeType

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

Примеры

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

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

Dates.lastdayofquarterФункция

lastdayofquarter(dt::TimeType) -> TimeType

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

Примеры

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

julia> 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)
Quarter(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.canonicalizeФункция

canonicalize(::CompoundPeriod) -> CompoundPeriod

Приводит CompoundPeriod к канонической форме, применяя следующие правила:

  • Любой Period достаточно большой, чтобы быть частично представленным более грубым Period, разбивается на несколько Period (например, Hour(30) становится Day(1) + Hour(6)).
  • Period с противоположными знаками будут объединены, если это возможно (например, Hour(1) - Day(1) становится -Hour(23)).

Примеры

julia> canonicalize(Dates.CompoundPeriod(Dates.Hour(12), Dates.Hour(13)))
1 day, 1 hour

julia> canonicalize(Dates.CompoundPeriod(Dates.Hour(-1), Dates.Minute(1)))
-59 minutes

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

julia> canonicalize(Dates.CompoundPeriod(Dates.Minute(50000)))
4 weeks, 6 days, 17 hours, 20 minutes

Dates.valueФункция

Dates.value(x::Period) -> Int64

Для данного периода возвращает связанное значение. Например, value(Millisecond(10)) возвращает 10 как целое число.

Dates.defaultФункция

default(p::Period) -> Period

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

Dates.periodsФункция

Dates.periods(::CompoundPeriod) -> Vector{Period}

Возвращает Vector Period , которые составляют данный CompoundPeriod.

Эта функция требует Julia 1.7 или новее.

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

Значения 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), Month)
1985-08-01

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

julia> floor(DateTime(2016, 8, 6, 12, 0, 0), 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), Month)
1985-09-01

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

julia> ceil(DateTime(2016, 8, 6, 12, 0, 0), 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), Month)
1985-08-01

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

julia> round(DateTime(2016, 8, 6, 12, 0, 0), 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(Day(16), Week)
2 weeks

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

julia> floor(Hour(36), 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(Day(16), Week)
3 weeks

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

julia> ceil(Hour(36), 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(Day(16), Week)
2 weeks

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

julia> round(Hour(36), 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.

Константы

Дни недели:

Переменная Сокр. Значение (Цел.)
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.ISODateTimeFormatКонстанта

Dates.ISODateTimeFormat

Описывает форматирование даты и времени в формате ISO8601. Это значение по умолчанию для Dates.format объекта DateTime.

Пример

julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), ISODateTimeFormat)
"2018-08-08T12:00:43.001"

Dates.ISODateFormatКонстанта

Dates.ISODateFormat

Описывает форматирование даты в формате ISO8601. Это значение по умолчанию для Dates.format объекта Date.

Пример

julia> Dates.format(Date(2018, 8, 8), ISODateFormat)
"2018-08-08"

Dates.ISOTimeFormatКонстанта

Dates.ISOTimeFormat

Описывает форматирование времени в формате ISO8601. Это значение по умолчанию для Dates.format объекта Time.

Пример

julia> Dates.format(Time(12, 0, 43, 1), ISOTimeFormat)
"12:00:43.001"

Dates.RFC1123FormatКонстанта

Dates.RFC1123Format

Описывает форматирование даты и времени в формате RFC1123.

Пример

julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), RFC1123Format)
"Wed, 08 Aug 2018 12:00:43"
  • 1Понятие секунды UT на самом деле довольно фундаментально. Существуют в основном два разных понятия времени, обычно принятых, одно основано на физическом вращении Земли (один полный оборот = 1 день), другое основано на СИ секунде (фиксированное, постоянное значение). Они радикально отличаются! Подумайте об этом, «секунда UT», как определена относительно вращения Земли, может иметь разную абсолютную длину в зависимости от дня! В любом случае, тот факт, что Date и DateTime основаны на секундах UT, является упрощающим, но честным предположением, чтобы избежать таких сложностей, как високосные секунды и вся их сложность. Эта основа времени формально называется UT или UT1. Основывание типов на секунде UT в основном означает, что каждая минута имеет 60 секунд, а каждый день 24 часа и приводит к более естественным вычислениям при работе с календарными датами.

© 2009–2023 Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors
Licensed under the MIT License.
https://docs.julialang.org/en/v1.9/stdlib/Dates/

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API