Period
Year
Quarter
Month
Week
Day
Hour
Minute
Second
Millisecond
Microsecond
Nanosecond

Period类型表示时间的离散、人类可读的表示。

CompoundPeriod

CompoundPeriod对于表达不是较小周期固定倍数的时间周期很有用。例如，“一年零一天”不是固定天数，但可以使用CompoundPeriod来表达。实际上，CompoundPeriod是通过不同周期类型的加法自动生成的，例如Year(1) + Day(1)会生成CompoundPeriod结果。

Instant

Instant类型表示基于整数的、机器可读的时间表示，作为从纪元开始的连续时间线。

UTInstant{T}

UTInstant表示基于UT时间的机器时间线（1天=地球自转一周）。T是一个Period参数，指示瞬间的分辨率或精度。

TimeType

TimeType类型包装Instant机器实例以提供机器瞬间的人类可读表示。Time、DateTime和Date是TimeType的子类型。

DateTime

DateTime包装一个UTInstant{Millisecond}并根据格里高利历进行解释。

Date

Date包装一个UTInstant{Day}并根据格里高利历进行解释。

Time

Time包装一个Nanosecond并表示24小时制中的特定时刻。

TimeZone

地理区域通常基于经度确定特定位置的时间。一些时区实行夏令时（例如EST -> EDT）。有关实现和更多支持，请参阅TimeZones.jl包

UTC

UTC，或协调世界时，是所有其他时区测量的TimeZone。它与0°经线上的时间相关联。它不会因夏令时而调整。

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

按部分构造DateTime类型。参数必须可转换为Int64。

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

通过Period类型部分构造DateTime类型。参数可以按任何顺序排列。未提供的DateTime部分将默认为Dates.default(period)的值。

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

通过调整器API创建DateTime。起点将根据提供的y, m, d...参数构建，并将进行调整，直到f::Function返回true。调整中的步长可以通过step关键字手动提供。limit为调整API在抛出错误之前（如果f::Function从未满足）将追求的最大迭代次数提供了一个限制。

示例

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

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

DateTime(dt::Date) -> DateTime

将Date转换为DateTime。新DateTime的小时、分钟、秒和毫秒部分假定为零。

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

通过解析遵循format字符串中给定模式的dt日期时间字符串来构造DateTime（有关语法，请参阅DateFormat）。

示例

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

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

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

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

使用TimeType对象并应用提供的format来构造字符串。可以使用以下字符代码来构造format字符串

连续代码字符的数量指示代码的宽度。格式yyyy-mm指定代码y应具有宽度4，而m应具有宽度2。生成数字的代码具有关联的模式：固定宽度或最小宽度。固定宽度模式在值短于指定宽度时在左侧用零填充，在值长于指定宽度时截断值。最小宽度模式的工作方式与固定宽度相同，只是它不会截断长于宽度的值。

创建format时，您可以使用任何非代码字符作为分隔符。例如，要生成字符串“1996-01-15T00:00:00”，您可以使用format：“yyyy-mm-ddTHH:MM:SS”。请注意，如果您需要将代码字符用作文字，则可以使用转义字符反斜杠。字符串“1996y01m”可以使用格式“yyyy\ymm\m”生成。

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

构造一个日期格式化对象，可用于解析日期字符串或将日期对象格式化为字符串。可以使用以下字符代码来构造format字符串

上面未列出的字符通常被视为日期和时间段之间的分隔符。例如，字符串“1996-01-15T00:00:00.0”的format字符串将类似于“y-m-dTH:M:S.s”。如果您需要将代码字符用作分隔符，则可以使用反斜杠对其进行转义。日期“1995y01m”的格式将为“y\ym\m”。

请注意，12:00AM对应00:00（午夜），12:00PM对应12:00（中午）。当使用p说明符解析时间时，任何小时（H或I）都被解释为12小时制，因此I代码主要用于输出。

创建DateFormat对象代价很高。尽可能地创建一次并多次使用它，或者尝试dateformat""字符串宏。使用此宏在宏扩展时创建一次DateFormat对象并在以后重复使用它。还有几个预定义的格式化程序，稍后列出。

