AnyMath 文档

日期

该 日期 模块提供了两种类型的日期工作: 日期和 日期时间，分别表示日精度和毫秒精度；两者都是抽象的子类型 时间表类型. 不同类型的动机很简单：有些操作在代码和心理推理方面都要简单得多，因为不必处理更高精度的复杂性。 例如，由于 日期类型仅解析为单个日期的精度（即没有小时，分钟或秒），时区，夏令时/夏令时和闰秒的正常考虑是不必要的，并且可以避免。

两者兼而有之 日期和 日期时间基本上是不可变的 Int64包装纸。 单身人士 即时 这两种类型的字段实际上是一个 UTInstant{P} 类型，它代表了一个基于UT第二脚注的不断增加的机器时间线：1[UT第二的概念实际上是相当基本的。 基本上有两种不同的时间概念被普遍接受，一种基于地球的物理旋转（一个完整的旋转=1天），另一种基于SI秒（一个固定的，恒定的值）。 这些完全不同！ 想想看，一个"UT秒"，作为相对于地球自转的定义，可能有一个不同的绝对长度取决于一天！ 不管怎么说，事实是 日期和 日期时间基于UT秒是一个简化但诚实的假设，这样就可以避免闰秒及其所有复杂性。 这个时间基础被正式称为https://en.wikipedia.org/wiki/Universal_Time[UT]或UT1。 基于UT秒的类型基本上意味着每分钟有60秒，每天有24小时，并且在使用日历日期时会导致更自然的计算。]. 该 日期时间type不知道时区（naive，用Python的说法），类似于Java8中的_LocalDateTime_。 额外的时区功能可以通过添加https://github.com/JuliaTime/TimeZones.jl/[TimeZones.jl包]，它编译https://www.iana.org/time-zones[IANA时区数据库]。 两者兼而有之 日期和 日期时间是根据https://en.wikipedia.org/wiki/ISO_8601[ISO8601]标准，其遵循proleptic公历。 值得注意的是，ISO8601标准特别关注BC/BCE日期。 一般来说，BC/BCE时代的最后一天，1-12-31BC/BCE，之后是1-1-1AD/CE，因此没有零年存在。 然而，ISO标准规定1BC/BCE是零年，因此 0000-12-31 是前一天吗 0001-01-01，及年份 -0001 （是的，负一年）是2BC/BCE，年 -0002 是3BC/BCE等。

构造函数

日期和 日期时间类型可以通过整数或 期间类型，通过解析，或通过调整器（稍后更多）:

julia> DateTime(2013)
2013-01-01T00:00:00

julia> DateTime(2013,7)
2013-07-01T00:00:00

julia> DateTime(2013,7,1)
2013-07-01T00:00:00

julia> DateTime(2013,7,1,12)
2013-07-01T12:00:00

julia> DateTime(2013,7,1,12,30)
2013-07-01T12:30:00

julia> DateTime(2013,7,1,12,30,59)
2013-07-01T12:30:59

julia> DateTime(2013,7,1,12,30,59,1)
2013-07-01T12:30:59.001

julia> Date(2013)
2013-01-01

julia> Date(2013,7)
2013-07-01

julia> Date(2013,7,1)
2013-07-01

julia> Date(Dates.Year(2013),Dates.Month(7),Dates.Day(1))
2013-07-01

朱莉娅>日期(日期.月(7),日期.年份(2013))
2013-07-01

日期或 日期时间解析是通过使用格式字符串来完成的。 格式字符串的工作原理是定义_delimited_或_fixed-width_"插槽"，这些插槽包含一个句点来解析和传递文本以解析和格式化字符串到 日期或 日期时间构造函数，形式 日期("2015-01-01",日期格式"y-m-d") 或 DateTime("20150101",dateformat"yyyy.adoc[]d"）.

分隔槽通过指定解析器在两个后续句点之间应该期望的分隔符来标记;所以 "y-m-d" 让解析器知道日期字符串中的第一个和第二个槽之间，如 "2014-07-16"，它应该找到 - 性格。 该 y, m，而 d 字符让解析器知道要在每个槽中解析哪些句点。

如上述构造函数的情况，如 日期(2013),分隔 数据格式s允许缺少日期和时间的部分，只要给出前面的部分。 其他部分被赋予通常的默认值。 例如, 日期("1981-03",日期格式"y-m-d") 申报表 1981-03-01，而 日期("31/12",日期格式"d/m/y") 给予 0001-12-31. （请注意，默认年份为1AD/CE。)然而，一个空字符串总是抛出一个 [医]争论者.

固定宽度槽是通过重复句号字符与宽度相对应的次数来指定的，而字符之间没有分隔符。 所以 数据格式"yyyymmdd" 将对应于一个日期字符串，如 "20140716". 解析器通过没有分隔符来区分固定宽度的槽，并注意到转换 "yyyymm" 从一个句点字符到下一个字符。

支持文本形式月解析也通过支持 u 和 U 字符，分别表示缩写和全长月份名称。 默认情况下，只支持英文月份名称，因此 u 对应于"Jan"，"Feb"，"Mar"等。 和 U 对应于"一月"，"二月"，"三月"等。 类似于其他名称=>值映射函数 姓名和 月名，自定义区域设置可以通过传入 区域设置=>Dict{String,Int} 映射到 N.月,月 和 每月,每月 分别缩写和全名月份名称的dicts。

上述例子使用 数据格式"" 字符串宏。 这个宏创建了一个 数据格式 对象一次，当宏展开，并使用相同的 数据格式 对象，即使代码段多次运行。

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

或者您可以显式创建DateFormat对象:

julia> df = DateFormat("y-m-d");

julia> dt = Date("2015-01-01",df)
2015-01-01

julia> dt2 = Date("2015-01-02",df)
2015-01-02

或者，使用广播:

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

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

为方便起见，您可以直接传递格式字符串（例如, 日期("2015-01-01","y-m-d")），虽然如果您重复解析相同的格式，则此表单会产生性能成本，因为它在内部创建了一个新的 数据格式 对象每次。

以及通过构造函数， 日期 或 日期时间 可以使用 解析,解析和 [医胰脏]函数，但具有可选的第三个类型参数 数据格式 指定格式；例如, 解析(日期,"06.23.2013",数据格式"m.d.y")，或 tryparse(日期时间,"1999-12-31t23:59:59") 它使用默认格式。 功能之间的显着区别在于，与 [医胰脏]，如果字符串为空或格式无效，则不会引发错误;相反 什么都没有 被退回。

兼容性

Julia1.9在Julia1.9之前，空字符串可以传递给构造函数和 解析,解析 没有错误，返回适当 日期时间(1), 日期(1) 或 时间(0). 同样, [医]胰脏 没有回来 什么都没有.

一整套解析和格式化测试和示例可在https://github.com/JuliaLang/julia/blob/master/stdlib/Dates/test/io.jl[脧锚脧赂`stdlib/日期/测试/io。jl`].

持续时间/比较

找到两个之间的时间长度 日期或 日期时间是直截了当的，因为它们的基本表示为 UTInstant{Day} 和 UTInstant{Millisecond}，分别。 之间的区别 日期以 日，和 日期时间在数量 毫秒. 同样，比较 时间表类型是比较底层机器实例的简单问题（反过来比较内部 Int64值）。

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

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

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

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

julia> dt > dt2
true

julia> dt != dt2
true

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

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

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

julia> dt - dt2
4411 days

julia> dt2 - dt
-4411 days

julia>dt=日期时间(2012,2,29)
2012-02-29T00：00：00

julia>dt2=日期时间(2000,2,1)
2000-02-01T00：00：00

朱莉娅>dt-dt2
381110400000毫秒

访问器功能

因为 日期和 日期时间类型存储为单个 Int64可以通过访问器函数检索值、日期部分或字段。 小写访问器将字段返回为整数:

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

julia> Dates.year(t)
2014

julia> Dates.month(t)
1

julia> Dates.week(t)
5

julia> Dates.day(t)
31

而propercase在相应的返回相同的值 期间类型:

julia> Dates.Year(t)
2014 years

julia> Dates.Day(t)
31 days

提供复合方法是因为在同一时间访问多个字段比单独访问更有效:

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

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

朱莉娅>日期.月日(t)
(2014, 1, 31)

人们也可以访问底层 UTInstant的 或整数值:

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

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

julia> Dates.value(t)
735264

查询函数

查询函数提供有关a的日历信息 时间表类型. 它们包括有关星期几的信息:

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

julia> Dates.dayofweek(t)
5

julia> Dates.dayname(t)
"Friday"

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

一年中的月份:

julia> Dates.monthname(t)
"January"

julia> Dates.daysinmonth(t)
31

以及有关 时间表类型的年份和季度:

julia> Dates.isleapyear(t)
false

朱莉娅>日期.年(t)
31

朱莉娅>日期.四分之一年(t)
1

朱莉娅>日期.第四节(t)
31

该 姓名和 月名方法也可以采用可选 区域设置 关键字，可用于返回其他语言/区域设置的一年中的日期或月份的名称。 这些函数也有返回缩写名称的版本，即 n.日,日和 月abc. 首先，映射被加载到 语言环境 变量:

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

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

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

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

然后可以使用上面提到的函数来执行查询:

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

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

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

由于没有加载日子的缩写版本，因此尝试使用该函数 n.日,日 会抛出错误。

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

时间表-周期算术

当使用任何语言/日期框架来熟悉如何处理日期周期算术时，这是一个很好的实践，因为有一些https://codeblog.jonskeet.uk/2010/12/01/the-joys-of-date-time-arithmetic/[棘手的问题]要处理（尽管对于日精度类型要少得多）。

该 日期 模块方法试图遵循简单的原则，即在做的时候尽量少改变 期间算术。 这种方法通常也被称为_calendrical_算术，或者如果有人在谈话中问你相同的计算，你可能会猜到什么。 为什么这么大惊小怪? 让我们举一个经典的例子：添加1个月到2014年1月31日。 答案是什么？ Javascript会说https://markhneedham.com/blog/2009/01/07/javascript-add-a-month-to-a-date/[3月3日]（假设31天）。 PHP说https://stackoverflow.com/questions/5760262/php-adding-months-to-a-date-while-not-exceeding-the-last-day-of-the-month[3月2日]（假设30天）。 事实是，没有正确的答案。 在 日期 模块，它给出了2月28日的结果。 它是怎么弄明白的？ 考虑经典7-7-7赌博游戏在赌场.

现在想象一下，插槽不是7-7-7，而是年-月-日，或者在我们的例子中，2014-01-31。 当您要求在此日期添加1个月时，月份槽会递增，因此现在我们有2014-02-31。 然后检查日数是否大于新月份的最后有效日;如果是（如上面的情况），则将日数向下调整到最后有效日（28）。 这种方法有什么后果？ 去吧，在我们的约会中再加上一个月, 2014-02-28+月份(1)==2014-03-28. 什么？ 你在等三月的最后一天吗? 不，对不起，记住7-7-7插槽。 尽可能少的插槽会改变，所以我们首先将月插槽增加1,2014-03-28，然后繁荣，我们完成了，因为这是一个有效的日期。 另一方面，如果我们要在原来的日期2014-01-31上增加2个月，那么我们最终会得到2014-03-31，正如预期的那样。 这种方法的另一个分支是当强制执行特定顺序时（即以不同的顺序添加事物会导致不同的结果）的关联性损失。 例如:

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

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

那里怎么了？ 在第一行中，我们在1月29日增加1天，结果是2014-01-30；然后我们增加1个月，所以我们得到2014-02-30，然后调整到2014-02-28。 在第二个例子中，我们添加1个月_first_，其中我们得到2014-02-29，它向下调整到2014-02-28，而_then_添加1天，结果是2014-03-01。 在这种情况下有帮助的一个设计原则是，在存在多个周期的情况下，操作将按周期的_types_排序，而不是它们的值或位置顺序;这意味着 年份 将始终首先添加，然后 月份，则 周 等。 因此，下面的_does_导致关联性并且只是起作用:

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

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

棘手？ 也许吧。 什么是无辜的 日期 用户要做什么？ 底线是要意识到，在处理月份时，明确地强制某种关联性可能会导致一些意想不到的结果，但除此之外，一切都应该按预期工作。 值得庆幸的是，在处理UT中的时间时，这几乎是日期周期算术中奇怪情况的程度（避免处理夏令时，闰秒等的"乐趣"）。).

