std/times

Модуль times содержит функции и типы для работы со временем, используя пролептический григорианский календарь. Он также доступен для целевой платформы JavaScript.

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

Примеры

import std/[times, os]
# Simple benchmarking
let time = cpuTime()
sleep(100) # Replace this with something to be timed
echo "Time taken: ", cpuTime() - time

# Current date & time
let now1 = now()     # Current timestamp as a DateTime in local time
let now2 = now().utc # Current timestamp as a DateTime in UTC
let now3 = getTime() # Current timestamp as a Time

# Arithmetic using Duration
echo "One hour from now      : ", now() + initDuration(hours = 1)
# Arithmetic using TimeInterval
echo "One year from now      : ", now() + 1.years
echo "One month from now     : ", now() + 1.months

Парсинг и форматирование дат

Тип DateTime может быть распарсен и отформатирован с использованием различных процедур parse и format.

let dt = parse("2000-01-01", "yyyy-MM-dd")
echo dt.format("yyyy-MM-dd")

Различные поддерживаемые шаблоны форматирования описаны ниже.

Другие строки могут быть вставлены, поместив их в ''. Например, hh'->'mm даст 01->56. Помимо пробелов, следующие символы могут быть вставлены без кавычек: : - , . ( ) / [ ]. Буквальный символ ' может быть указан с помощью ''.

Однако вам не обязательно разделять шаблоны форматирования, так как недвусмысленный шаблон форматирования, например, yyyyMMddhhmmss, также является допустимым (хотя только для годов в диапазоне от 1 до 9999).

Продолжительность vs Интервал времени

Модуль times экспортирует два похожих типа, которые оба используются для представления промежутка времени: Duration и TimeInterval. Этот раздел объясняет их различия и когда один тип предпочтительнее другого (кратко: используйте Duration , если не требуется поддержка месяцев и лет).

Duration

Тип Duration представляет продолжительность времени, хранящуюся как секунды и наносекунды. Тип Duration всегда полностью нормализован, поэтому initDuration(hours = 1) и initDuration(minutes = 60) эквивалентны.

Арифметические операции с типом Duration очень быстры, особенно при использовании с типом Time, поскольку они включают только основные арифметические операции. Поскольку Duration более производительный и проще для понимания, он обычно предпочтительнее.

TimeInterval

Тип TimeInterval представляет продолжительность времени в календарных единицах, например, «1 год и 2 дня». Поскольку некоторые единицы не могут быть нормализованы (например, длина года отличается для високосных лет), тип TimeInterval использует отдельные поля для каждой единицы. Тип TimeInterval из этого модуля обычно не нормализует ничего, поэтому даже единицы, которые могли бы быть нормализованы (например, секунды, миллисекунды и т.д.), остаются неизменными.

Арифметические операции с типом TimeInterval могут быть очень медленными, поскольку требуют информации о часовом поясе.

Поскольку этот тип медленнее и сложнее, тип TimeInterval следует избегать, если программа не нуждается явно в функциях, которых у Duration нет.

Сколько длится день?

Следует особо отметить, что обработка дней отличается между TimeInterval и Duration. Тип Duration всегда считает день точно 86400 секундами. Для TimeInterval это более сложно.

Например, рассмотрим промежуток времени между двумя отметками времени в одном часовом поясе:

• 2018-03-25T12:00+02:00
• 2018-03-26T12:00+01:00

Если рассматривать только дату и время, то кажется, что прошло ровно один день. Однако смещения UTC разные, что означает, что смещение UTC было изменено где-то между. Это происходит дважды в год для часовых поясов, которые используют летнее время. Из-за этого изменения фактически прошло 25 часов.

Тип TimeInterval использует календарные единицы и покажет, что прошло ровно один день. Тип Duration с другой стороны, нормализует все до секунд и, следовательно, скажет, что прошло 90000 секунд, что равно 25 часам.

См. также

• модуль monotypes

Импорты

strutils, math, options, since, winlean, time_t

Типы

DateTime = object of RootObj

Представляет время в разных частях. Хотя этот тип может представлять високосные секунды, они обычно не поддерживаются в этом модуле. Они не игнорируются, но DateTime возвращаемые процедурами в этом модуле никогда не будут иметь високосной секунды. Исходный код Изменить

DateTimeLocale = object
  MMM*: array[mJan .. mDec, string]
  MMMM*: array[mJan .. mDec, string]
  ddd*: array[dMon .. dSun, string]
  dddd*: array[dMon .. dSun, string]

Исходный код Изменить

Duration = object

Представляет фиксированную продолжительность времени, то есть продолжительность с постоянной длиной, независимо от контекста.

Для создания нового Duration, используйте initDuration. Вместо попытки получить доступ к закрытым атрибутам, используйте inSeconds для преобразования в секунды и inNanoseconds для преобразования в наносекунды.

Исходный код Изменить

DurationParts = array[FixedTimeUnit, int64]

Исходный код Изменить

FixedTimeUnit = range[Nanoseconds .. Weeks]

Поддиапазон TimeUnit, который содержит только единицы с фиксированной продолжительностью. Это единицы, которые могут быть представлены Duration. Исходный код Изменить

HourRange = range[0 .. 23]

Исходный код Изменить

IsoWeekRange = range[1 .. 53]

Номер недели календаря ISO 8601. Исходный код Изменить

IsoYear = distinct int

Номер календарного года ISO 8601.

Предупреждение: Год ISO, основанный на неделе, может соответствовать следующему или предыдущему году с 29 декабря по 3 января.

Исходный код Изменить

MinuteRange = range[0 .. 59]

Исходный код Изменить

Month = enum
  mJan = (1, "January"), mFeb = "February", mMar = "March", mApr = "April",
  mMay = "May", mJun = "June", mJul = "July", mAug = "August",
  mSep = "September", mOct = "October", mNov = "November", mDec = "December"

Представляет месяц. Обратите внимание, что перечисление начинается с 1, поэтому ord(month) даст номер месяца в диапазоне 1..12. Исходный код Изменить

MonthdayRange = range[1 .. 31]

Исходный код Изменить

NanosecondRange = range[0 .. 999999999]

Исходный код Изменить

SecondRange = range[0 .. 60]

Включает значение 60, чтобы учесть високосную секунду. Однако обратите внимание, что second DateTime никогда не будет високосной секундой. Исходный код Изменить

Time = object

Представляет точку во времени. Исходный код Изменить

TimeFormat = object
  ## \
  ## Contains the patterns encoded as bytes.
  ## Literal values are encoded in a special way.
  ## They start with `Lit.byte`, then the length of the literal, then the
  ## raw char values of the literal. For example, the literal `foo` would
  ## be encoded as `@[Lit.byte, 3.byte, 'f'.byte, 'o'.byte, 'o'.byte]`.

Представляет формат для разбора и печати типов времени.

Для создания нового TimeFormat используйте процедуру initTimeFormat.

Исходный код Изменить