有关如何分别使用DateFormat对象解析和写入日期字符串，请参阅DateTime和format。

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

创建一个DateFormat对象。类似于DateFormat("Y-m-d H:M:S")，但在宏扩展期间创建一次DateFormat对象。

有关格式说明符的详细信息，请参阅DateFormat。

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

通过解析遵循DateFormat对象中给定模式的dt日期时间字符串来构造DateTime，如果省略则使用dateformat"yyyy-mm-dd\THH:MM:SS.s"。

类似于DateTime(::AbstractString, ::AbstractString)，但在使用预创建的DateFormat对象重复解析格式相似的日期时间字符串时效率更高。

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

按部分构造Date类型。参数必须可转换为Int64。

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

通过Period类型部分构造Date类型。参数可以按任何顺序排列。未提供的Date部分将默认为Dates.default(period)的值。

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

通过调整器 API 创建一个 Date。起点将根据提供的 y, m, d 参数构建，并将进行调整，直到 f::Function 返回 true。可以通过 step 关键字手动提供调整的步长。limit 为调整 API 在抛出错误之前（如果 f::Function 始终不满足）将执行的最大迭代次数设置了一个限制。

示例

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

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

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

Date(dt::DateTime) -> Date

将 DateTime 转换为 Date。DateTime 的小时、分钟、秒和毫秒部分会被截断，因此在构造时仅使用年份、月份和日期部分。

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

通过解析遵循 format 字符串中给定模式的 d 日期字符串来构造 Date（有关语法，请参阅 DateFormat）。

示例

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

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

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

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

通过解析遵循 DateFormat 对象中给定模式的 d 日期字符串来构造 Date，如果省略则使用日期格式“yyyy-mm-dd”。

类似于 Date(::AbstractString, ::AbstractString)，但在使用预先创建的 DateFormat 对象重复解析格式类似的日期字符串时效率更高。

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

通过分段构造 Time 类型。参数必须可转换为 Int64。

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

通过 Period 类型部分构造 Time 类型。参数可以按任意顺序排列。未提供的 Time 部分将默认为 Dates.default(period) 的值。

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

通过调整器 API 创建一个 Time。起点将根据提供的 h, mi, s, ms, us 参数构建，并将进行调整，直到 f::Function 返回 true。可以通过 step 关键字手动提供调整的步长。limit 为调整 API 在抛出错误之前（如果 f::Function 始终不满足）将执行的最大迭代次数设置了一个限制。请注意，默认步长将调整以允许针对给定参数获得更高的精度；例如，如果提供了小时、分钟和秒参数，则默认步长将为 Millisecond(1) 而不是 Second(1)。

示例

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

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

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

Time(dt::DateTime) -> Time

将 DateTime 转换为 Time。DateTime 的小时、分钟、秒和毫秒部分用于创建新的 Time。微秒和纳秒默认值为零。

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

通过解析遵循 format 字符串中给定模式的 t 时间字符串来构造 Time（有关语法，请参阅 DateFormat）。

示例

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

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

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

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

通过解析遵循 DateFormat 对象中给定模式的 t 日期时间字符串来构造 Time，如果省略则使用日期格式“HH:MM:SS.s”。

类似于 Time(::AbstractString, ::AbstractString)，但在使用预先创建的 DateFormat 对象重复解析格式类似的时间字符串时效率更高。

now() -> DateTime

返回一个对应于用户系统时间的 DateTime，包括系统时区区域设置。

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

返回一个对应于用户系统时间的 DateTime，以 UTC/GMT 表示。对于其他时区，请参阅 TimeZones.jl 包。

示例

julia> now(UTC)
2023-01-04T10:52:24.864

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

返回 TimeType 支持的最小单位值。

示例

julia> eps(DateTime)
1 millisecond

julia> eps(Date)
1 day

julia> eps(Time)
1 nanosecond

year(dt::TimeType) -> Int64

Date 或 DateTime 的年份，以 Int64 表示。

month(dt::TimeType) -> Int64

Date 或 DateTime 的月份，以 Int64 表示。

week(dt::TimeType) -> Int64