作为奖励，所有周期算术对象都直接与范围一起工作:

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

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

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

julia> collect(dr)
7-element Vector{Date}:
 2014-01-29
 2014-02-28
 2014-03-29
 2014-04-29
 2014-05-29
 2014-06-29
 2014-07-29

调节器功能

与日期周期算术一样方便，通常日期所需的计算类型具有_calendrical_或_temporal_性质，而不是固定数量的周期。 假期是一个完美的例子;大多数遵循"阵亡将士纪念日=5月的最后一个星期一"或"感恩节=11月的第4个星期四"等规则。 这些类型的时间表达式处理与日历相关的规则，如每月的第一个或最后一个月，下周二，或第一个和第三个星期三等。

该 日期 模块通过几种方便的方法提供了_ADJUSTER_API，这些方法有助于简单简洁地表达时间规则。 第一组调整器方法处理周，月，季度和年的第一个和最后一个。 他们每人拿一张单 时间表类型作为输入并返回或_adjust to_相对于输入所需周期的第一个或最后一个。

julia> Dates.firstdayofweek(Date(2014,7,16)) # Adjusts the input to the Monday of the input's week
2014-07-14

julia> Dates.lastdayofmonth(Date(2014,7,16)) # Adjusts to the last day of the input's month
2014-07-31

