times
The times
module contains routines and types for dealing with time using the proleptic Gregorian calendar. It's also available for the JavaScript target.
Although the times
module supports nanosecond time resolution, the resolution used by getTime()
depends on the platform and backend (JS is limited to millisecond precision).
Examples
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
Parsing and Formatting Dates
The DateTime
type can be parsed and formatted using the different parse
and format
procedures.
let dt = parse("2000-01-01", "yyyy-MM-dd") echo dt.format("yyyy-MM-dd")
The different format patterns that are supported are documented below.
Pattern | Description | Example |
---|---|---|
d |
Numeric value representing the day of the month, it will be either one or two digits long. |
|
dd |
Same as above, but is always two digits. |
|
ddd |
Three letter string which indicates the day of the week. |
|
dddd |
Full string for the day of the week. |
|
h |
The hours in one digit if possible. Ranging from 1-12. |
|
hh |
The hours in two digits always. If the hour is one digit, 0 is prepended. |
|
H |
The hours in one digit if possible, ranging from 0-23. |
|
HH |
The hours in two digits always. 0 is prepended if the hour is one digit. |
|
m |
The minutes in one digit if possible. |
|
mm |
Same as above but always two digits, 0 is prepended if the minute is one digit. |
|
M |
The month in one digit if possible. |
|
MM |
The month in two digits always. 0 is prepended if the month value is one digit. |
|
MMM |
Abbreviated three-letter form of the month. |
|
MMMM |
Full month string, properly capitalized. |
|
s |
Seconds as one digit if possible. |
|
ss |
Same as above but always two digits. 0 is prepended if the second is one digit. |
|
t |
A when time is in the AM. P when time is in the PM. |
|
tt |
Same as above, but AM and PM instead of A and P respectively. |
|
yy |
The last two digits of the year. When parsing, the current century is assumed. |
|
yyyy |
The year, padded to at least four digits. Is always positive, even when the year is BC. When the year is more than four digits, '+' is prepended. |
|
YYYY |
The year without any padding. Is always positive, even when the year is BC. |
|
uuuu |
The year, padded to at least four digits. Will be negative when the year is BC. When the year is more than four digits, '+' is prepended unless the year is BC. |
|
UUUU |
The year without any padding. Will be negative when the year is BC. |
|
z |
Displays the timezone offset from UTC. |
|
zz |
Same as above but with leading 0. |
|
zzz |
Same as above but with :mm where mm represents minutes. |
|
zzzz |
Same as above but with :ss where ss represents seconds. |
|
g |
Era: AD or BC |
|
fff |
Milliseconds display |
|
ffffff |
Microseconds display |
|
fffffffff |
Nanoseconds display |
|
Other strings can be inserted by putting them in ''
. For example hh'->'mm
will give 01->56
. The following characters can be inserted without quoting them: :
-
(
)
/
[
]
,
. A literal '
can be specified with ''
.
However you don't need to necessarily separate format patterns, as an unambiguous format string like yyyyMMddhhmmss
is also valid (although only for years in the range 1..9999).
Duration vs TimeInterval
The times
module exports two similar types that are both used to represent some amount of time: Duration and TimeInterval. This section explains how they differ and when one should be preferred over the other (short answer: use Duration
unless support for months and years is needed).
Duration
A Duration
represents a duration of time stored as seconds and nanoseconds. A Duration
is always fully normalized, so initDuration(hours = 1)
and initDuration(minutes = 60)
are equivalent.
Arithmetic with a Duration
is very fast, especially when used with the Time
type, since it only involves basic arithmetic. Because Duration
is more performant and easier to understand it should generally preferred.
TimeInterval
A TimeInterval
represents an amount of time expressed in calendar units, for example "1 year and 2 days". Since some units cannot be normalized (the length of a year is different for leap years for example), the TimeInterval
type uses separate fields for every unit. The TimeInterval
's returned from this module generally don't normalize anything, so even units that could be normalized (like seconds, milliseconds and so on) are left untouched.
Arithmetic with a TimeInterval
can be very slow, because it requires timezone information.
Since it's slower and more complex, the TimeInterval
type should be avoided unless the program explicitly needs the features it offers that Duration
doesn't have.
How long is a day?
It should be especially noted that the handling of days differs between TimeInterval
and Duration
. The Duration
type always treats a day as exactly 86400 seconds. For TimeInterval
, it's more complex.
As an example, consider the amount of time between these two timestamps, both in the same timezone:
- 2018-03-25T12:00+02:00
- 2018-03-26T12:00+01:00
If only the date & time is considered, it appears that exactly one day has passed. However, the UTC offsets are different, which means that the UTC offset was changed somewhere in between. This happens twice each year for timezones that use daylight savings time. Because of this change, the amount of time that has passed is actually 25 hours.
The TimeInterval
type uses calendar units, and will say that exactly one day has passed. The Duration
type on the other hand normalizes everything to seconds, and will therefore say that 90000 seconds has passed, which is the same as 25 hours.
See also
Imports
Types
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"
- Represents a month. Note that the enum starts at
1
, soord(month)
will give the month number in the range1..12
. Source Edit WeekDay = enum dMon = "Monday", dTue = "Tuesday", dWed = "Wednesday", dThu = "Thursday", dFri = "Friday", dSat = "Saturday", dSun = "Sunday"
- Represents a weekday. Source Edit
MonthdayRange = range[1 .. 31]
- Source Edit
HourRange = range[0 .. 23]
- Source Edit
MinuteRange = range[0 .. 59]
- Source Edit
SecondRange = range[0 .. 60]
- Includes the value 60 to allow for a leap second. Note however that the
second
of aDateTime
will never be a leap second. Source Edit YeardayRange = range[0 .. 365]
- Source Edit
NanosecondRange = range[0 .. 999999999]
- Source Edit
Time = object seconds: int64 nanosecond: NanosecondRange
- Represents a point in time. Source Edit
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
- Represents a time in different parts. Although this type can represent leap seconds, they are generally not supported in this module. They are not ignored, but the
DateTime
's returned by procedures in this module will never have a leap second. Source Edit Duration = object seconds: int64 nanosecond: NanosecondRange
-
Represents a fixed duration of time, meaning a duration that has constant length independent of the context.
To create a new
Source EditDuration
, use initDuration proc. TimeUnit = enum Nanoseconds, Microseconds, Milliseconds, Seconds, Minutes, Hours, Days, Weeks, Months, Years
- Different units of time. Source Edit
FixedTimeUnit = range[Nanoseconds .. Weeks]
- Subrange of
TimeUnit
that only includes units of fixed duration. These are the units that can be represented by aDuration
. Source Edit 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
-
Represents a non-fixed duration of time. Can be used to add and subtract non-fixed time units from a DateTime or Time.
Create a new
TimeInterval
with initTimeInterval proc.Note that
TimeInterval
doesn't represent a fixed duration of time, since the duration of some units depend on the context (e.g a year can be either 365 or 366 days long). The non-fixed time units are years, months, days and week.Note that
Source EditTimeInterval
's returned from thetimes
module are never normalized. If you want to normalize a time unit, Duration should be used instead. 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
- Timezone interface for supporting DateTimes of arbitrary timezones. The
times
module only supplies implementations for the systems local time and UTC. Source Edit 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.
- Represents a point in time with an associated UTC offset and DST flag. This type is only used for implementing timezones. Source Edit
DurationParts = array[FixedTimeUnit, int64]
- Source Edit
TimeIntervalParts = array[TimeUnit, int]
- Source Edit
DateTimeLocale = object MMM*: array[mJan .. mDec, string] MMMM*: array[mJan .. mDec, string] ddd*: array[dMon .. dSun, string] dddd*: array[dMon .. dSun, string]
- Source Edit
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
-
Represents a format for parsing and printing time types.
To create a new
Source EditTimeFormat
use initTimeFormat proc. TimeParseError = object of ValueError
- Raised when parsing input using a
TimeFormat
fails. Source Edit TimeFormatParseError = object of ValueError
- Raised when parsing a
TimeFormat
string fails. Source Edit
Consts
DurationZero = (seconds: 0, nanosecond: 0)
- Zero value for durations. Useful for comparisons.
doAssert initDuration(seconds = 1) > DurationZero doAssert initDuration(seconds = 0) == DurationZero
Source Edit 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"])
- Source Edit
Procs
proc convert[T: SomeInteger](unitFrom, unitTo: FixedTimeUnit; quantity: T): T {...}{. inline.}
- Convert a quantity of some duration unit to another duration unit. This proc only deals with integers, so the result might be truncated.
Example:
doAssert convert(Days, Hours, 2) == 48 doAssert convert(Days, Weeks, 13) == 1 # Truncated doAssert convert(Seconds, Milliseconds, -1) == -1000
Source Edit proc isLeapYear(year: int): bool {...}{.raises: [], tags: [].}
- Returns true if
year
is a leap year.Example:
doAssert isLeapYear(2000) doAssert not isLeapYear(1900)
Source Edit proc getDaysInMonth(month: Month; year: int): int {...}{.raises: [], tags: [].}
- Get the number of days in
month
ofyear
.Example:
doAssert getDaysInMonth(mFeb, 2000) == 29 doAssert getDaysInMonth(mFeb, 2001) == 28
Source Edit proc getDayOfYear(monthday: MonthdayRange; month: Month; year: int): YeardayRange {...}{. tags: [], raises: [], gcsafe, locks: 0.}
- Returns the day of the year. Equivalent with
initDateTime(monthday, month, year, 0, 0, 0).yearday
.Example:
doAssert getDayOfYear(1, mJan, 2000) == 0 doAssert getDayOfYear(10, mJan, 2000) == 9 doAssert getDayOfYear(10, mFeb, 2000) == 40
Source Edit proc getDayOfWeek(monthday: MonthdayRange; month: Month; year: int): WeekDay {...}{. tags: [], raises: [], gcsafe, locks: 0.}
- Returns the day of the week enum from day, month and year. Equivalent with
initDateTime(monthday, month, year, 0, 0, 0).weekday
.Example:
doAssert getDayOfWeek(13, mJun, 1990) == dWed doAssert $getDayOfWeek(13, mJun, 1990) == "Wednesday"
Source Edit proc getDaysInYear(year: int): int {...}{.raises: [], tags: [].}
- Get the number of days in a
year
Example:
doAssert getDaysInYear(2000) == 366 doAssert getDaysInYear(2001) == 365
Source Edit proc initDuration(nanoseconds, microseconds, milliseconds, seconds, minutes, hours, days, weeks: int64 = 0): Duration {...}{.raises: [], tags: [].}
- Create a new Duration.
Example:
let dur = initDuration(seconds = 1, milliseconds = 1) doAssert dur.inMilliseconds == 1001 doAssert dur.inSeconds == 1
Source Edit proc inWeeks(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole weeks.
Example:
let dur = initDuration(days = 8) doAssert dur.inWeeks == 1
Source Edit proc inDays(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole days.
Example:
let dur = initDuration(hours = -50) doAssert dur.inDays == -2
Source Edit proc inHours(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole hours.
Example:
let dur = initDuration(minutes = 60, days = 2) doAssert dur.inHours == 49
Source Edit proc inMinutes(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole minutes.
Example:
let dur = initDuration(hours = 2, seconds = 10) doAssert dur.inMinutes == 120
Source Edit proc inSeconds(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole seconds.
Example:
let dur = initDuration(hours = 2, milliseconds = 10) doAssert dur.inSeconds == 2 * 60 * 60
Source Edit proc inMilliseconds(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole milliseconds.
Example:
let dur = initDuration(seconds = -2) doAssert dur.inMilliseconds == -2000
Source Edit proc inMicroseconds(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole microseconds.
Example:
let dur = initDuration(seconds = -2) doAssert dur.inMicroseconds == -2000000
Source Edit proc inNanoseconds(dur: Duration): int64 {...}{.raises: [], tags: [].}
- Convert the duration to the number of whole nanoseconds.
Example:
let dur = initDuration(seconds = -2) doAssert dur.inNanoseconds == -2000000000
Source Edit proc toParts(dur: Duration): DurationParts {...}{.raises: [], tags: [].}
-
Converts a duration into an array consisting of fixed time units.
Each value in the array gives information about a specific unit of time, for example
result[Days]
gives a count of days.This procedure is useful for converting
Duration
values to strings.Example:
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
Source Edit proc `$`(dur: Duration): string {...}{.raises: [], tags: [].}
- Human friendly string representation of a
Duration
.Example:
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"
Source Edit proc `+`(a, b: Duration): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntAddDuration", raises: [], tags: [].}
- Add two durations together.
Example:
doAssert initDuration(seconds = 1) + initDuration(days = 1) == initDuration(seconds = 1, days = 1)
Source Edit proc `-`(a, b: Duration): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntSubDuration", raises: [], tags: [].}
- Subtract a duration from another.
Example:
doAssert initDuration(seconds = 1, days = 1) - initDuration(seconds = 1) == initDuration(days = 1)
Source Edit proc `-`(a: Duration): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntReverseDuration", raises: [], tags: [].}
- Reverse a duration.
Example:
doAssert -initDuration(seconds = 1) == initDuration(seconds = -1)
Source Edit proc `<`(a, b: Duration): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntLtDuration", raises: [], tags: [].}
- Note that a duration can be negative, so even if
a < b
is truea
might represent a larger absolute duration. Useabs(a) < abs(b)
to compare the absolute duration.Example:
doAssert initDuration(seconds = 1) < initDuration(seconds = 2) doAssert initDuration(seconds = -2) < initDuration(seconds = 1) doAssert initDuration(seconds = -2).abs < initDuration(seconds = 1).abs == false
Source Edit proc `<=`(a, b: Duration): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntLeDuration", raises: [], tags: [].}
- Source Edit
proc `==`(a, b: Duration): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntEqDuration", raises: [], tags: [].}
-
Example:
let d1 = initDuration(weeks = 1) d2 = initDuration(days = 7) doAssert d1 == d2
Source Edit proc `*`(a: int64; b: Duration): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntMulInt64Duration", raises: [], tags: [].}
- Multiply a duration by some scalar.
Example:
doAssert 5 * initDuration(seconds = 1) == initDuration(seconds = 5) doAssert 3 * initDuration(minutes = 45) == initDuration(hours = 2, minutes = 15)
Source Edit proc `*`(a: Duration; b: int64): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntMulDuration", raises: [], tags: [].}
- Multiply a duration by some scalar.
Example:
doAssert initDuration(seconds = 1) * 5 == initDuration(seconds = 5) doAssert initDuration(minutes = 45) * 3 == initDuration(hours = 2, minutes = 15)
Source Edit proc `+=`(d1: var Duration; d2: Duration) {...}{.raises: [], tags: [].}
- Source Edit
proc `-=`(dt: var Duration; ti: Duration) {...}{.raises: [], tags: [].}
- Source Edit
proc `*=`(a: var Duration; b: int) {...}{.raises: [], tags: [].}
- Source Edit
proc `div`(a: Duration; b: int64): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntDivDuration", raises: [], tags: [].}
- Integer division for durations.
Example:
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)
Source Edit proc high(typ: typedesc[Duration]): Duration
- Get the longest representable duration. Source Edit
proc low(typ: typedesc[Duration]): Duration
- Get the longest representable duration of negative direction. Source Edit
proc abs(a: Duration): Duration {...}{.raises: [], tags: [].}
-
Example:
doAssert initDuration(milliseconds = -1500).abs == initDuration(milliseconds = 1500)
Source Edit proc initTime(unix: int64; nanosecond: NanosecondRange): Time {...}{.raises: [], tags: [].}
- Create a Time from a unix timestamp and a nanosecond part. Source Edit
proc nanosecond(time: Time): NanosecondRange {...}{.raises: [], tags: [].}
- Get the fractional part of a
Time
as the number of nanoseconds of the second. Source Edit proc fromUnix(unix: int64): Time {...}{.gcsafe, locks: 0, tags: [], raises: [], noSideEffect.}
- Convert a unix timestamp (seconds since
1970-01-01T00:00:00Z
) to aTime
.Example:
doAssert $fromUnix(0).utc == "1970-01-01T00:00:00Z"
Source Edit proc toUnix(t: Time): int64 {...}{.gcsafe, locks: 0, tags: [], raises: [], noSideEffect.}
- Convert
t
to a unix timestamp (seconds since1970-01-01T00:00:00Z
). See alsotoUnixFloat
for subsecond resolution.Example:
doAssert fromUnix(0).toUnix() == 0
Source Edit proc fromUnixFloat(seconds: float): Time {...}{.gcsafe, locks: 0, tags: [], raises: [], noSideEffect.}
- Convert a unix timestamp in seconds to a
Time
; same asfromUnix
but with subsecond resolution.Example:
doAssert fromUnixFloat(123456.0) == fromUnixFloat(123456) doAssert fromUnixFloat(-123456.0) == fromUnixFloat(-123456)
Source Edit proc toUnixFloat(t: Time): float {...}{.gcsafe, locks: 0, tags: [], raises: [].}
- Same as
toUnix
but using subsecond resolution.Example:
let t = getTime() # `<` because of rounding errors doAssert abs(t.toUnixFloat().fromUnixFloat - t) < initDuration(nanoseconds = 1000)
Source Edit proc fromWinTime(win: int64): Time {...}{.raises: [], tags: [].}
- Convert a Windows file time (100-nanosecond intervals since
1601-01-01T00:00:00Z
) to aTime
. Source Edit proc toWinTime(t: Time): int64 {...}{.raises: [], tags: [].}
- Convert
t
to a Windows file time (100-nanosecond intervals since1601-01-01T00:00:00Z
). Source Edit proc getTime(): Time {...}{.tags: [TimeEffect], gcsafe, locks: 0, raises: [].}
- Gets the current time as a
Time
with up to nanosecond resolution. Source Edit proc `-`(a, b: Time): Duration {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntDiffTime", raises: [], tags: [].}
- Computes the duration between two points in time.
Example:
doAssert initTime(1000, 100) - initTime(500, 20) == initDuration(minutes = 8, seconds = 20, nanoseconds = 80)
Source Edit proc `+`(a: Time; b: Duration): Time {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntAddTime", raises: [], tags: [].}
- Add a duration of time to a
Time
.Example:
doAssert (fromUnix(0) + initDuration(seconds = 1)) == fromUnix(1)
Source Edit proc `-`(a: Time; b: Duration): Time {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntSubTime", raises: [], tags: [].}
- Subtracts a duration of time from a
Time
.Example:
doAssert (fromUnix(0) - initDuration(seconds = 1)) == fromUnix(-1)
Source Edit proc `<`(a, b: Time): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntLtTime", raises: [], tags: [].}
- Returns true if
a < b
, that is ifa
happened beforeb
.Example:
doAssert initTime(50, 0) < initTime(99, 0)
Source Edit proc `<=`(a, b: Time): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntLeTime", raises: [], tags: [].}
- Returns true if
a <= b
. Source Edit proc `==`(a, b: Time): bool {...}{.gcsafe, noSideEffect, gcsafe, locks: 0, extern: "ntEqTime", raises: [], tags: [].}
- Returns true if
a == b
, that is if both times represent the same point in time. Source Edit proc `+=`(t: var Time; b: Duration) {...}{.raises: [], tags: [].}
- Source Edit
proc `-=`(t: var Time; b: Duration) {...}{.raises: [], tags: [].}
- Source Edit
proc high(typ: typedesc[Time]): Time
- Source Edit
proc low(typ: typedesc[Time]): Time
- Source Edit
proc nanosecond(dt: DateTime): NanosecondRange {...}{.inline, raises: [], tags: [].}
- The number of nanoseconds after the second, in the range 0 to 999_999_999. Source Edit
proc second(dt: DateTime): SecondRange {...}{.inline, raises: [], tags: [].}
- The number of seconds after the minute, in the range 0 to 59. Source Edit
proc minute(dt: DateTime): MinuteRange {...}{.inline, raises: [], tags: [].}
- The number of minutes after the hour, in the range 0 to 59. Source Edit
proc hour(dt: DateTime): HourRange {...}{.inline, raises: [], tags: [].}
- The number of hours past midnight, in the range 0 to 23. Source Edit
proc monthday(dt: DateTime): MonthdayRange {...}{.inline, raises: [], tags: [].}
- The day of the month, in the range 1 to 31. Source Edit
proc month(dt: DateTime): Month {...}{.raises: [], tags: [].}
- The month as an enum, the ordinal value is in the range 1 to 12. Source Edit
proc year(dt: DateTime): int {...}{.inline, raises: [], tags: [].}
- The year, using astronomical year numbering (meaning that before year 1 is year 0, then year -1 and so on). Source Edit
proc weekday(dt: DateTime): WeekDay {...}{.inline, raises: [], tags: [].}
- The day of the week as an enum, the ordinal value is in the range 0 (monday) to 6 (sunday). Source Edit
proc yearday(dt: DateTime): YeardayRange {...}{.inline, raises: [], tags: [].}
- The number of days since January 1, in the range 0 to 365. Source Edit
proc isDst(dt: DateTime): bool {...}{.inline, raises: [], tags: [].}
- Determines whether DST is in effect. Always false for the JavaScript backend. Source Edit
proc timezone(dt: DateTime): Timezone {...}{.inline, raises: [], tags: [].}
- The timezone represented as an implementation of
Timezone
. Source Edit proc utcOffset(dt: DateTime): int {...}{.inline, raises: [], tags: [].}
- The offset in seconds west of UTC, including any offset due to DST. Note that the sign of this number is the opposite of the one in a formatted offset string like
+01:00
(which would be equivalent to the UTC offset-3600
). Source Edit proc isInitialized(dt: DateTime): bool {...}{.raises: [], tags: [].}
-
Example:
doAssert now().isInitialized doAssert not default(DateTime).isInitialized
Source Edit proc isLeapDay(dt: DateTime): bool {...}{.raises: [], tags: [].}
- Returns whether
t
is a leap day, i.e. Feb 29 in a leap year. This matters as it affects time offset calculations.Example:
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())
Source Edit proc toTime(dt: DateTime): Time {...}{.tags: [], raises: [], gcsafe, locks: 0.}
- Converts a
DateTime
to aTime
representing the same point in time. Source Edit 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: [].}
-
Create a new
Timezone
.zonedTimeFromTimeImpl
andzonedTimeFromAdjTimeImpl
is used as the underlying implementations forzonedTimeFromTime
andzonedTimeFromAdjTime
.If possible, the name parameter should match the name used in the tz database. If the timezone doesn't exist in the tz database, or if the timezone name is unknown, then any string that describes the timezone unambiguously can be used. Note that the timezones name is used for checking equality!
Example:
proc utcTzInfo(time: Time): ZonedTime = ZonedTime(utcOffset: 0, isDst: false, time: time) let utc = newTimezone("Etc/UTC", utcTzInfo, utcTzInfo)
Source Edit proc name(zone: Timezone): string {...}{.raises: [], tags: [].}
-
The name of the timezone.
If possible, the name will be the name used in the tz database. If the timezone doesn't exist in the tz database, or if the timezone name is unknown, then any string that describes the timezone unambiguously might be used. For example, the string "LOCAL" is used for the systems local timezone.
See also: https://en.wikipedia.org/wiki/Tz_database
Source Edit proc zonedTimeFromTime(zone: Timezone; time: Time): ZonedTime {...}{.raises: [], tags: [].}
- Returns the
ZonedTime
for some point in time. Source Edit proc zonedTimeFromAdjTime(zone: Timezone; adjTime: Time): ZonedTime {...}{. raises: [], tags: [].}
-
Returns the
ZonedTime
for some local time.Note that the
Source EditTime
argument does not represent a point in time, it represent a local time! E.g ifadjTime
isfromUnix(0)
, it should be interpreted as 1970-01-01T00:00:00 in thezone
timezone, not in UTC. proc `$`(zone: Timezone): string {...}{.raises: [], tags: [].}
- Returns the name of the timezone. Source Edit
proc `==`(zone1, zone2: Timezone): bool {...}{.raises: [], tags: [].}
- Two
Timezone
's are considered equal if their name is equal.Example:
doAssert local() == local() doAssert local() != utc()
Source Edit proc inZone(time: Time; zone: Timezone): DateTime {...}{.tags: [], raises: [], gcsafe, locks: 0.}
- Convert
time
into aDateTime
usingzone
as the timezone. Source Edit proc inZone(dt: DateTime; zone: Timezone): DateTime {...}{.tags: [], raises: [], gcsafe, locks: 0.}
- Returns a
DateTime
representing the same point in time asdt
but usingzone
as the timezone. Source Edit proc utc(): Timezone {...}{.raises: [], tags: [].}
- Get the
Timezone
implementation for the UTC timezone.Example:
doAssert now().utc.timezone == utc() doAssert utc().name == "Etc/UTC"
Source Edit proc local(): Timezone {...}{.raises: [], tags: [].}
- Get the
Timezone
implementation for the local timezone.Example:
doAssert now().timezone == local() doAssert local().name == "LOCAL"
Source Edit proc utc(dt: DateTime): DateTime {...}{.raises: [], tags: [].}
- Shorthand for
dt.inZone(utc())
. Source Edit proc local(dt: DateTime): DateTime {...}{.raises: [], tags: [].}
- Shorthand for
dt.inZone(local())
. Source Edit proc utc(t: Time): DateTime {...}{.raises: [], tags: [].}
- Shorthand for
t.inZone(utc())
. Source Edit proc local(t: Time): DateTime {...}{.raises: [], tags: [].}
- Shorthand for
t.inZone(local())
. Source Edit proc now(): DateTime {...}{.tags: [TimeEffect], gcsafe, locks: 0, raises: [].}
-
Get the current time as a
DateTime
in the local timezone.Shorthand for
Source EditgetTime().local
. proc initDateTime(monthday: MonthdayRange; month: Month; year: int; hour: HourRange; minute: MinuteRange; second: SecondRange; nanosecond: NanosecondRange; zone: Timezone = local()): DateTime {...}{. raises: [], tags: [].}
- Create a new DateTime in the specified timezone.
Example:
let dt1 = initDateTime(30, mMar, 2017, 00, 00, 00, 00, utc()) doAssert $dt1 == "2017-03-30T00:00:00Z"
Source Edit proc initDateTime(monthday: MonthdayRange; month: Month; year: int; hour: HourRange; minute: MinuteRange; second: SecondRange; zone: Timezone = local()): DateTime {...}{.raises: [], tags: [].}
- Create a new DateTime in the specified timezone.
Example:
let dt1 = initDateTime(30, mMar, 2017, 00, 00, 00, utc()) doAssert $dt1 == "2017-03-30T00:00:00Z"
Source Edit proc `+`(dt: DateTime; dur: Duration): DateTime {...}{.raises: [], tags: [].}
-
Example:
let dt = initDateTime(30, mMar, 2017, 00, 00, 00, utc()) let dur = initDuration(hours = 5) doAssert $(dt + dur) == "2017-03-30T05:00:00Z"
Source Edit proc `-`(dt: DateTime; dur: Duration): DateTime {...}{.raises: [], tags: [].}
-
Example:
let dt = initDateTime(30, mMar, 2017, 00, 00, 00, utc()) let dur = initDuration(days = 5) doAssert $(dt - dur) == "2017-03-25T00:00:00Z"
Source Edit proc `-`(dt1, dt2: DateTime): Duration {...}{.raises: [], tags: [].}
- Compute the duration between
dt1
anddt2
.Example:
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)
Source Edit proc `<`(a, b: DateTime): bool {...}{.raises: [], tags: [].}
- Returns true if
a
happened beforeb
. Source Edit proc `<=`(a, b: DateTime): bool {...}{.raises: [], tags: [].}
- Returns true if
a
happened before or at the same time asb
. Source Edit proc `==`(a, b: DateTime): bool {...}{.raises: [], tags: [].}
- Returns true if
a
andb
represent the same point in time. Source Edit proc `+=`(a: var DateTime; b: Duration) {...}{.raises: [], tags: [].}
- Source Edit
proc `-=`(a: var DateTime; b: Duration) {...}{.raises: [], tags: [].}
- Source Edit
proc getDateStr(dt = now()): string {...}{.gcsafe, extern: "nt$1", tags: [TimeEffect], raises: [].}
- Gets the current local date as a string of the format
YYYY-MM-DD
.Example:
echo getDateStr(now() - 1.months)
Source Edit proc getClockStr(dt = now()): string {...}{.gcsafe, extern: "nt$1", tags: [TimeEffect], raises: [].}
- Gets the current local clock time as a string of the format
HH:mm:ss
.Example:
echo getClockStr(now() - 1.hours)
Source Edit proc `$`(f: TimeFormat): string {...}{.raises: [], tags: [].}
- Returns the format string that was used to construct
f
.Example:
let f = initTimeFormat("yyyy-MM-dd") doAssert $f == "yyyy-MM-dd"
Source Edit proc initTimeFormat(format: string): TimeFormat {...}{. raises: [TimeFormatParseError], tags: [].}
-
Construct a new time format for parsing & formatting time types.
See Parsing and formatting dates for documentation of the
format
argument.Example:
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: [].}
- Format
dt
using the format specified byf
.Example:
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: [].}
-
Shorthand for constructing a
TimeFormat
and using it to formatdt
.See Parsing and formatting dates for documentation of the
format
argument.Example:
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: [].}
- Overload that validates
format
at compile time. Source Edit proc formatValue(result: var string; value: DateTime; specifier: string) {...}{. raises: [TimeFormatParseError], tags: [].}
- adapter for strformat. Not intended to be called directly. Source Edit
proc format(time: Time; f: string; zone: Timezone = local()): string {...}{. raises: [TimeFormatParseError], tags: [].}
-
Shorthand for constructing a
TimeFormat
and using it to formattime
. Will use the timezone specified byzone
.See Parsing and formatting dates for documentation of the
f
argument.Example:
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: [].}
- Overload that validates
f
at compile time. Source Edit proc parse(input: string; f: TimeFormat; zone: Timezone = local(); loc: DateTimeLocale = DefaultLocale): DateTime {...}{. raises: [TimeParseError, Defect], tags: [TimeEffect].}
-
Parses
input
as aDateTime
using the format specified byf
. If no UTC offset was parsed, theninput
is assumed to be specified in thezone
timezone. If a UTC offset was parsed, the result will be converted to thezone
timezone.Month and day names from the passed in
loc
are used.Example:
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].}
-
Shorthand for constructing a
TimeFormat
and using it to parseinput
as aDateTime
.See Parsing and formatting dates for documentation of the
f
argument.Example:
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].}
- Overload that validates
f
at compile time. Source Edit proc parseTime(input, f: string; zone: Timezone): Time {...}{. raises: [TimeParseError, TimeFormatParseError, Defect], tags: [TimeEffect].}
-
Shorthand for constructing a
TimeFormat
and using it to parseinput
as aDateTime
, then converting it aTime
.See Parsing and formatting dates for documentation of the
format
argument.Example:
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].}
- Overload that validates
format
at compile time. Source Edit proc `$`(dt: DateTime): string {...}{.tags: [], raises: [], gcsafe, locks: 0.}
- Converts a
DateTime
object to a string representation. It uses the formatyyyy-MM-dd'T'HH:mm:sszzz
.Example:
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.}
- Converts a
Time
value to a string representation. It will use the local time zone and use the formatyyyy-MM-dd'T'HH:mm:sszzz
.Example:
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: [].}
-
Creates a new TimeInterval.
This proc doesn't perform any normalization! For example,
initTimeInterval(hours = 24)
andinitTimeInterval(days = 1)
are not equal.You can also use the convenience procedures called
milliseconds
,seconds
,minutes
,hours
,days
,months
, andyears
.Example:
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: [].}
- Adds two
TimeInterval
objects together. Source Edit proc `-`(ti: TimeInterval): TimeInterval {...}{.raises: [], tags: [].}
- Reverses a time interval
Example:
let day = -initTimeInterval(hours = 24) doAssert day.hours == -24
Source Edit proc `-`(ti1, ti2: TimeInterval): TimeInterval {...}{.raises: [], tags: [].}
-
Subtracts TimeInterval
ti1
fromti2
.Time components are subtracted one-by-one, see output:
Example:
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: [].}
- Gives the difference between
startDt
andendDt
as aTimeInterval
. The following guarantees about the result is given:- All fields will have the same sign.
- If
startDt.timezone == endDt.timezone
, it is guaranteed thatstartDt + between(startDt, endDt) == endDt
. - If
startDt.timezone != endDt.timezone
, then the result will be equivalent tobetween(startDt.utc, endDt.utc)
.
Example:
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: [].}
-
Converts a
TimeInterval
into an array consisting of its time units, starting with nanoseconds and ending with years.This procedure is useful for converting
TimeInterval
values to strings. E.g. then you need to implement custom interval printingExample:
var tp = toParts(initTimeInterval(years = 1, nanoseconds = 123)) doAssert tp[Years] == 1 doAssert tp[Nanoseconds] == 123
Source Edit proc `$`(ti: TimeInterval): string {...}{.raises: [], tags: [].}
- Get string representation of
TimeInterval
.Example:
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 of
nanos
nanoseconds. Source Edit proc microseconds(micros: int): TimeInterval {...}{.inline, raises: [], tags: [].}
- TimeInterval of
micros
microseconds. Source Edit proc milliseconds(ms: int): TimeInterval {...}{.inline, raises: [], tags: [].}
- TimeInterval of
ms
milliseconds. Source Edit proc seconds(s: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
s
seconds.
Source Editecho getTime() + 5.seconds
proc minutes(m: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
m
minutes.
Source Editecho getTime() + 5.minutes
proc hours(h: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
h
hours.
Source Editecho getTime() + 2.hours
proc days(d: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
d
days.
Source Editecho getTime() + 2.days
proc weeks(w: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
w
weeks.
Source Editecho getTime() + 2.weeks
proc months(m: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
m
months.
Source Editecho getTime() + 2.months
proc years(y: int): TimeInterval {...}{.inline, raises: [], tags: [].}
-
TimeInterval of
y
years.
Source Editecho getTime() + 2.years
proc `+`(dt: DateTime; interval: TimeInterval): DateTime {...}{.raises: [], tags: [].}
-
Adds
interval
todt
. Components frominterval
are added in the order of their size, i.e. first theyears
component, then themonths
component and so on. The returnedDateTime
will have the same timezone as the input.Note that when adding months, monthday overflow is allowed. This means that if the resulting month doesn't have enough days it, the month will be incremented and the monthday will be set to the number of days overflowed. So adding one month to
31 October
will result in31 November
, which will overflow and result in1 December
.Example:
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"
Source Edit proc `-`(dt: DateTime; interval: TimeInterval): DateTime {...}{.raises: [], tags: [].}
- Subtract
interval
fromdt
. Components frominterval
are subtracted in the order of their size, i.e. first theyears
component, then themonths
component and so on. The returnedDateTime
will have the same timezone as the input.Example:
let dt = initDateTime(30, mMar, 2017, 00, 00, 00, utc()) doAssert $(dt - 5.days) == "2017-03-25T00:00:00Z"
Source Edit proc `+`(time: Time; interval: TimeInterval): Time {...}{.raises: [], tags: [].}
- Adds
interval
totime
. Ifinterval
contains any years, months, weeks or days the operation is performed in the local timezone.Example:
let tm = fromUnix(0) doAssert tm + 5.seconds == fromUnix(5)
Source Edit proc `-`(time: Time; interval: TimeInterval): Time {...}{.raises: [], tags: [].}
- Subtracts
interval
from Timetime
. Ifinterval
contains any years, months, weeks or days the operation is performed in the local timezone.Example:
let tm = fromUnix(5) doAssert tm - 5.seconds == fromUnix(0)
Source Edit proc `+=`(a: var DateTime; b: TimeInterval) {...}{.raises: [], tags: [].}
- Source Edit
proc `-=`(a: var DateTime; b: TimeInterval) {...}{.raises: [], tags: [].}
- Source Edit
proc `+=`(t: var Time; b: TimeInterval) {...}{.raises: [], tags: [].}
- Source Edit
proc `-=`(t: var Time; b: TimeInterval) {...}{.raises: [], tags: [].}
- Source Edit
proc epochTime(): float {...}{.tags: [TimeEffect], raises: [].}
-
Gets time after the UNIX epoch (1970) in seconds. It is a float because sub-second resolution is likely to be supported (depending on the hardware/OS).
Source EditgetTime
should generally be preferred over this proc. proc cpuTime(): float {...}{.tags: [TimeEffect], raises: [].}
- Gets time spent that the CPU spent to run the current process in seconds. This may be more useful for benchmarking than
epochTime
. However, it may measure the real time instead (depending on the OS). The value of the result has no meaning. To generate useful timing values, take the difference between the results of twocpuTime
calls:Example:
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
When the flag--benchmarkVM
is passed to the compiler, this proc is also available at compile time Source Edit proc nanosecond=(dt: var DateTime; value: NanosecondRange) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc second=(dt: var DateTime; value: SecondRange) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc minute=(dt: var DateTime; value: MinuteRange) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc hour=(dt: var DateTime; value: HourRange) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc monthdayZero=(dt: var DateTime; value: int) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc monthZero=(dt: var DateTime; value: int) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc year=(dt: var DateTime; value: int) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc weekday=(dt: var DateTime; value: WeekDay) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc yearday=(dt: var DateTime; value: YeardayRange) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc isDst=(dt: var DateTime; value: bool) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc timezone=(dt: var DateTime; value: Timezone) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
proc utcOffset=(dt: var DateTime; value: int) {...}{. deprecated: "Deprecated since v1.3.1", raises: [], tags: [].}
- Source Edit
Templates
template formatValue(result: var string; value: Time; specifier: string)
- adapter for
strformat
. Not intended to be called directly. Source Edit
© 2006–2021 Andreas Rumpf
Licensed under the MIT License.
https://nim-lang.org/docs/times.html