返回 Date 或 DateTime 的 ISO 周日期，以 Int64 表示。请注意，一年的第一周是包含该年第一个星期四的那一周，这可能导致 1 月 4 日之前的日期位于上一年的最后一周。例如，week(Date(2005, 1, 1)) 是 2004 年的第 53 周。

示例

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

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

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

day(dt::TimeType) -> Int64

Date 或 DateTime 的当月日期，以 Int64 表示。

hour(dt::DateTime) -> Int64

DateTime 的当日小时，以 Int64 表示。

hour(t::Time) -> Int64

Time 的小时，以 Int64 表示。

minute(dt::DateTime) -> Int64

DateTime 的分钟，以 Int64 表示。

minute(t::Time) -> Int64

Time 的分钟，以 Int64 表示。

second(dt::DateTime) -> Int64

DateTime 的秒，以 Int64 表示。

second(t::Time) -> Int64

Time 的秒，以 Int64 表示。

millisecond(dt::DateTime) -> Int64

DateTime 的毫秒，以 Int64 表示。

millisecond(t::Time) -> Int64

Time 的毫秒，以 Int64 表示。

microsecond(t::Time) -> Int64

Time 的微秒，以 Int64 表示。

nanosecond(t::Time) -> Int64

Time 的纳秒，以 Int64 表示。

Year(v)

使用给定的 v 值构造 Year 对象。输入必须能够无损转换为 Int64。

Month(v)

使用给定的 v 值构造 Month 对象。输入必须能够无损转换为 Int64。

Week(v)

使用给定的 v 值构造 Week 对象。输入必须能够无损转换为 Int64。

Day(v)

使用给定的 v 值构造 Day 对象。输入必须能够无损转换为 Int64。

Hour(dt::DateTime) -> Hour

DateTime 的小时部分，以 Hour 表示。

Minute(dt::DateTime) -> Minute

DateTime 的分钟部分，以 Minute 表示。

Second(dt::DateTime) -> Second

DateTime 的秒部分，以 Second 表示。

Millisecond(dt::DateTime) -> Millisecond

DateTime 的毫秒部分，以 Millisecond 表示。

Microsecond(dt::Time) -> Microsecond

Time 的微秒部分，以 Microsecond 表示。

Nanosecond(dt::Time) -> Nanosecond

Time 的纳秒部分，以 Nanosecond 表示。

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

同时返回 Date 或 DateTime 的年份和月份部分。

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

同时返回 Date 或 DateTime 的月份和日期部分。

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

同时返回 Date 或 DateTime 的年份、月份和日期部分。

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

返回与给定 locale 中 Date 或 DateTime 的星期几对应的完整日期名称。也接受 Integer。

示例

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

julia> dayname(4)
"Thursday"

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

返回与给定 locale 中 Date 或 DateTime 的星期几对应的缩写名称。也接受 Integer。

示例

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

julia> dayabbr(3)
"Wed"

dayofweek(dt::TimeType) -> Int64

返回星期几，以 Int64 表示，其中 1 = 星期一，2 = 星期二，依此类推。

示例

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

dayofmonth(dt::TimeType) -> Int64

Date 或 DateTime 的当月日期，以 Int64 表示。

dayofweekofmonth(dt::TimeType) -> Int

对于dt的星期几，返回它在dt所在月份中的第几个。例如，如果dt的星期几是星期一，则1 = 当月的第一个星期一，2 = 当月的第二个星期一，依此类推。范围为1:5。

示例

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

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

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

daysofweekinmonth(dt::TimeType) -> Int

对于dt的星期几，返回dt所在月份中该星期几的总天数。返回4或5。在时间表达式中，可以通过在调整函数中包含dayofweekofmonth(dt) == daysofweekinmonth(dt)来指定一个月中一周的最后一天，这很有用。

示例

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

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

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

返回给定locale中Date、DateTime或Integer的月份全称。

示例

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

julia> monthname(2)
"February"

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

返回给定locale中Date、DateTime或Integer的月份缩写。

示例

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

julia> monthabbr(2)
"Feb"

daysinmonth(dt::TimeType) -> Int

返回dt所在月份的天数。值为28、29、30或31。

示例

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

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

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

isleapyear(dt::TimeType) -> Bool