julia> Dates.lastdayofquarter(Date(2014,7,16)) # Adjusts to the last day of the input's quarter
2014-09-30

接下来的两个高阶方法, [医托尼文]，和 托普雷夫，通过取一个泛化处理时态表达式 数据功能 作为第一个参数，以及一个开始 时间表类型. A 数据功能 只是一个函数，通常是匿名的，它需要一个 时间表类型作为输入并返回一个 布尔, 真的 表示满足的调整准则。 例如:

julia> istuesday = x->Dates.dayofweek(x) == Dates.Tuesday; # Returns true if the day of the week of x is Tuesday

julia> Dates.tonext(istuesday, Date(2014,7,13)) # 2014-07-13 is a Sunday
2014-07-15

julia> Dates.tonext(Date(2014,7,13), Dates.Tuesday) # Convenience method provided for day of the week adjustments
2014-07-15

这对于更复杂的时态表达式的do-block语法很有用:

julia> Dates.tonext(Date(2014,7,13)) do x
           # Return true on the 4th Thursday of November (Thanksgiving)
           Dates.dayofweek(x) == Dates.Thursday &&
           Dates.dayofweekofmonth(x) == 4 &&
           Dates.month(x) == Dates.November
       end
2014-11-27

该 基地。过滤器方法可用于获取指定范围内的所有有效日期/时刻:

# Pittsburgh street cleaning; Every 2nd Tuesday from April to November
# Date range from January 1st, 2014 to January 1st, 2015
julia> dr = Dates.Date(2014):Day(1):Dates.Date(2015);

