times

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

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

Примеры

import 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, означают, что где-то между значениями произошла смена часового пояса. Это происходит дважды в год для часовых поясов, использующих летнее время. Из-за этого смещения фактически прошло 25 часов.

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

См. также

• модуль monotones

Импорты

strutils, math, options, since, posix

Типы

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. Исходный код Редактировать

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

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

MonthdayRange = range[1 .. 31]

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

HourRange = range[0 .. 23]

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

MinuteRange = range[0 .. 59]

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

SecondRange = range[0 .. 60]

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

YeardayRange = range[0 .. 365]

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

NanosecondRange = range[0 .. 999999999]

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

Time = object
  seconds: int64
  nanosecond: NanosecondRange

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

DateTime = object of RootObj
  nanosecond: NanosecondRange
  second: SecondRange
  minute: MinuteRange
  hour: HourRange
  monthdayZero: int
  monthZero: int
  year: int
  weekday: WeekDay
  yearday: YeardayRange
  isDst: bool
  timezone: Timezone
  utcOffset: int

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

Duration = object
  seconds: int64
  nanosecond: NanosecondRange

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

Чтобы создать новый Duration, используйте процедуру initDuration.

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

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

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

FixedTimeUnit = range[Nanoseconds .. Weeks]

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

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.

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

Timezone = ref object
  zonedTimeFromTimeImpl: proc (x: Time): ZonedTime {...}{.tags: [], raises: [],
      gcsafe, locks: 0.}
  zonedTimeFromAdjTimeImpl: proc (x: Time): ZonedTime {...}{.tags: [], raises: [],
      gcsafe, locks: 0.}
  name: string

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

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. Этот тип используется только для реализации часовых поясов. Исходный код Редактировать

DurationParts = array[FixedTimeUnit, int64]

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

TimeIntervalParts = array[TimeUnit, int]

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

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

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

TimeFormat = object
  patterns: seq[byte] ## \
                      ## 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]``.
  formatStr: string

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

Чтобы создать новый TimeFormat, используйте процедуру initTimeFormat.

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

TimeParseError = object of ValueError

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

TimeFormatParseError = object of ValueError

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

Константы

DurationZero = (seconds: 0, nanosecond: 0)

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

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

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

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"])

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

Процедуры

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 isLeapYear(year: int): bool {...}{.raises: [], tags: [].}

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

Пример:

doAssert isLeapYear(2000)
doAssert not isLeapYear(1900)

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Каждое значение в массиве содержит информацию о конкретной временной единице, например 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 `$`(dur: Duration): string {...}{.raises: [], tags: [].}

Человекопонятное строковое представление 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 `+`(a, b: Duration): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0,
                                     extern: "ntAddDuration", raises: [],
                                     tags: [].}

Сложить две продолжительности.

Пример:

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

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

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

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

Пример:

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

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

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

Изменить знак продолжительности.

Пример:

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

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

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

Обратите внимание, что продолжительность может быть отрицательной, поэтому даже если 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: Duration): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0,
                                  extern: "ntLeDuration", raises: [], tags: [].}

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

Пример:

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 high(typ: typedesc[Duration]): Duration

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

То же, что и toUnix, но с использованием разрешения до наносекунд.

Пример:

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

Добавляет длительность времени к Time.

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

Создаёт новый 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 name(zone: Timezone): string {...}{.raises: [], tags: [].}

Имя часового пояса.

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

Краткая запись для getTime().local.

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

Пример:

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

echo getDateStr(now() - 1.months)

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

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

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

Пример:

echo getClockStr(now() - 1.hours)

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

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

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

Пример:

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

Source Edit

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

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

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

Пример:

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

Source Edit

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

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

Пример:

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

Source Edit

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

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

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

Пример:

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

Source Edit

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

Перегрузка, которая проверяет format во время компиляции. Source Edit

proc formatValue(result: var string; value: DateTime; specifier: string) {...}{.
    raises: [TimeFormatParseError], tags: [].}

Адаптер для strformat. Не предназначен для прямого вызова. Source Edit

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

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

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

Пример:

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

Source Edit

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

Перегрузка, которая проверяет f во время компиляции. Source Edit

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

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

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

Пример:

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

Source Edit

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

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

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

Пример:

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

Source Edit

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

Перегрузка, которая проверяет f во время компиляции. Source Edit

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

Сокращенная запись для создания 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)

Source Edit

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

Перегрузка, которая проверяет format во время компиляции. Source Edit

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

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

Пример:

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

Source Edit

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

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

Пример:

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

Source Edit

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

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

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

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

Пример:

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

Source Edit

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

Складывает два объекта TimeInterval. Source Edit

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

Разворачивает временной интервал

Пример:

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

Source Edit

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

Вычитает TimeInterval ti1 из ti2.

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

Пример:

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

Source Edit

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

Source Edit

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

Source Edit

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

Возвращает разницу между startDt и endDt как TimeInterval. Гарантируются следующие свойства результата:

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

Пример:

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

Source Edit

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

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

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

Пример:

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

Source Edit

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

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

Пример:

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

Source Edit

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

TimeInterval из nanos наносекунд. Source Edit

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

Интервал времени в micros микросекундах. Исходный код Редактировать

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

Интервал времени в ms миллисекундах. Исходный код Редактировать

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

Интервал времени в s секундах.

echo getTime() + 5.seconds

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

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

Интервал времени в m минутах.

echo getTime() + 5.minutes

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

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

Интервал времени в h часах.

echo getTime() + 2.hours

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

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

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

echo getTime() + 2.days

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

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

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

echo getTime() + 2.weeks

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

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

Интервал времени в m месяцах.

echo getTime() + 2.months

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

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

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

echo getTime() + 2.years

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

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

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

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

Пример:

let dt = initDateTime(30, mMar, 2017, 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 `-`(dt: DateTime; interval: TimeInterval): DateTime {...}{.raises: [], tags: [].}

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

Пример:

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Получает время, которое процессор потратил на выполнение текущего процесса, в секундах. Это может быть полезнее для тестирования производительности, чем 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 nanosecond=(dt: var DateTime; value: NanosecondRange) {...}{.
    deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Шаблоны

template formatValue(result: var string; value: Time; specifier: string)

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