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 的寬度應為四，而 m 的寬度應為二。產生數字的代碼具有關聯模式：固定寬度或最小寬度。固定寬度模式在值短於指定寬度時，會在值左側補零，而在值較長時會將值截斷。最小寬度模式與固定寬度模式相同，但不會截斷長於寬度的值。

在建立 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」的 dt 字串將會有類似「y-m-dTH:M:S.s」的 format 字串。如果您需要使用碼字元作為分隔符，可以使用反斜線進行跳脫。日期「1995y01m」將會有「y\ym\m」的格式。

請注意，上午 12:00 對應到 00:00（午夜），下午 12:00 對應到 12:00（正午）。使用 p 規格符號解析時間時，任何小時（H 或 I）都將解釋為 12 小時制，因此 I 碼主要用於輸出。

建立一個 DateFormat 物件很昂貴。只要有可能，建立一次並多次使用，或嘗試使用 dateformat"" 字串巨集。使用這個巨集會在巨集擴充時間建立 DateFormat 物件一次，並在稍後重複使用。還有幾個 預先定義的格式化器，稍後列出。

請參閱 DateTime 和 format，瞭解如何分別使用 DateFormat 物件來解析和寫入日期字串。

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 日期時間字串，或在省略時為 dateformat"yyyy-mm-dd\THH:MM:SS.s"，來建構一個 DateTime。

類似於 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 物件中指定的模式，或省略時為 dateformat"yyyy-mm-dd"，解析 d 日期字串來建構 Date。

類似於 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，如果省略則為 dateformat"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

傳回與 Date 或 DateTime 的星期幾對應的完整星期名稱，以指定的 locale 為準。也接受 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

傳回一個 1 = 星期一，2 = 星期二，等等 的 Int64 週日期。

範例

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

調整 dt，最多重複 limit 次，每次遞增 step，直到 func 傳回 true。func 必須接收單一 TimeType 參數，並傳回 Bool。same 允許 dt 滿足 func。

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

調整 dt，最多重複 limit 次，每次遞增 step，直到 func 傳回 true。func 必須接收單一 TimeType 參數，並傳回 Bool。same 允許 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 值建構 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

傳回輸入時間段的合理「預設」值，其中 T(1) 會傳回年、月和日，而 T(0) 會傳回小時、分鐘、秒和毫秒。

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

傳回組成給定 CompoundPeriod 的 Period 的 Vector。

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

傳回解析度為 p 時小於或等於 dt 的最近 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

傳回解析度為 p 時大於或等於 dt 的最近 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 的 Date 或 DateTime，解析度為 p。預設（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)

同時傳回解析度為 p 的 Date 或 DateTime 的 floor 和 ceil。比個別呼叫 floor 和 ceil 更有效率。

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

同時傳回解析度為 p 的 Period 的 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，並以 Int64 傳回自捨入基準時間 (0000-01-01T00:00:00) 以來的日數。

datetime2epochms(dt::DateTime) -> Int64

取得指定的 DateTime，並以 Int64 傳回自捨入基準時間 (0000-01-01T00:00:00) 以來的毫秒數。

today() -> Date

傳回 now() 的日期部分。

unix2datetime(x) -> DateTime

取得自 Unix 基準時間 1970-01-01T00:00:00 以來的秒數，並轉換為對應的 DateTime。

datetime2unix(dt::DateTime) -> Float64

取得指定的 DateTime，並以 Float64 傳回自 Unix 基準時間 1970-01-01T00:00:00 以來的秒數。

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"