julia> filter(dr) do x
           Dates.dayofweek(x) == Dates.Tue &&
           Dates.April <= Dates.month(x) <= Dates.Nov &&
           Dates.dayofweekofmonth(x) == 2
       end
8-element Vector{Date}:
 2014-04-08
 2014-05-13
 2014-06-10
 2014-07-08
 2014-08-12
 2014-09-09
 2014-10-14
 2014-11-11

其他示例和测试可在https://github.com/JuliaLang/julia/blob/master/stdlib/Dates/test/adjusters.jl[脧锚脧赂`stdlib/日期/测试/调整器。jl`].

期间类型

周期是人类对离散的，有时是不规则的时间持续时间的看法。 考虑1个月；根据年份和月份的上下文，它可以表示28、29、30或31的值（以天为单位）。 或者在闰年的情况下，一年可以代表365或366天。 期间类型很简单 Int64包装器，并通过包装任何构造 Int64 可转换类型，即 年份(1) 或 月份(3.0). 之间的算术 期间相同类型的行为像整数，并且有限 期-实 算术是可用的。 您可以使用以下方法提取底层整数 日期。价值.

julia> y1 = Dates.Year(1)
1 year

朱莉娅>y2=日期.年份(2)
2年

朱莉娅>y3=日期。年份(10)
10年

朱莉娅>y1+y2
3年

朱莉娅>div(y3,y2)
5

朱莉娅>y3-y2
8年

朱莉娅>y3%y2
0年

julia>div(y3,3)#镜像整数除法
3年

朱莉娅>日期.值（日期。毫秒(10))
10

表示不是基本类型的整数倍的周期或持续时间可以用 日期。复合周期类型。 复合周期可以从简单的手工构建 期间类型。 此外， 规范化,规范化函数可以用来把一个句点分解成一个 日期。复合周期. 这对于转换持续时间特别有用，例如，差值为2 日期时间，成更方便的表示。

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

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

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

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

四舍五入

日期和 日期时间值可以四舍五入到指定的分辨率（例如，1个月或15分钟） 楼层, 齐尔，或 圆形:

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

julia>ceil(日期时间(2013, 2, 13, 0, 31, 20), 日期。分钟(15))
2013-02-13T00：45：00

julia>round(日期时间(2016, 8, 6, 20, 15), 日期。日）
2016-08-07T00：00：00

与数字不同 圆形方法，默认情况下打破对偶数的联系， 时间表类型圆形方法使用 RoundNearestTiesUp 舍入模式。 （很难猜测是什么打破了与最近的"偶数"的联系 时间表类型 这就需要了。)可供选择的进一步详情 圆模/圆模 s可在 xref:stdlib/Dates.adoc#stdlib-dates-api[API参考。

四舍五入通常应符合预期，但在某些情况下，预期的行为并不明显。

四舍五入时代

在许多情况下，为四舍五入指定的分辨率（例如, 日期。第二(30)）平均分为下一个最大周期（在这种情况下, 日期。分钟(1)). 但是，在这种情况下，舍入行为可能会导致混淆。 四舍五入a的预期结果是什么 xref:stdlib/Dates.adoc#Dates.DateTime[日期时间 到最近的10小时？

julia> round(DateTime(2016, 7, 17, 11, 55), Dates.Hour(10))
2016-07-17T12:00:00

考虑到小时（12）不能被10整除，这似乎令人困惑。 原因是 2016-07-17T12：00：00 被选择的是，它是17,676,660小时后 0000-01-01T00：00：00，而17,676,660可被10整除。

作为朱莉娅 日期和 日期时间值根据ISO8601标准表示, 0000-01-01T00：00：00 被选为基数（或"舍入纪元"），从中开始舍入计算中使用的天数（和毫秒）。 （请注意，这与Julia的内部表示略有不同 日期使用https://en.wikipedia.org/wiki/Rata_Die[Rata Die notation];但由于ISO8601标准对最终用户最明显, 0000-01-01T00：00：00 被选为四舍五入时代，而不是 0000-12-31T00：00：00 内部使用，以尽量减少混乱。)

使用的唯一例外 0000-01-01T00：00：00 由于四舍五入时代是四舍五入到周。 四舍五入到最近的一周将始终返回一个星期一（iso8601指定的一周的第一天）。 出于这个原因，我们使用 0000-01-03T00：00：00 （ISO8601定义的0000年第一周的第一天）作为四舍五入到周数时的基数。

下面是一个相关的案例，其中预期的行为不一定是显而易见的：当我们四舍五入到最近的时候会发生什么 P(2)，在哪里 P 是一个 期间类型？ 在某些情况下（具体而言，当 P<：日期。时间周期 答案很清楚:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Hour(2))
2016-07-17T08:00:00

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Minute(2))
2016-07-17T08:56:00

这似乎是显而易见的，因为这些时段中的每个时段中的两个仍然平均分成下一个更大的顺序时段。 但在两个月的情况下（仍然平均分为一年），答案可能令人惊讶:

julia> round(DateTime(2016, 7, 17, 8, 55, 30), Dates.Month(2))
2016-07-01T00:00:00

为什么轮到七月的第一天，即使它是第7个月（奇数）？ 关键是月份是1索引的（第一个月被分配为1），而不是小时，分钟，秒和毫秒（其中第一个被分配为0）。