TimeFormatParseError = object of ValueError

Возникает, когда происходит неудачный разбор строки TimeFormat. Исходный код Изменить

TimeInterval = object
  nanoseconds*: int          ## The number of nanoseconds
  microseconds*: int         ## The number of microseconds
  milliseconds*: int         ## The number of milliseconds
  seconds*: int              ## The number of seconds
  minutes*: int              ## The number of minutes
  hours*: int                ## The number of hours
  days*: int                 ## The number of days
  weeks*: int                ## The number of weeks
  months*: int               ## The number of months
  years*: int                ## The number of years

Представляет нефиксированную продолжительность времени. Может использоваться для добавления и вычитания нефиксированных единиц времени из DateTime или Time.

Создайте новый TimeInterval с помощью процедуры initTimeInterval.

Обратите внимание, что TimeInterval не представляет фиксированную продолжительность времени, поскольку продолжительность некоторых единиц зависит от контекста (например, год может длиться 365 или 366 дней). Нефиксированные единицы времени — это годы, месяцы, дни и недели.

Обратите внимание, что TimeInterval из модуля times никогда не нормализуются. Если вам нужно нормализовать единицу времени, используйте Duration.

Исходный код Изменить

TimeIntervalParts = array[TimeUnit, int]

Исходный код Изменить

TimeParseError = object of ValueError

Возникает, когда разбор входных данных с помощью TimeFormat терпит неудачу. Исходный код Изменить

TimeUnit = enum
  Nanoseconds, Microseconds, Milliseconds, Seconds, Minutes, Hours, Days, Weeks,
  Months, Years

Разные единицы времени. Исходный код Изменить

Timezone = ref object

Интерфейс часового пояса для поддержки DateTime произвольных часовых поясов. Модуль times предоставляет только реализации для местного времени системы и UTC. Исходный код Изменить

WeekDay = enum
  dMon = "Monday", dTue = "Tuesday", dWed = "Wednesday", dThu = "Thursday",
  dFri = "Friday", dSat = "Saturday", dSun = "Sunday"

Представляет день недели. Исходный код Изменить

YeardayRange = range[0 .. 365]

Исходный код Изменить

ZonedTime = object
  time*: Time                ## The point in time being represented.
  utcOffset*: int            ## The offset in seconds west of UTC,
                             ## including any offset due to DST.
  isDst*: bool               ## Determines whether DST is in effect.

Представляет точку во времени с ассоциированным смещением UTC и флагом DST. Этот тип используется только для реализации часовых поясов. Исходный код Изменить

Константы

DefaultLocale = (MMM: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
                       "Sep", "Oct", "Nov", "Dec"], MMMM: ["January",
    "February", "March", "April", "May", "June", "July", "August", "September",
    "October", "November", "December"],
                 ddd: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"], dddd: [
    "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])

Исходный код Изменить

DurationZero = (seconds: 0, nanosecond: 0)

Нулевое значение для продолжительностей. Полезно для сравнений.

doAssert initDuration(seconds = 1) > DurationZero
doAssert initDuration(seconds = 0) == DurationZero

Исходный код Изменить

Процедуры

proc `$`(dt: DateTime): string {....tags: [], raises: [], gcsafe, forbids: [].}

Преобразует объект DateTime в строковое представление. Используется формат yyyy-MM-dd'T'HH:mm:sszzz.

Пример:

let dt = dateTime(2000, mJan, 01, 12, 00, 00, 00, utc())
doAssert $dt == "2000-01-01T12:00:00Z"
doAssert $default(DateTime) == "Uninitialized DateTime"

Исходный код Редактировать

proc `$`(dur: Duration): string {....raises: [], tags: [], forbids: [].}

Человеко-понятное строковое представление Duration.

Пример:

doAssert $initDuration(seconds = 2) == "2 seconds"
doAssert $initDuration(weeks = 1, days = 2) == "1 week and 2 days"
doAssert $initDuration(hours = 1, minutes = 2, seconds = 3) ==
  "1 hour, 2 minutes, and 3 seconds"
doAssert $initDuration(milliseconds = -1500) ==
  "-1 second and -500 milliseconds"

Исходный код Редактировать

proc `$`(f: TimeFormat): string {....raises: [], tags: [], forbids: [].}

Возвращает строку формата, используемую для построения f.

Пример:

let f = initTimeFormat("yyyy-MM-dd")
doAssert $f == "yyyy-MM-dd"

Исходный код Редактировать