如果dt的年份为闰年，则返回true。

示例

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

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

dayofyear(dt::TimeType) -> Int

返回dt在一年中的第几天，其中1月1日为第1天。

daysinyear(dt::TimeType) -> Int

如果dt的年份为闰年，则返回366，否则返回365。

示例

julia> daysinyear(1999)
365

julia> daysinyear(2000)
366

quarterofyear(dt::TimeType) -> Int

返回dt所在的季度。取值范围为1:4。

dayofquarter(dt::TimeType) -> Int

返回dt所在季度的第几天。取值范围为1:92。

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

根据提供的Period类型截断dt的值。

示例

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

firstdayofweek(dt::TimeType) -> TimeType

将dt调整到其所在周的星期一。

示例

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

lastdayofweek(dt::TimeType) -> TimeType

将dt调整到其所在周的星期日。

示例

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

firstdayofmonth(dt::TimeType) -> TimeType

将dt调整到其所在月份的第一天。

示例

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

lastdayofmonth(dt::TimeType) -> TimeType

将dt调整到其所在月份的最后一天。

示例

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

firstdayofyear(dt::TimeType) -> TimeType

将dt调整到其所在年份的第一天。

示例

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

lastdayofyear(dt::TimeType) -> TimeType

将dt调整到其所在年份的最后一天。

示例

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

firstdayofquarter(dt::TimeType) -> TimeType

将dt调整到其所在季度的第一天。

示例

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

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

lastdayofquarter(dt::TimeType) -> TimeType

将dt调整到其所在季度的最后一天。

示例

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

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

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

将dt调整到下一个与dow对应的星期几，其中1 = 星期一，2 = 星期二，依此类推。设置same=true允许将当前dt视为下一个dow，从而无需进行调整。

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

将dt调整到上一个与dow对应的星期几，其中1 = 星期一，2 = 星期二，依此类推。设置same=true允许将当前dt视为上一个dow，从而无需进行调整。

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

将dt调整到其所在月份的第一个dow。或者，of=Year将调整到一年的第一个dow。

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

将dt调整到其所在月份的最后一个dow。或者，of=Year将调整到一年的最后一个dow。

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

通过最多迭代limit次，每次迭代增加step，直到func返回true，从而调整dt。func必须接受一个TimeType参数并返回一个Bool。same允许在满足func时考虑dt。

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

通过最多迭代limit次，每次迭代增加step，直到func返回true，从而调整dt。func必须接受一个TimeType参数并返回一个Bool。same允许在满足func时考虑dt。

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

使用给定的v值构造一个Period类型。输入必须能够无损转换为Int64。

CompoundPeriod(periods) -> CompoundPeriod

从Period的Vector构造一个CompoundPeriod。相同类型的所有Period将加在一起。

示例

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

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

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

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

canonicalize(::CompoundPeriod) -> CompoundPeriod

通过应用以下规则将CompoundPeriod简化为其规范形式

• 任何足够大可以由更粗糙的Period部分表示的Period都将被分解成多个Period（例如，Hour(30)变为Day(1) + Hour(6)）
• 符号相反的Period将在可能的情况下合并（例如，Hour(1) - Day(1)变为-Hour(23)）

示例

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

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

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

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

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

对于给定的时间段，返回与该时间段关联的值。例如，value(Millisecond(10))将10作为整数返回。

default(p::Period) -> Period

通过对Year、Month和Day返回T(1)，对Hour、Minute、Second和Millisecond返回T(0)，为输入Period返回一个合理的“默认”值。

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

返回构成给定CompoundPeriod的Period的Vector。

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

返回小于或等于dt且精度为p的最近的Date或DateTime。

为了方便起见，p可以是类型而不是值：floor(dt, Dates.Hour)是floor(dt, Dates.Hour(1))的简写。

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

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

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

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

返回大于或等于dt且精度为p的最近的Date或DateTime。

为了方便起见，p可以是类型而不是值：ceil(dt, Dates.Hour)是ceil(dt, Dates.Hour(1))的简写。

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

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

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

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

返回与dt最接近且精度为p的Date或DateTime。默认情况下（RoundNearestTiesUp），舍入（例如，将9:30舍入到最接近的小时）将向上舍入。