这意味着四舍五入a 日期时间秒、分钟、小时或年的偶数倍（因为ISO8601规范包括零年）将导致 日期时间在该字段中具有偶数值，同时舍入a 日期时间到月的偶数倍将导致月字段具有奇数值。 由于月份和年份都可能包含不规则的天数，因此舍入到偶数天数是否会导致"天"字段中的偶数值不确定。

查看 API参考有关从 日期 模块。

空气污染指数参考

日期和时间类型

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

期间 类型表示时间的离散的人类表示。

CompoundPeriod

A 复合周期 对于表示不是较小周期的固定倍数的时间段是有用的。 例如，"一年一天"不是一个固定的天数，而是可以用一个 复合周期. 事实上，一个 复合周期 通过添加不同的周期类型自动生成，例如 年(1)+日(1) 产生一个 复合周期 结果。

Instant

即时 类型将基于整数的时间机器表示为从一个时代开始的连续时间线。

UTInstant{T}

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

TimeType

时间表类型 类型包装 即时 机器实例提供机器即时的人类表示. 时间, 日期时间 和 日期 是亚型的 时间表类型.

DateTime

日期时间 表示根据proleptic公历的时间点。 时间的最佳分辨率是毫秒（即，微秒或纳秒不能用这种类型表示）。 该类型支持定点算术，因此容易出现下溢（和溢出）。 一个显着的结果是四舍五入时添加一个 微秒 或一个 纳秒级:

julia> dt = DateTime(2023, 8, 19, 17, 45, 32, 900)
2023-08-19T17:45:32.900

julia> dt + Millisecond(1)
2023-08-19T17:45:32.901

julia> dt + Microsecond(1000) # 1000us == 1ms
2023-08-19T17:45:32.901

julia> dt + Microsecond(999) # 999us rounded to 1000us
2023-08-19T17:45:32.901

julia> dt + Microsecond(1499) # 1499 rounded to 1000us
2023-08-19T17:45:32.901
Date

日期 包装a UTInstant{Day} 并根据proleptic公历解释它。

Time

时间 包装a 纳秒级 并表示24小时一天中的特定时刻。

TimeZone

地理区域一般基于经度确定在某个位置的时间。 一些时区观察夏令时（例如EST->EDT）。 有关实现和更多支持，请参阅https://github.com/JuliaTime/TimeZones.jl[脧锚脧赂`时区。jl`]包装

UTC

协调世界时，或协调世界时，是 时区从中测量所有其他人。 它与经度0°处的时间相关联。 它不适用于夏令时。

日期及功能

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

建造一个 日期时间 按零件类型。 参数必须可转换为 Int64.

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

构建一个 日期时间 类型： 期间 型部件。 参数可以是任何顺序。 未提供的日期时间部分将默认为 日期。违约(期间).

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

创建一个 日期时间 通过调整器API。 起点将从提供的 y，m，d。.. 参数，并将被调整，直到 f::功能 申报表 真的. 在调整的步长可以通过手动提供 步骤 关键字。 限额 为调整API在抛出错误之前将追求的最大迭代次数提供限制（在以下情况下 f::功能 永远不会满足）。

*例子*

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

转换a 日期 到一个 日期时间. 新的小时、分钟、秒和毫秒部分 日期时间 都假定为零。

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

构建一个 日期时间 通过解析 dt的 日期时间字符串遵循 格式 字符串（见 数据格式为语法）。

注意此方法创建一个 数据格式 对象每次被调用。 建议您创建一个 数据格式对象，并将其用作第二个参数，以避免重复使用相同格式时性能损失。

*例子*

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

通过使用构造字符串 时间表类型 对象并应用所提供的 格式. 以下字符代码可用于构造 格式 字符串:

密码 例子： 评论

y

6

具有固定宽度的数字年份

Y

1996

具有最小宽度的数字年份

m

1, 12

最小宽度的数字月份

u

一月

根据 区域设置

U

一月

完整的月份名称根据 区域设置 关键字

d

1, 31

最小宽度的月份日

H

0, 23

小时(24小时制)，最小宽度

M

0, 59

最小宽度的分钟

S

0, 59

第二个最小宽度

s

000, 500

毫秒，最小宽度为3

e

星期一,星期二

一周的缩写日

E

星期一

全日的星期名称

顺序代码字符的数量表示代码的宽度。 的格式 yyyy-mm 指定代码 y 应该有四个同时的宽度 m 二的宽度。 产生数字的代码有一个关联的模式:固定宽度或最小宽度. 固定宽度模式在小于指定宽度时用零填充值，在较长时截断值。 最小宽度模式的工作原理与固定宽度相同，只是它不会截断大于宽度的值。

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

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

构造可用于解析日期字符串或将日期对象格式化为字符串的日期格式化对象。 以下字符代码可用于构造 格式 字符串:

密码 比赛 评论

Y

1996, 96

申报年份1996,0096

y

1996, 96

同为 Y 上 解析,解析 但丢弃多余的数字 格式

m

1, 01

匹配1或2位数字月份

u

一月

根据 区域设置 关键字

U

一月

根据 区域设置 关键字

d

1, 01

匹配1或2位数的天数

H

00