proc `$`(p: IsoYear): string {.borrow, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `$`(ti: TimeInterval): string {....raises: [], tags: [], forbids: [].}

Получить строковое представление TimeInterval.

Пример:

doAssert $initTimeInterval(years = 1, nanoseconds = 123) ==
  "1 year and 123 nanoseconds"
doAssert $initTimeInterval() == "0 nanoseconds"

Исходный код Редактировать

proc `$`(time: Time): string {....tags: [], raises: [], gcsafe, forbids: [].}

Преобразует значение Time в строковое представление. Используется локальная временная зона и формат yyyy-MM-dd'T'HH:mm:sszzz.

Пример:

let dt = dateTime(1970, mJan, 01, 00, 00, 00, 00, local())
let tm = dt.toTime()
doAssert $tm == "1970-01-01T00:00:00" & format(dt, "zzz")

Исходный код Редактировать

proc `$`(zone: Timezone): string {....raises: [], tags: [], forbids: [].}

Возвращает имя временной зоны. Исходный код Редактировать

proc `*`(a: Duration; b: int64): Duration {....gcsafe, noSideEffect, ...gcsafe,
    extern: "ntMulDuration", raises: [], tags: [], forbids: [].}

Умножение длительности на скаляр.

Пример:

doAssert initDuration(seconds = 1) * 5 == initDuration(seconds = 5)
doAssert initDuration(minutes = 45) * 3 == initDuration(hours = 2, minutes = 15)

Исходный код Редактировать

proc `*`(a: int64; b: Duration): Duration {....gcsafe, noSideEffect, ...gcsafe,
    extern: "ntMulInt64Duration", raises: [], tags: [], forbids: [].}

Умножение длительности на скаляр.

Пример:

doAssert 5 * initDuration(seconds = 1) == initDuration(seconds = 5)
doAssert 3 * initDuration(minutes = 45) == initDuration(hours = 2, minutes = 15)

Исходный код Редактировать

proc `*=`(a: var Duration; b: int) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `+`(a, b: Duration): Duration {....gcsafe, noSideEffect, ...gcsafe,
                                     extern: "ntAddDuration", raises: [],
                                     tags: [], forbids: [].}

Сложение двух интервалов времени.

Пример:

doAssert initDuration(seconds = 1) + initDuration(days = 1) ==
  initDuration(seconds = 1, days = 1)

Исходный код Редактировать

proc `+`(a: Time; b: Duration): Time {....gcsafe, noSideEffect, ...gcsafe,
                                       extern: "ntAddTime", raises: [],
                                       tags: [], forbids: [].}

Добавление интервала времени к Time.

Пример:

doAssert (fromUnix(0) + initDuration(seconds = 1)) == fromUnix(1)

Исходный код Редактировать

proc `+`(dt: DateTime; dur: Duration): DateTime {....raises: [], tags: [],
    forbids: [].}

Пример:

let dt = dateTime(2017, mMar, 30, 00, 00, 00, 00, utc())
let dur = initDuration(hours = 5)
doAssert $(dt + dur) == "2017-03-30T05:00:00Z"

Исходный код Редактировать

proc `+`(dt: DateTime; interval: TimeInterval): DateTime {....raises: [], tags: [],
    forbids: [].}

Добавляет interval к dt. Компоненты из interval добавляются в порядке их величины, т.е. сначала компонент years, затем months и так далее. Результирующее DateTime будет иметь ту же временную зону, что и входные данные.

Обратите внимание, что при добавлении месяцев допускается переполнение дня месяца. Это означает, что если у полученного месяца недостаточно дней, месяц будет увеличен, а день месяца будет установлен на количество переполненных дней. Добавление одного месяца к 31 October приведет к 31 November, что переполнит и даст 1 December.

Пример:

let dt = dateTime(2017, mMar, 30, 00, 00, 00, 00, utc())
doAssert $(dt + 1.months) == "2017-04-30T00:00:00Z"
# This is correct and happens due to monthday overflow.
doAssert $(dt - 1.months) == "2017-03-02T00:00:00Z"

Исходный код Редактировать

proc `+`(ti1, ti2: TimeInterval): TimeInterval {....raises: [], tags: [],
    forbids: [].}

Складывает два объекта TimeInterval вместе. Исходный код Редактировать

proc `+`(time: Time; interval: TimeInterval): Time {....raises: [], tags: [],
    forbids: [].}

Добавляет interval к time. Если interval содержит какие-либо годы, месяцы, недели или дни, операция выполняется в локальной временной зоне.

Пример:

let tm = fromUnix(0)
doAssert tm + 5.seconds == fromUnix(5)

Исходный код Редактировать

proc `+=`(a: var DateTime; b: Duration) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `+=`(a: var DateTime; b: TimeInterval) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `+=`(a: var TimeInterval; b: TimeInterval) {....raises: [], tags: [],
    forbids: [].}

Исходный код Редактировать

proc `+=`(d1: var Duration; d2: Duration) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `+=`(t: var Time; b: Duration) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `+=`(t: var Time; b: TimeInterval) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `-`(a, b: Duration): Duration {....gcsafe, noSideEffect, ...gcsafe,
                                     extern: "ntSubDuration", raises: [],
                                     tags: [], forbids: [].}

Вычитание продолжительности из другой.

Пример:

doAssert initDuration(seconds = 1, days = 1) - initDuration(seconds = 1) ==
  initDuration(days = 1)

Исходный код Редактировать

proc `-`(a, b: Time): Duration {....gcsafe, noSideEffect, ...gcsafe,
                                 extern: "ntDiffTime", raises: [], tags: [],
                                 forbids: [].}

Вычисляет продолжительность между двумя моментами времени.

Пример:

doAssert initTime(1000, 100) - initTime(500, 20) ==
  initDuration(minutes = 8, seconds = 20, nanoseconds = 80)

Исходный код Редактировать

proc `-`(a: Duration): Duration {....gcsafe, noSideEffect, ...gcsafe,
                                  extern: "ntReverseDuration", raises: [],
                                  tags: [], forbids: [].}

Обратная продолжительность.

Пример:

doAssert -initDuration(seconds = 1) == initDuration(seconds = -1)

Исходный код Редактировать

proc `-`(a: Time; b: Duration): Time {....gcsafe, noSideEffect, ...gcsafe,
                                       extern: "ntSubTime", raises: [],
                                       tags: [], forbids: [].}

Вычитает продолжительность из Time.

Пример:

doAssert (fromUnix(0) - initDuration(seconds = 1)) == fromUnix(-1)

Исходный код Редактировать

proc `-`(dt1, dt2: DateTime): Duration {....raises: [], tags: [], forbids: [].}

Вычислить продолжительность между dt1 и dt2.

Пример:

let dt1 = dateTime(2017, mMar, 30, 00, 00, 00, 00, utc())
let dt2 = dateTime(2017, mMar, 25, 00, 00, 00, 00, utc())

doAssert dt1 - dt2 == initDuration(days = 5)

Исходный код Редактировать

proc `-`(dt: DateTime; dur: Duration): DateTime {....raises: [], tags: [],
    forbids: [].}

Пример:

let dt = dateTime(2017, mMar, 30, 00, 00, 00, 00, utc())
let dur = initDuration(days = 5)
doAssert $(dt - dur) == "2017-03-25T00:00:00Z"

Исходный код Редактировать

proc `-`(dt: DateTime; interval: TimeInterval): DateTime {....raises: [], tags: [],
    forbids: [].}

Вычесть interval из dt. Компоненты из interval вычитаются в порядке их размера, т.е. сначала компонент years, затем компонент months и так далее. Возвращаемый DateTime будет иметь тот же часовой пояс, что и входные данные.

Пример:

let dt = dateTime(2017, mMar, 30, 00, 00, 00, 00, utc())
doAssert $(dt - 5.days) == "2017-03-25T00:00:00Z"

Исходный код Редактировать

proc `-`(ti1, ti2: TimeInterval): TimeInterval {....raises: [], tags: [],
    forbids: [].}

Вычитает промежуток времени ti1 из ti2.

Компоненты времени вычитаются по одному, см. вывод:

Пример:

let ti1 = initTimeInterval(hours = 24)
let ti2 = initTimeInterval(hours = 4)
doAssert (ti1 - ti2) == initTimeInterval(hours = 20)

Исходный код Редактировать

proc `-`(ti: TimeInterval): TimeInterval {....raises: [], tags: [], forbids: [].}

Обратный промежуток времени

Пример:

let day = -initTimeInterval(hours = 24)
doAssert day.hours == -24

Исходный код Редактировать

proc `-`(time: Time; interval: TimeInterval): Time {....raises: [], tags: [],
    forbids: [].}

Вычитает interval из времени time. Если interval содержит какие-либо годы, месяцы, недели или дни, операция выполняется в местном часовом поясе.

Пример:

let tm = fromUnix(5)
doAssert tm - 5.seconds == fromUnix(0)

Исходный код Редактировать

proc `-=`(a: var DateTime; b: Duration) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `-=`(a: var DateTime; b: TimeInterval) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `-=`(a: var TimeInterval; b: TimeInterval) {....raises: [], tags: [],
    forbids: [].}

Исходный код Редактировать

proc `-=`(dt: var Duration; ti: Duration) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `-=`(t: var Time; b: Duration) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `-=`(t: var Time; b: TimeInterval) {....raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `<`(a, b: DateTime): bool {....raises: [], tags: [], forbids: [].}

Возвращает true, если a произошло раньше b. Исходный код Редактировать

proc `<`(a, b: Duration): bool {....gcsafe, noSideEffect, ...gcsafe,
                                 extern: "ntLtDuration", raises: [], tags: [],
                                 forbids: [].}

Обратите внимание, что продолжительность может быть отрицательной, поэтому, даже если a < b истинно, a может представлять большую абсолютную продолжительность. Используйте abs(a) < abs(b) для сравнения абсолютной продолжительности.

Пример:

doAssert initDuration(seconds = 1) < initDuration(seconds = 2)
doAssert initDuration(seconds = -2) < initDuration(seconds = 1)
doAssert initDuration(seconds = -2).abs < initDuration(seconds = 1).abs == false

Исходный код Редактировать

proc `<`(a, b: Time): bool {....gcsafe, noSideEffect, ...gcsafe, extern: "ntLtTime",
                             raises: [], tags: [], forbids: [].}

Возвращает true, если a < b, то есть если a произошло раньше b.

Пример:

doAssert initTime(50, 0) < initTime(99, 0)

Исходный код Редактировать

proc `<=`(a, b: DateTime): bool {....raises: [], tags: [], forbids: [].}

Возвращает true, если a произошло до или одновременно с b. Исходный код Редактировать

proc `<=`(a, b: Duration): bool {....gcsafe, noSideEffect, ...gcsafe,
                                  extern: "ntLeDuration", raises: [], tags: [],
                                  forbids: [].}

Исходный код Редактировать

proc `<=`(a, b: Time): bool {....gcsafe, noSideEffect, ...gcsafe, extern: "ntLeTime",
                              raises: [], tags: [], forbids: [].}

Возвращает true, если a <= b. Исходный код Редактировать

proc `==`(a, b: DateTime): bool {....raises: [], tags: [], forbids: [].}

Возвращает true, если a и b представляют один и тот же момент времени. Исходный код Редактировать

proc `==`(a, b: Duration): bool {....gcsafe, noSideEffect, ...gcsafe,
                                  extern: "ntEqDuration", raises: [], tags: [],
                                  forbids: [].}

Пример:

let
  d1 = initDuration(weeks = 1)
  d2 = initDuration(days = 7)
doAssert d1 == d2

Исходный код Редактировать

proc `==`(a, b: IsoYear): bool {.borrow, ...raises: [], tags: [], forbids: [].}

Исходный код Редактировать

proc `==`(a, b: Time): bool {....gcsafe, noSideEffect, ...gcsafe, extern: "ntEqTime",
                              raises: [], tags: [], forbids: [].}

Возвращает true, если a == b, то есть если оба времени представляют один и тот же момент времени. Исходный код Редактировать

proc `==`(zone1, zone2: Timezone): bool {....raises: [], tags: [], forbids: [].}

Два Timezone считаются равными, если их имена равны.

Пример:

doAssert local() == local()
doAssert local() != utc()

Исходный код Редактировать

proc abs(a: Duration): Duration {....raises: [], tags: [], forbids: [].}

Пример:

doAssert initDuration(milliseconds = -1500).abs ==
  initDuration(milliseconds = 1500)

Исходный код Редактировать

proc between(startDt, endDt: DateTime): TimeInterval {....raises: [], tags: [],
    forbids: [].}

Указывает разницу между startDt и endDt в качестве TimeInterval. Ниже приведены гарантии относительно результата:

• Все поля будут иметь одинаковый знак.
• Если startDt.timezone == endDt.timezone, гарантируется, что startDt + between(startDt, endDt) == endDt.
• Если startDt.timezone != endDt.timezone, то результат будет эквивалентен between(startDt.utc, endDt.utc).

Пример:

var a = dateTime(2015, mMar, 25, 12, 0, 0, 00, utc())
var b = dateTime(2017, mApr, 1, 15, 0, 15, 00, utc())
var ti = initTimeInterval(years = 2, weeks = 1, hours = 3, seconds = 15)
doAssert between(a, b) == ti
doAssert between(a, b) == -between(b, a)

Исходный код Редактировать

proc convert[T: SomeInteger](unitFrom, unitTo: FixedTimeUnit; quantity: T): T {.
    inline.}

Преобразовать количество единиц некоторой временной единицы в другую временную единицу. Эта процедура работает только с целыми числами, поэтому результат может быть усечен.

Пример:

doAssert convert(Days, Hours, 2) == 48
doAssert convert(Days, Weeks, 13) == 1 # Truncated
doAssert convert(Seconds, Milliseconds, -1) == -1000

Исходный код Редактировать

proc cpuTime(): float {....tags: [TimeEffect], raises: [], forbids: [].}

Получает время, потраченное процессором на выполнение текущего процесса, в секундах. Это может быть полезнее для тестирования производительности, чем epochTime. Однако, он может измерять реальное время (в зависимости от ОС). Значение результата не имеет смысла. Для получения полезных значений времени возьмите разницу между результатами двух вызовов cpuTime:

Пример:

var t0 = cpuTime()
# some useless work here (calculate fibonacci)
var fib = @[0, 1, 1]
for i in 1..10:
  fib.add(fib[^1] + fib[^2])
echo "CPU time [s] ", cpuTime() - t0
echo "Fib is [s] ", fib

Когда флаг --benchmarkVM передается компилятору, эта процедура также доступна во время компиляции Исходный код Редактировать

proc dateTime(year: int; month: Month; monthday: MonthdayRange;
              hour: HourRange = 0; minute: MinuteRange = 0;
              second: SecondRange = 0; nanosecond: NanosecondRange = 0;
              zone: Timezone = local()): DateTime {....raises: [], tags: [],
    forbids: [].}

Создает новый DateTime в указанном часовом поясе.

Пример:

assert $dateTime(2017, mMar, 30, zone = utc()) == "2017-03-30T00:00:00Z"

Исходный код Редактировать

proc days(d: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

TimeInterval продолжительностью d дней.

echo getTime() + 2.days

Исходный код Редактировать

proc `div`(a: Duration; b: int64): Duration {....gcsafe, noSideEffect, ...gcsafe,
    extern: "ntDivDuration", raises: [], tags: [], forbids: [].}

Целочисленное деление для продолжительностей.

Пример:

doAssert initDuration(seconds = 3) div 2 ==
  initDuration(milliseconds = 1500)
doAssert initDuration(minutes = 45) div 30 ==
  initDuration(minutes = 1, seconds = 30)
doAssert initDuration(nanoseconds = 3) div 2 ==
  initDuration(nanoseconds = 1)

Исходный код Редактировать

proc epochTime(): float {....tags: [TimeEffect], raises: [], forbids: [].}

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

В общем случае следует отдавать предпочтение процедуре getTime.

Предупреждение: Не подходит для тестирования производительности (но всё ещё лучше, чем now), используйте monotimes.getMonoTime или cpuTime вместо этого, в зависимости от задачи.

Исходный код Редактировать

proc format(dt: DateTime; f: static[string]): string {....raises: [].}

Перегрузка, которая проверяет format во время компиляции. Исходный код Редактировать

proc format(dt: DateTime; f: string; loc: DateTimeLocale = DefaultLocale): string {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}

Сокращенная запись для создания TimeFormat и использования его для форматирования dt.

См. Разбор и форматирование дат для документации аргумента format.

Пример:

let dt = dateTime(2000, mJan, 01, 00, 00, 00, 00, utc())
doAssert "2000-01-01" == format(dt, "yyyy-MM-dd")

Исходный код Редактировать

proc format(dt: DateTime; f: TimeFormat; loc: DateTimeLocale = DefaultLocale): string {.
    ...raises: [], tags: [], forbids: [].}

Форматирует dt с использованием формата, заданного f.

Пример:

let f = initTimeFormat("yyyy-MM-dd")
let dt = dateTime(2000, mJan, 01, 00, 00, 00, 00, utc())
doAssert "2000-01-01" == dt.format(f)

Исходный код Редактировать

proc format(time: Time; f: static[string]; zone: Timezone = local()): string {.
    ...raises: [].}

Перегрузка, которая проверяет f во время компиляции. Исходный код Редактировать

proc format(time: Time; f: string; zone: Timezone = local()): string {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}

Сокращенная запись для создания TimeFormat и использования его для форматирования time. Будет использовать часовой пояс, указанный в zone.

См. Разбор и форматирование дат для документации аргумента f.

Пример:

var dt = dateTime(1970, mJan, 01, 00, 00, 00, 00, utc())
var tm = dt.toTime()
doAssert format(tm, "yyyy-MM-dd'T'HH:mm:ss", utc()) == "1970-01-01T00:00:00"

Исходный код Редактировать

proc formatValue(result: var string; value: DateTime | Time; specifier: string)

адаптер для strformat. Не предназначен для прямого вызова. Исходный код Редактировать

proc fromUnix(unix: int64): Time {....gcsafe, tags: [], raises: [], noSideEffect,
                                   ...forbids: [].}

Преобразовать метку времени Unix (секунды с момента 1970-01-01T00:00:00Z) в Time.

Пример:

doAssert $fromUnix(0).utc == "1970-01-01T00:00:00Z"

Исходный код Редактировать

proc fromUnixFloat(seconds: float): Time {....gcsafe, tags: [], raises: [],
    noSideEffect, ...forbids: [].}

Преобразовать метку времени Unix в секундах в Time; то же самое, что и fromUnix , но с разрешением ниже секунды.

Пример:

doAssert fromUnixFloat(123456.0) == fromUnixFloat(123456)
doAssert fromUnixFloat(-123456.0) == fromUnixFloat(-123456)

Исходный код Редактировать

proc fromWinTime(win: int64): Time {....raises: [], tags: [], forbids: [].}

Преобразовать временную метку Windows (интервалы в 100 наносекунд с момента 1601-01-01T00:00:00Z) в Time. Исходный код Редактировать

proc getClockStr(dt = now()): string {....gcsafe, extern: "nt$1",
                                       tags: [TimeEffect], raises: [],
                                       forbids: [].}

Получает текущее локальное время как строку в формате HH:mm:ss.

Пример:

echo getClockStr(now() - 1.hours)

Исходный код Редактировать

proc getDateStr(dt = now()): string {....gcsafe, extern: "nt$1",
                                      tags: [TimeEffect], raises: [],
                                      forbids: [].}

Получает текущую локальную дату в виде строки в формате YYYY-MM-dd.

Пример:

echo getDateStr(now() - 1.months)

Исходный код Редактировать

proc getDayOfWeek(monthday: MonthdayRange; month: Month; year: int): WeekDay {.
    ...tags: [], raises: [], gcsafe, forbids: [].}

Возвращает перечисление дня недели по дню, месяцу и году. Эквивалентно dateTime(year, month, monthday, 0, 0, 0, 0).weekday.

Пример:

doAssert getDayOfWeek(13, mJun, 1990) == dWed
doAssert $getDayOfWeek(13, mJun, 1990) == "Wednesday"

Исходный код Редактировать

proc getDayOfYear(monthday: MonthdayRange; month: Month; year: int): YeardayRange {.
    ...tags: [], raises: [], gcsafe, forbids: [].}

Возвращает день года. Эквивалентно dateTime(year, month, monthday, 0, 0, 0, 0).yearday.

Пример:

doAssert getDayOfYear(1, mJan, 2000) == 0
doAssert getDayOfYear(10, mJan, 2000) == 9
doAssert getDayOfYear(10, mFeb, 2000) == 40

Исходный код Редактировать

proc getDaysInMonth(month: Month; year: int): int {....raises: [], tags: [],
    forbids: [].}

Получить количество дней в month year.

Пример:

doAssert getDaysInMonth(mFeb, 2000) == 29
doAssert getDaysInMonth(mFeb, 2001) == 28

Исходный код Редактировать

proc getDaysInYear(year: int): int {....raises: [], tags: [], forbids: [].}

Получить количество дней в year

Пример:

doAssert getDaysInYear(2000) == 366
doAssert getDaysInYear(2001) == 365

Исходный код Изменить

proc getIsoWeekAndYear(dt: DateTime): tuple[isoweek: IsoWeekRange,
    isoyear: IsoYear] {....raises: [], tags: [], forbids: [].}

Возвращает неделю и год по ISO 8601.

Предупреждение: Год по ISO, основанный на неделе, может соответствовать следующему или предыдущему году со 29 декабря по 3 января.

Пример:

assert getIsoWeekAndYear(initDateTime(21, mApr, 2018, 00, 00, 00)) == (isoweek: 16.IsoWeekRange, isoyear: 2018.IsoYear)
block:
  let (w, y) = getIsoWeekAndYear(initDateTime(30, mDec, 2019, 00, 00, 00))
  assert w == 01.IsoWeekRange
  assert y == 2020.IsoYear
assert getIsoWeekAndYear(initDateTime(13, mSep, 2020, 00, 00, 00)) == (isoweek: 37.IsoWeekRange, isoyear: 2020.IsoYear)
block:
  let (w, y) = getIsoWeekAndYear(initDateTime(2, mJan, 2021, 00, 00, 00))
  assert w.int > 52
  assert w.int < 54
  assert y.int mod 100 == 20

Исходный код Изменить

proc getTime(): Time {....tags: [TimeEffect], gcsafe, raises: [], forbids: [].}

Получает текущее время как Time с разрешением до наносекунд. Исходный код Изменить

proc getWeeksInIsoYear(y: IsoYear): IsoWeekRange {....raises: [], tags: [],
    forbids: [].}

Возвращает количество недель в указанном году по ISO 8601, которое может быть либо 53, либо 52.

Пример:

assert getWeeksInIsoYear(IsoYear(2019)) == 52
assert getWeeksInIsoYear(IsoYear(2020)) == 53

Исходный код Изменить

proc high(typ: typedesc[Duration]): Duration

Получить максимальную представимую продолжительность. Исходный код Изменить

proc high(typ: typedesc[Time]): Time

Исходный код Изменить

proc hour(dt: DateTime): HourRange {.inline, ...raises: [], tags: [], forbids: [].}

Количество часов, прошедших с полуночи, в диапазоне от 0 до 23. Исходный код Изменить

proc hour=(dt: var DateTime; value: HourRange) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устаревший: Устарел начиная с версии v1.3.1

Исходный код Изменить

proc hours(h: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

Промежуток времени в h часах.

echo getTime() + 2.hours

Исходный код Изменить

proc inDays(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных дней.

Пример:

let dur = initDuration(hours = -50)
doAssert dur.inDays == -2

Исходный код Изменить

proc inHours(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных часов.

Пример:

let dur = initDuration(minutes = 60, days = 2)
doAssert dur.inHours == 49

Исходный код Изменить

proc initDateTime(monthday: MonthdayRange; month: Month; year: int;
                  hour: HourRange; minute: MinuteRange; second: SecondRange;
                  nanosecond: NanosecondRange; zone: Timezone = local()): DateTime {.
    ...deprecated: "use `dateTime`", raises: [], tags: [], forbids: [].}

Устаревший: используйте `dateTime`

Создать новый DateTime в указанной временной зоне.

Пример: cmd: --warning:deprecated:off

assert $initDateTime(30, mMar, 2017, 00, 00, 00, 00, utc()) == "2017-03-30T00:00:00Z"

Исходный код Изменить

proc initDateTime(monthday: MonthdayRange; month: Month; year: int;
                  hour: HourRange; minute: MinuteRange; second: SecondRange;
                  zone: Timezone = local()): DateTime {.
    ...deprecated: "use `dateTime`", raises: [], tags: [], forbids: [].}

Устаревший: используйте `dateTime`

Создать новый DateTime в указанной временной зоне.

Пример: cmd: --warning:deprecated:off

assert $initDateTime(30, mMar, 2017, 00, 00, 00, utc()) == "2017-03-30T00:00:00Z"

Исходный код Изменить

proc initDateTime(weekday: WeekDay; isoweek: IsoWeekRange; isoyear: IsoYear;
                  hour: HourRange; minute: MinuteRange; second: SecondRange;
                  nanosecond: NanosecondRange; zone: Timezone = local()): DateTime {.
    ...gcsafe, raises: [], tags: [], forbids: [].}

Исходный код Изменить

proc initDateTime(weekday: WeekDay; isoweek: IsoWeekRange; isoyear: IsoYear;
                  hour: HourRange; minute: MinuteRange; second: SecondRange;
                  zone: Timezone = local()): DateTime {....gcsafe, raises: [],
    tags: [], forbids: [].}

Исходный код Изменить

proc initDuration(nanoseconds, microseconds, milliseconds, seconds, minutes,
                  hours, days, weeks: int64 = 0): Duration {....raises: [],
    tags: [], forbids: [].}

Создать новый Duration.

Пример:

let dur = initDuration(seconds = 1, milliseconds = 1)
doAssert dur.inMilliseconds == 1001
doAssert dur.inSeconds == 1

Исходный код Изменить

proc initTime(unix: int64; nanosecond: NanosecondRange): Time {....raises: [],
    tags: [], forbids: [].}

Создать Time из Unix-временной метки и наносекундной части. Исходный код Изменить

proc initTimeFormat(format: string): TimeFormat {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}

Создать новый формат времени для парсинга и форматирования типов времени.

См. Парсинг и форматирование дат для документации аргумента format.

Пример:

let f = initTimeFormat("yyyy-MM-dd")
doAssert "2000-01-01" == "2000-01-01".parse(f).format(f)

Исходный код Изменить

proc initTimeInterval(nanoseconds, microseconds, milliseconds, seconds, minutes,
                      hours, days, weeks, months, years: int = 0): TimeInterval {.
    ...raises: [], tags: [], forbids: [].}

Создает новый TimeInterval.

Эта процедура не выполняет никакой нормализации! Например, initTimeInterval(hours = 24) и initTimeInterval(days = 1) не равны.

Вы также можете использовать удобные процедуры, называемые milliseconds, seconds, minutes, hours, days, months, и years.

Пример:

let day = initTimeInterval(hours = 24)
let dt = dateTime(2000, mJan, 01, 12, 00, 00, 00, utc())
doAssert $(dt + day) == "2000-01-02T12:00:00Z"
doAssert initTimeInterval(hours = 24) != initTimeInterval(days = 1)

Исходный код Изменить

proc inMicroseconds(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных микросекунд.

Пример:

let dur = initDuration(seconds = -2)
doAssert dur.inMicroseconds == -2000000

Исходный код Изменить

proc inMilliseconds(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных миллисекунд.

Пример:

let dur = initDuration(seconds = -2)
doAssert dur.inMilliseconds == -2000

Исходный код Изменить

proc inMinutes(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных минут.

Пример:

let dur = initDuration(hours = 2, seconds = 10)
doAssert dur.inMinutes == 120

Исходный код Изменить

proc inNanoseconds(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных наносекунд.

Пример:

let dur = initDuration(seconds = -2)
doAssert dur.inNanoseconds == -2000000000

Исходный код Изменить

proc inSeconds(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в целое число полных секунд.

Пример:

let dur = initDuration(hours = 2, milliseconds = 10)
doAssert dur.inSeconds == 2 * 60 * 60

Исходный код Изменить

proc inWeeks(dur: Duration): int64 {....raises: [], tags: [], forbids: [].}

Преобразует продолжительность в количество полных недель.

Пример:

let dur = initDuration(days = 8)
doAssert dur.inWeeks == 1

Исходный код Изменить

proc inZone(dt: DateTime; zone: Timezone): DateTime {....tags: [], raises: [],
    gcsafe, forbids: [].}

Возвращает DateTime, представляющую ту же точку во времени, что и dt, но с использованием zone в качестве часового пояса. Исходный код Изменить

proc inZone(time: Time; zone: Timezone): DateTime {....tags: [], raises: [],
    gcsafe, forbids: [].}

Преобразовать time в DateTime, используя zone в качестве часового пояса. Исходный код Изменить

proc isDst(dt: DateTime): bool {.inline, ...raises: [], tags: [], forbids: [].}

Определяет, действует ли летнее время. Всегда ложно для JavaScript-бекенда. Исходный код Изменить

proc isDst=(dt: var DateTime; value: bool) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc isInitialized(dt: DateTime): bool {....raises: [], tags: [], forbids: [].}

Пример:

doAssert now().isInitialized
doAssert not default(DateTime).isInitialized

Исходный код Изменить

proc isLeapDay(dt: DateTime): bool {....raises: [], tags: [], forbids: [].}

Возвращает, является ли t високосным днем, т.е. 29 февраля в високосный год. Это важно, так как влияет на расчеты смещения времени.

Пример:

let dt = dateTime(2020, mFeb, 29, 00, 00, 00, 00, utc())
doAssert dt.isLeapDay
doAssert dt+1.years-1.years != dt
let dt2 = dateTime(2020, mFeb, 28, 00, 00, 00, 00, utc())
doAssert not dt2.isLeapDay
doAssert dt2+1.years-1.years == dt2
doAssertRaises(Exception): discard dateTime(2021, mFeb, 29, 00, 00, 00, 00, utc())

Исходный код Изменить

proc isLeapYear(year: int): bool {....raises: [], tags: [], forbids: [].}

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

Пример:

doAssert isLeapYear(2000)
doAssert not isLeapYear(1900)

Исходный код Изменить

proc local(): Timezone {....raises: [], tags: [], forbids: [].}

Получить реализацию Timezone для локального часового пояса.

Пример:

doAssert now().timezone == local()
doAssert local().name == "LOCAL"

Исходный код Изменить

proc local(dt: DateTime): DateTime {....raises: [], tags: [], forbids: [].}

Краткая форма для dt.inZone(local()). Исходный код Изменить

proc local(t: Time): DateTime {....raises: [], tags: [], forbids: [].}

Краткая форма для t.inZone(local()). Исходный код Изменить

proc low(typ: typedesc[Duration]): Duration

Получить наибольшую представимую продолжительность отрицательного направления. Исходный код Изменить

proc low(typ: typedesc[Time]): Time

Исходный код Изменить

proc microseconds(micros: int): TimeInterval {.inline, ...raises: [], tags: [],
    forbids: [].}

Продолжительность micros микросекунд. Исходный код Изменить

proc milliseconds(ms: int): TimeInterval {.inline, ...raises: [], tags: [],
    forbids: [].}

Продолжительность ms миллисекунд. Исходный код Изменить

proc minute(dt: DateTime): MinuteRange {.inline, ...raises: [], tags: [],
    forbids: [].}

Количество минут после часа в диапазоне от 0 до 59. Исходный код Изменить

proc minute=(dt: var DateTime; value: MinuteRange) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc minutes(m: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

Продолжительность m минут.

echo getTime() + 5.minutes

Исходный код Изменить

proc month(dt: DateTime): Month {....raises: [], tags: [], forbids: [].}

Месяц как перечисление, порядковое значение находится в диапазоне от 1 до 12. Исходный код Изменить

proc monthday(dt: DateTime): MonthdayRange {.inline, ...raises: [], tags: [],
    forbids: [].}

День месяца в диапазоне от 1 до 31. Исходный код Изменить

proc monthdayZero=(dt: var DateTime; value: int) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc months(m: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

Продолжительность m месяцев.

echo getTime() + 2.months

Исходный код Изменить

proc monthZero=(dt: var DateTime; value: int) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc name(zone: Timezone): string {....raises: [], tags: [], forbids: [].}

Название часового пояса.

Если это возможно, будет использовано название, используемое в базе данных tz. Если часовой пояс не существует в базе данных tz или имя часового пояса неизвестно, может быть использована любая строка, которая однозначно описывает часовой пояс. Например, строка "LOCAL" используется для локального часового пояса системы.

См. также: https://en.wikipedia.org/wiki/Tz_database

Исходный код Изменить

proc nanosecond(dt: DateTime): NanosecondRange {.inline, ...raises: [], tags: [],
    forbids: [].}

Количество наносекунд после секунды, в диапазоне от 0 до 999_999_999. Исходный код Изменить

proc nanosecond(time: Time): NanosecondRange {....raises: [], tags: [], forbids: [].}

Получить дробную часть Time в виде количества наносекунд секунды. Исходный код Изменить

proc nanosecond=(dt: var DateTime; value: NanosecondRange) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc nanoseconds(nanos: int): TimeInterval {.inline, ...raises: [], tags: [],
    forbids: [].}

Продолжительность nanos наносекунд. Исходный код Изменить

proc newTimezone(name: string; zonedTimeFromTimeImpl: proc (time: Time): ZonedTime {.
    ...tags: [], raises: [], gcsafe.}; zonedTimeFromAdjTimeImpl: proc (
    adjTime: Time): ZonedTime {....tags: [], raises: [], gcsafe.}): owned Timezone {.
    ...raises: [], tags: [], forbids: [].}

Создать новый Timezone.

zonedTimeFromTimeImpl и zonedTimeFromAdjTimeImpl используются в качестве базовых реализаций для zonedTimeFromTime и zonedTimeFromAdjTime.

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

Пример:

proc utcTzInfo(time: Time): ZonedTime =
  ZonedTime(utcOffset: 0, isDst: false, time: time)
let utc = newTimezone("Etc/UTC", utcTzInfo, utcTzInfo)

Исходный код Изменить

proc now(): DateTime {....tags: [TimeEffect], gcsafe, raises: [], forbids: [].}

Получить текущее время как DateTime в локальном часовом поясе. Сокращение для getTime().local.

Предупреждение: Не подходит для тестирования производительности, используйте monotimes.getMonoTime или cpuTime вместо этого, в зависимости от случая использования.

Исходный код Изменить

proc parse(input, f: string; tz: Timezone = local();
           loc: DateTimeLocale = DefaultLocale): DateTime {.
    ...raises: [TimeParseError, TimeFormatParseError], tags: [TimeEffect],
    forbids: [].}

Сокращение для построения TimeFormat и использования его для анализа input как DateTime.

См. Разбор и форматирование дат для документации аргумента f.

Пример:

let dt = dateTime(2000, mJan, 01, 00, 00, 00, 00, utc())
doAssert dt == parse("2000-01-01", "yyyy-MM-dd", utc())

Исходный код Изменить

proc parse(input: string; f: static[string]; zone: Timezone = local();
           loc: DateTimeLocale = DefaultLocale): DateTime {.
    ...raises: [TimeParseError].}

Перегрузка, которая проверяет f во время компиляции. Исходный код Изменить

proc parse(input: string; f: TimeFormat; zone: Timezone = local();
           loc: DateTimeLocale = DefaultLocale): DateTime {.
    ...raises: [TimeParseError], tags: [TimeEffect], forbids: [].}

Анализирует input как DateTime с использованием формата, указанного в f. Если смещение UTC не было проанализировано, предполагается, что input указано в часовом поясе zone. Если смещение UTC было проанализировано, результат будет преобразован в часовой пояс zone.

Используются названия месяцев и дней из переданного loc.

Пример:

let f = initTimeFormat("yyyy-MM-dd")
let dt = dateTime(2000, mJan, 01, 00, 00, 00, 00, utc())
doAssert dt == "2000-01-01".parse(f, utc())

Исходный код Изменить

proc parseTime(input, f: string; zone: Timezone): Time {.
    ...raises: [TimeParseError, TimeFormatParseError], tags: [TimeEffect],
    forbids: [].}

Сокращение для построения TimeFormat и использования его для анализа input как DateTime, а затем преобразования в Time.

См. Разбор и форматирование дат для документации аргумента format.

Пример:

let tStr = "1970-01-01T00:00:00+00:00"
doAssert parseTime(tStr, "yyyy-MM-dd'T'HH:mm:sszzz", utc()) == fromUnix(0)

Исходный код Изменить

proc parseTime(input: string; f: static[string]; zone: Timezone): Time {.
    ...raises: [TimeParseError].}

Перегрузка, которая проверяет format во время компиляции. Исходный код Изменить

proc second(dt: DateTime): SecondRange {.inline, ...raises: [], tags: [],
    forbids: [].}

Количество секунд после минуты в диапазоне от 0 до 59. Исходный код Изменить

proc second=(dt: var DateTime; value: SecondRange) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc seconds(s: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

Промежуток времени в s секундах.

echo getTime() + 5.seconds

Исходный код Изменить

proc timezone(dt: DateTime): Timezone {.inline, ...raises: [], tags: [],
                                        forbids: [].}

Часовой пояс, представленный как реализация Timezone. Исходный код Изменить

proc timezone=(dt: var DateTime; value: Timezone) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело с версии v1.3.1

Исходный код Изменить

proc toParts(dur: Duration): DurationParts {....raises: [], tags: [], forbids: [].}

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

Каждое значение в массиве содержит информацию о конкретной единице времени, например, result[Days] указывает количество дней.

Эта процедура полезна для преобразования значений Duration в строки.

Пример:

var dp = toParts(initDuration(weeks = 2, days = 1))
doAssert dp[Days] == 1
doAssert dp[Weeks] == 2
doAssert dp[Minutes] == 0
dp = toParts(initDuration(days = -1))
doAssert dp[Days] == -1

Исходный код Изменить

proc toParts(ti: TimeInterval): TimeIntervalParts {....raises: [], tags: [],
    forbids: [].}

Преобразует TimeInterval в массив, состоящий из его единиц времени, начиная с наносекунд и заканчивая годами.

Эта процедура полезна для преобразования значений TimeInterval в строки. Например, вам нужно реализовать пользовательскую печать интервалов

Пример:

var tp = toParts(initTimeInterval(years = 1, nanoseconds = 123))
doAssert tp[Years] == 1
doAssert tp[Nanoseconds] == 123

Исходный код Изменить

proc toTime(dt: DateTime): Time {....tags: [], raises: [], gcsafe, forbids: [].}

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

proc toUnix(t: Time): int64 {....gcsafe, tags: [], raises: [], noSideEffect,
                              ...forbids: [].}

Преобразовать t в метку времени Unix (секунды с момента 1970-01-01T00:00:00Z). См. также toUnixFloat для разрешения долей секунды.

Пример:

doAssert fromUnix(0).toUnix() == 0

Исходный код Изменить

proc toUnixFloat(t: Time): float {....gcsafe, tags: [], raises: [], forbids: [].}

То же, что и toUnix, но с разрешением долей секунды.

Пример:

let t = getTime()
# `<` because of rounding errors
doAssert abs(t.toUnixFloat().fromUnixFloat - t) < initDuration(nanoseconds = 1000)

Исходный код Изменить

proc toWinTime(t: Time): int64 {....raises: [], tags: [], forbids: [].}

Преобразовать t в метку времени Windows (интервалы в 100 наносекунд с момента 1601-01-01T00:00:00Z). Исходный код Изменить

proc utc(): Timezone {....raises: [], tags: [], forbids: [].}

Получить реализацию Timezone для часового пояса UTC.

Пример:

doAssert now().utc.timezone == utc()
doAssert utc().name == "Etc/UTC"

Исходный код Изменить

proc utc(dt: DateTime): DateTime {....raises: [], tags: [], forbids: [].}

Сокращение для dt.inZone(utc()). Исходный код Изменить

proc utc(t: Time): DateTime {....raises: [], tags: [], forbids: [].}

Сокращение для t.inZone(utc()). Исходный код Изменить

proc utcOffset(dt: DateTime): int {.inline, ...raises: [], tags: [], forbids: [].}

Смещение в секундах к западу от UTC, включая любое смещение из-за DST. Обратите внимание, что знак этого числа — обратный знаку в отформатированной строке смещения, например +01:00 (что эквивалентно смещению UTC -3600). Исходный код Изменить

proc utcOffset=(dt: var DateTime; value: int) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело начиная с версии v1.3.1

Исходный код Редактировать

proc weekday(dt: DateTime): WeekDay {.inline, ...raises: [], tags: [], forbids: [].}

День недели в виде перечисления, порядковое значение в диапазоне от 0 (понедельник) до 6 (воскресенье). Исходный код Редактировать

proc weekday=(dt: var DateTime; value: WeekDay) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело начиная с версии v1.3.1

Исходный код Редактировать

proc weeks(w: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

Интервал времени в w неделях.

echo getTime() + 2.weeks

Исходный код Редактировать

proc year(dt: DateTime): int {.inline, ...raises: [], tags: [], forbids: [].}

Год, используя астрономическую нумерацию годов (т.е. год до 1 года — это 0 год, затем -1 год и так далее). Исходный код Редактировать

proc year=(dt: var DateTime; value: int) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело начиная с версии v1.3.1

Исходный код Редактировать

proc yearday(dt: DateTime): YeardayRange {.inline, ...raises: [], tags: [],
    forbids: [].}

Количество дней с 1 января, в диапазоне от 0 до 365. Исходный код Редактировать

proc yearday=(dt: var DateTime; value: YeardayRange) {.
    ...deprecated: "Deprecated since v1.3.1", raises: [], tags: [], forbids: [].}

Устарело: Устарело начиная с версии v1.3.1

Исходный код Редактировать

proc years(y: int): TimeInterval {.inline, ...raises: [], tags: [], forbids: [].}

Интервал времени в y годах.

echo getTime() + 2.years

Исходный код Редактировать

proc zonedTimeFromAdjTime(zone: Timezone; adjTime: Time): ZonedTime {.
    ...raises: [], tags: [], forbids: [].}

Возвращает ZonedTime для некоторого локального времени.

Обратите внимание, что аргумент Time не представляет точку во времени, он представляет локальное время! Например, если adjTime равно fromUnix(0), это следует интерпретировать как 1970-01-01T00:00:00 в часовом поясе zone, а не в UTC.

Исходный код Редактировать

proc zonedTimeFromTime(zone: Timezone; time: Time): ZonedTime {....raises: [],
    tags: [], forbids: [].}

Возвращает ZonedTime для некоторой точки во времени. Исходный код Редактировать