为了方便起见，p可以是类型而不是值：round(dt, Dates.Hour)是round(dt, Dates.Hour(1))的简写。

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

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

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

round(::TimeType, ::Period, ::RoundingMode)的有效舍入模式为RoundNearestTiesUp（默认）、RoundDown（floor）和RoundUp（ceil）。

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

将x向下舍入到precision的最近倍数。如果x和precision是Period的不同子类型，则返回值将与precision具有相同的类型。

为了方便起见，precision可以是类型而不是值：floor(x, Dates.Hour)是floor(x, Dates.Hour(1))的简写。

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

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

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

不支持舍入到precision为Month或Year，因为这些Period的长度不一致。

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

将x向上舍入到precision的最近倍数。如果x和precision是Period的不同子类型，则返回值将与precision具有相同的类型。

为了方便起见，precision可以是类型而不是值：ceil(x, Dates.Hour)是ceil(x, Dates.Hour(1))的简写。

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

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

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

不支持舍入到precision为Month或Year，因为这些Period的长度不一致。

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

将x舍入到precision的最近倍数。如果x和precision是Period的不同子类型，则返回值将与precision具有相同的类型。默认情况下（RoundNearestTiesUp），舍入（例如，将90分钟舍入到最接近的小时）将向上舍入。

为了方便起见，precision可以是类型而不是值：round(x, Dates.Hour)是round(x, Dates.Hour(1))的简写。

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

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

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

round(::Period, ::T, ::RoundingMode)的有效舍入模式为RoundNearestTiesUp（默认）、RoundDown（floor）和RoundUp（ceil）。

不支持舍入到precision为Month或Year，因为这些Period的长度不一致。

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

同时返回Date或DateTime在分辨率p下的floor和ceil。比分别调用floor和ceil更高效。

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

同时返回Period在分辨率p下的floor和ceil。比分别调用floor和ceil更高效。

epochdays2date(days) -> Date

获取自舍入纪元（0000-01-01T00:00:00）以来的天数，并返回相应的Date。

epochms2datetime(milliseconds) -> DateTime

获取自舍入纪元（0000-01-01T00:00:00）以来的毫秒数，并返回相应的DateTime。

date2epochdays(dt::Date) -> Int64

获取给定的Date，并返回自舍入纪元（0000-01-01T00:00:00）以来的天数，以Int64形式表示。

datetime2epochms(dt::DateTime) -> Int64

获取给定的DateTime，并返回自舍入纪元（0000-01-01T00:00:00）以来的毫秒数，以Int64形式表示。

today() -> Date

返回now()的日期部分。

unix2datetime(x) -> DateTime

获取自 Unix 纪元1970-01-01T00:00:00以来的秒数，并将其转换为相应的DateTime。

datetime2unix(dt::DateTime) -> Float64

获取给定的DateTime，并返回自 Unix 纪元1970-01-01T00:00:00以来的秒数，以Float64形式表示。

julian2datetime(julian_days) -> DateTime

获取自儒略历纪元-4713-11-24T12:00:00以来的儒略日数，并返回相应的DateTime。

datetime2julian(dt::DateTime) -> Float64

获取给定的DateTime，并返回自儒略历纪元-4713-11-24T12:00:00以来的儒略日数，以Float64形式表示。

rata2datetime(days) -> DateTime

获取自纪元0000-12-31T00:00:00以来的 Rata Die 日数，并返回相应的DateTime。

datetime2rata(dt::TimeType) -> Int64

返回从给定的Date或DateTime开始，自纪元以来的 Rata Die 日数。

Dates.ISODateTimeFormat

描述日期和时间的 ISO8601 格式。这是DateTime的Dates.format的默认值。

示例

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

Dates.ISODateFormat

描述日期的 ISO8601 格式。这是Date的Dates.format的默认值。

示例

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

Dates.ISOTimeFormat

描述时间的 ISO8601 格式。这是Time的Dates.format的默认值。

示例

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

Dates.RFC1123Format

描述日期和时间的 RFC1123 格式。

示例

julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), RFC1123Format)
"Wed, 08 Aug 2018 12:00:43"