比赛时间(24小时制)

我

00

用于以12小时制输出小时

M

00

比赛分钟

S

00

匹配秒数

s

.500

匹配毫秒

e

星期一，星期二

匹配缩短的星期几

E

星期一

匹配全名星期几

p

我

匹配AM/PM（不区分大小写）

yyyymmdd

19960101

匹配固定宽度的年、月和日

上面没有列出的字符通常被视为日期和时间间隔之间的分隔符。 例如a dt的 字符串"1996-01-15T00:00:00.0"将有一个 格式 像"y-m-dTH:M:S.s"这样的字符串。 如果您需要使用一个代码字符作为分隔符，您可以使用反斜杠转义它。 日期"1995y01m"的格式为"y\ym\m"。

请注意，12:00am对应00:00（午夜），12:00pm对应12:00（中午）。 当用一个 p 说明者，任何时间（要么 H 或 我）被解释为12小时制，因此 我 代码主要用于输出。

创建DateFormat对象的成本很高。 只要有可能，创建一次并多次使用它或尝试 数据格式""字符串宏。 使用此宏在宏扩展时创建一次DateFormat对象，并在以后重用它。 还有几个 预先定义的格式化程序，后面列出。

见 日期时间和 格式关于如何使用DateFormat对象分别解析和写入日期字符串。

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

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

见 数据格式有关格式说明符的详细信息。

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

构建一个 日期时间 通过解析 dt的 日期时间字符串遵循 数据格式对象，或dateformat"yyyy-mm-dd\THH:MM:SS。s"如果省略。

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

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

构建一个 日期 按零件类型。 参数必须可转换为 Int64.

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

建造一个 日期 类型： 期间 型部件。 参数可以是任何顺序。 日期 未提供的部件将默认为 日期。违约(期间).

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

创建一个 日期 通过调整器API。 起点将从提供的 y，m，d 参数，并将被调整，直到 f::功能 申报表 真的. 在调整的步长可以通过手动提供 步骤 关键字。 限额 为调整API在抛出错误之前将追求的最大迭代次数提供限制（给定 f::功能 永远不会满足）。

*例子*

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

转换a 日期时间 到一个 日期. 小时、分钟、秒和毫秒部分 日期时间 被截断，因此在建筑中只使用年、月、日部分。

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

构建一个 日期 通过解析 d 日期字符串遵循 格式 字符串（见 数据格式为语法）。

注意此方法创建一个 数据格式 对象每次被调用。 建议您创建一个 数据格式对象，并将其用作第二个参数，以避免重复使用相同格式时性能损失。

*例子*

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

构建一个 日期 通过解析 d 日期字符串遵循 数据格式对象，或dateformat"yyyy-mm-dd"如果省略。

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

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

建造一个 时间 按零件类型。 参数必须可转换为 Int64.

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

建造一个 时间 类型： 期间 型部件。 参数可以是任何顺序。 时间 未提供的部件将默认为 日期。违约(期间).

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

创建一个 时间 通过调整器API。 起点将从提供的 h，mi，s，ms，us 参数，并将被调整，直到 f::功能 申报表 真的. 在调整的步长可以通过手动提供 步骤 关键字。 限额 为调整API在抛出错误之前将追求的最大迭代次数提供限制（在以下情况下 f::功能 永远不会满足）。 请注意，默认步骤将调整为允许给定参数的更高精度;即如果提供了小时，分钟和秒参数，则默认步骤将为 毫秒(1) 而不是 第二(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

转换a 日期时间 到一个 时间. 小时、分钟、秒和毫秒部分 日期时间 用于创建新的 时间. 微秒和纳秒默认为零。

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

构建一个 时间 通过解析 t 时间字符串遵循的模式在 格式 字符串（见 数据格式为语法）。

注意此方法创建一个 数据格式 对象每次被调用。 建议您创建一个 数据格式对象，并将其用作第二个参数，以避免重复使用相同格式时性能损失。

*例子*

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

构建一个 时间 通过解析 t 日期时间字符串遵循 数据格式对象，或dateformat"HH:MM:SS。s"如果省略。

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

now() -> DateTime

返回a 日期时间 对应于用户的系统时间，包括系统时区区域设置。

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

返回a 日期时间 对应用户的系统时间为UTC/GMT。 有关其他时区，请参阅时区。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

返回支持的最小单位值 时间表类型.

*例子*

julia> eps(DateTime)
1 millisecond

julia> eps(Date)
1 day

julia> eps(Time)
1 nanosecond

访问器功能

year(dt::TimeType) -> Int64

A年 日期 或 日期时间 作为一个 Int64.

month(dt::TimeType) -> Int64

一个月 日期 或 日期时间 作为一个 Int64.

week(dt::TimeType) -> Int64

归还https://en.wikipedia.org/wiki/ISO_week_date[ISO周日期] 日期 或 日期时间 作为一个 Int64. 请注意，一年的第一周是包含一年的第一个星期四的一周，这可能导致1月4日之前的日期是上一年的最后一周。 例如, 周(日期(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

一个月的一天 日期 或 日期时间 作为一个 Int64.

hour(dt::DateTime) -> Int64

一天中的一小时 日期时间 作为一个 Int64.

hour(t::Time) -> Int64

一小时 时间 作为一个 Int64.

minute(dt::DateTime) -> Int64

一分钟 日期时间 作为一个 Int64.

minute(t::Time) -> Int64

一分钟 时间 作为一个 Int64.

second(dt::DateTime) -> Int64

第二个 日期时间 作为一个 Int64.

second(t::Time) -> Int64

第二个 时间 作为一个 Int64.

millisecond(dt::DateTime) -> Int64

一毫秒 日期时间 作为一个 Int64.

millisecond(t::Time) -> Int64

一毫秒 时间 作为一个 Int64.

microsecond(t::Time) -> Int64

一个微秒 时间 作为一个 Int64.

nanosecond(t::Time) -> Int64

A的纳秒 时间 作为一个 Int64.

Year(v)

构建一个 年份 与给定的对象 v 价值。 输入必须无损地转换为 Int64.

Month(v)

建造一个 月份 与给定的对象 v 价值。 输入必须无损地转换为 Int64.

Week(v)

建造一个 周 与给定的对象 v 价值。 输入必须无损地转换为 Int64.

Day(v)

建造一个 日 与给定的对象 v 价值。 输入必须无损地转换为 Int64.

Hour(dt::DateTime) -> Hour

日期时间的小时部分作为 时间.

Minute(dt::DateTime) -> Minute

日期时间的分钟部分作为 分钟.

Second(dt::DateTime) -> Second

日期时间的第二部分作为 第二.

Millisecond(dt::DateTime) -> Millisecond

数据时间的毫秒部分作为 毫秒.

Microsecond(dt::Time) -> Microsecond

一个时间的微秒部分作为一个 微秒.

Nanosecond(dt::Time) -> Nanosecond

一个时间的纳秒部分作为一个 纳秒级.

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

同时返回a的年和月部分 日期 或 日期时间.

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

同时返回a的月和日部分 日期 或 日期时间.

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

同时返回a的年、月、日部分 日期 或 日期时间.

查询函数

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

返回与 日期 或 日期时间 在给定的 区域设置. 也接受 整数.

*例子*

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

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

返回与 日期 或 日期时间 在给定的 区域设置. 也接受 整数.

*例子*

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

一个月的一天 日期 或 日期时间 作为一个 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

返回该月份的全名 日期 或 日期时间 或 整数 在给定的 区域设置.

*例子*

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

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

返回缩写的月份名称 日期 或 日期时间 或 整数 在给定的 区域设置.

*例子*

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

朱莉娅>daysinmonth(日期("2000-02"))
29
isleapyear(dt::TimeType) -> Bool

回来吧 真的 如果年 dt的 是闰年。

*例子*

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

julia> isleapyear(Date("2005"))
false
dayofyear(dt::TimeType) -> Int

返回一年中的一天 dt的 1月1日是第一天。

daysinyear(dt::TimeType) -> Int

返回366如果年份 dt的 是闰年，否则返回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

截断的值 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的 到对应于一周的第二天 道琼斯指数 与 1=星期一，2=星期二等. 设置 同=真 允许当前 dt的 被认为是下一个 道琼斯指数，允许不发生调整。

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

调整 dt的 至星期前一日 道琼斯指数 与 1=星期一，2=星期二等. 设置 同=真 允许当前 dt的 被视为前 道琼斯指数，允许不发生调整。

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

调整 dt的 到第一 道琼斯指数 它的月份。 或者, of=年份 将调整到第一 道琼斯指数 这一年。

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

调整 dt的 到最后 道琼斯指数 它的月份。 或者, of=年份 会调整到最后 道琼斯指数 这一年。

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

调整 dt的 通过最多迭代 限额 迭代 步骤 递增直至 [医]func 申报表 真的. [医] 必须采取单 时间表类型 参数和返回a 布尔. 同 允许 dt的 要考虑在满足 [医]func.

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

调整 dt的 通过最多迭代 限额 迭代 步骤 递增直至 [医] 申报表 真的. [医]func 必须采取单 时间表类型 参数和返回a 布尔. 同 允许 dt的 要考虑在满足 [医]func.

期间

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

建造一个 期间 输入给定的 v 价值。 输入必须无损地转换为 Int64.

CompoundPeriod(periods) -> CompoundPeriod

构建一个 复合周期 从一个 向量资料 的 期间s.全部 期间相同类型的s将被加在一起。

*例子*

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

减少 复合周期 通过应用以下规则进入其规范形式:

*任何 期间 足够大，可以用粗糙的部分表示 期间 会被分解成多个 期间s（例如。 小时(30) 成为 日(1)+小时(6)) * 期间具有相反符号的s将在可能的情况下组合（例如。 小时(1)-天(1) 成为 -小时(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

对于给定周期，返回与该周期关联的值。 例如, 值(毫秒(10)) 返回10作为整数。

default(p::Period) -> Period

通过返回为输入周期返回一个合理的"默认"值 T(1) 年、月、日，以及 T(0) 小时、分钟、秒和毫秒。

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

归还 向量资料 的 期间组成给定的 复合周期.

兼容性

Julia1.7此功能需要Julia1.7或更高版本。

舍入函数

日期 和 日期时间 值可以四舍五入到指定的分辨率（例如，1个月或15分钟） 楼层, 齐尔，或 圆形.

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

返回最近的 日期 或 日期时间 小于或等于 dt的 经决议 p.

为方便起见, p 可能是类型而不是值: 地板（dt，日期。小时) 是一条捷径。 地板（dt，日期。小时(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.

为方便起见, p 可能是类型而不是值: ceil（dt，日期。小时) 是一条捷径。 ceil（dt，日期。小时(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. 默认情况下（RoundNearestTiesUp），领带（例如，将9:30四舍五入到最近的小时）将被四舍五入。

为方便起见, p 可能是类型而不是值: 圆形（dt，日期。小时) 是一条捷径。 圆形（dt，日期。小时(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 (默认), 四舍五入 (楼层），以及 综述 (齐尔).

最 期间 值也可以四舍五入到指定的分辨率:

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

圆形 x 下降到最接近的倍数 精密度. 如果 x 和 精密度 是不同的亚型 期间，返回值将具有与 精密度.

为方便起见, 精密度 可能是类型而不是值: 地板（x，日期。小时) 是一条捷径。 地板（x，日期。小时(1)).

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

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

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

四舍五入到 精密度 的 月份s或 年份不支持s，因为这些 期间s的长度不一致。

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

圆形 x 最接近的倍数 精密度. 如果 x 和 精密度 是不同的亚型 期间，返回值将具有与 精密度.

为方便起见, 精密度 可能是类型而不是值: ceil（x，日期。小时) 是一条捷径。 ceil（x，日期。小时(1)).

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

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

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

四舍五入到 精密度 的 月份s或 年份不支持s，因为这些 期间s的长度不一致。

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

圆形 x 到最接近的倍数 精密度. 如果 x 和 精密度 是不同的亚型 期间，返回值将具有与 精密度. 默认情况下（RoundNearestTiesUp），领带（例如，将90分钟舍入到最近的小时）将被四舍五入。

为方便起见, 精密度 可能是类型而不是值: 圆（x，日期。小时) 是一条捷径。 圆（x，日期。小时(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 (默认), 四舍五入 (楼层），以及 综述 (齐尔).

四舍五入到 精密度 的 月份s或 年份不支持s，因为这些 期间s的长度不一致。

以下函数不会导出:

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

同时返回 楼层 和 齐尔 一个 日期 或 日期时间 经决议 p. 比两者都调用更有效率 楼层 和 齐尔 单独地。

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

同时返回 楼层 和 齐尔 的 期间 经决议 p. 比两者都调用更有效率 楼层 和 齐尔 单独地。

epochdays2date(days) -> Date

取自四舍五入时代以来的天数（0000-01-01T00：00：00）并返回相应的 日期.

epochms2datetime(milliseconds) -> DateTime

取自舍入epoch以来的毫秒数（0000-01-01T00：00：00）并返回相应的 日期时间.

date2epochdays(dt::Date) -> Int64

拿给定的 日期 并返回自四舍五入epoch以来的天数（0000-01-01T00：00：00）作为一个 Int64.

datetime2epochms(dt::DateTime) -> Int64

拿给定的 日期时间 并返回自舍入epoch以来的毫秒数（0000-01-01T00：00：00）作为一个 Int64.

转换函数

today() -> Date

返回的日期部分 现在（）.

unix2datetime(x) -> DateTime

取自unix epoch以来的秒数 1970-01-01T00：00：00 并转换为相应的 日期时间.

datetime2unix(dt::DateTime) -> Float64

拿给定的 日期时间 并返回自unix时代以来的秒数 1970-01-01T00：00：00 作为一个 漂浮64.

julian2datetime(julian_days) -> DateTime

取自历元以来的儒略历日数 -4713-11-24T12：00：00 并返回相应的 日期时间.

datetime2julian(dt::DateTime) -> Float64

拿给定的 日期时间 并返回自儒略时代以来的儒略历天数 -4713-11-24T12：00：00 作为一个 漂浮64.

rata2datetime(days) -> DateTime

取自epoch以来的Rata Die天数 0000-12-31T00：00：00 并返回相应的 日期时间.

datetime2rata(dt::TimeType) -> Int64

返回自给定时代以来的Rata死亡天数 日期 或 日期时间.

常量

星期几:

变量 阿布尔。 值(Int)

星期一

星期一

1

星期二

星期二

2

星期三

星期三

3

星期四

星期四

4

星期五

星期五

5

星期六

星期六

6

星期日

太阳

7

一年中的几个月:

变量 阿布尔。 值(Int)

一月

一月

1

二月

2月

2

三月

三月

3

四月

四月

4

五月

五月

5

六月

君

6

七月份

7月

7

八月份

8月

8

9月

九月

9

10月

10月

10

11月

11月

11

12月

12月

12

常用日期格式化程序

Dates.ISODateTimeFormat

描述日期和时间的ISO8601格式。 这是默认值 日期。格式 一个 日期时间.

*例子*

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

描述日期的ISO8601格式。 这是默认值 日期。格式 一个 日期.

*例子*

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

描述了一段时间的ISO8601格式。 这是默认值 日期。格式 一个 时间.

*例子*

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"