@spec add(
  Calendar.naive_datetime(),
  integer(),
  :day | :hour | :minute | System.time_unit()
) :: t()

将指定的时间量添加到 NaiveDateTime 中。

接受任何 unit 中的 amount_to_add。 unit 可以是 :day、:hour、:minute、:second 或来自 System.time_unit/0 的任何亚秒精度。它默认为 :second。负值将向时间后退。

此函数始终认为单位是根据 Calendar.ISO 计算的。

示例

它默认使用秒

# adds seconds by default
iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2)
~N[2014-10-02 00:29:12]

# accepts negative offsets
iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], -2)
~N[2014-10-02 00:29:08]

它也可以与亚秒精度一起使用

iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2_000, :millisecond)
~N[2014-10-02 00:29:12.000]

以及天/小时/分钟

iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 2, :day)
~N[2015-03-02 00:29:10]
iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 36, :hour)
~N[2015-03-01 12:29:10]
iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 60, :minute)
~N[2015-02-28 01:29:10]

此操作将 NaiveDateTime 的精度与给定单位合并

iex> result = NaiveDateTime.add(~N[2014-10-02 00:29:10], 21, :millisecond)
~N[2014-10-02 00:29:10.021]
iex> result.microsecond
{21000, 3}

对格里高利秒或 Unix 纪元的操作经过优化

# from Gregorian seconds
iex> NaiveDateTime.add(~N[0000-01-01 00:00:00], 63_579_428_950)
~N[2014-10-02 00:29:10]

传递 DateTime 会自动将其转换为 NaiveDateTime，并丢弃时区信息

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> NaiveDateTime.add(dt, 21, :second)
~N[2000-02-29 23:00:28]

@spec after?(Calendar.naive_datetime(), Calendar.naive_datetime()) :: boolean()

如果第一个 NaiveDateTime 严格晚于第二个，则返回 true。

示例

iex> NaiveDateTime.after?(~N[2022-02-02 11:00:00], ~N[2021-01-01 11:00:00])
true
iex> NaiveDateTime.after?(~N[2021-01-01 11:00:00], ~N[2021-01-01 11:00:00])
false
iex> NaiveDateTime.after?(~N[2021-01-01 11:00:00], ~N[2022-02-02 11:00:00])
false

@spec before?(Calendar.naive_datetime(), Calendar.naive_datetime()) :: boolean()

如果第一个 NaiveDateTime 严格早于第二个，则返回 true。

示例

iex> NaiveDateTime.before?(~N[2021-01-01 11:00:00], ~N[2022-02-02 11:00:00])
true
iex> NaiveDateTime.before?(~N[2021-01-01 11:00:00], ~N[2021-01-01 11:00:00])
false
iex> NaiveDateTime.before?(~N[2022-02-02 11:00:00], ~N[2021-01-01 11:00:00])
false

@spec beginning_of_day(Calendar.naive_datetime()) :: t()

计算一个 NaiveDateTime，它是给定 NaiveDateTime 的第一个时刻。

要计算 DateTime 的一天开始时间，请调用此函数，然后转换回 DateTime

datetime
|> NaiveDateTime.beginning_of_day()
|> DateTime.from_naive(datetime.time_zone)

请注意，一天的开始时间可能在给定时区中不存在或不明确，因此您必须相应地处理这些情况。

示例

iex> NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07.123456])
~N[2000-01-01 00:00:00.000000]

@spec compare(Calendar.naive_datetime(), Calendar.naive_datetime()) :: :lt | :eq | :gt

比较两个 NaiveDateTime 结构体。

如果第一个晚于第二个，则返回 :gt，反之亦然。如果两个 NaiveDateTime 相等，则返回 :eq。

示例

iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15], ~N[2016-04-28 16:19:25])
:lt
iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15.1], ~N[2016-04-16 13:30:15.01])
:gt

此函数也可以用于比较没有时区信息的 DateTime

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> NaiveDateTime.compare(dt, ~N[2000-02-29 23:00:07])
:eq
iex> NaiveDateTime.compare(dt, ~N[2000-01-29 23:00:07])
:gt
iex> NaiveDateTime.compare(dt, ~N[2000-03-29 23:00:07])
:lt

@spec convert(Calendar.naive_datetime(), Calendar.calendar()) ::
  {:ok, t()} | {:error, :incompatible_calendars}

将给定的 naive_datetime 从一个日历转换为另一个日历。

如果无法在日历之间进行明确转换（见 Calendar.compatible_calendars?/2），则返回一个 {:error, :incompatible_calendars} 元组。

示例

想象一下，有人实现了 Calendar.Holocene，一个基于格里高利日历的日历，它在当前的格里高利年份上增加了整整 10,000 年

iex> NaiveDateTime.convert(~N[2000-01-01 13:30:15], Calendar.Holocene)
{:ok, %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
                     hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}

@spec convert!(Calendar.naive_datetime(), Calendar.calendar()) :: t()

将给定的 naive_datetime 从一个日历转换为另一个日历。

如果无法在日历之间进行明确转换（见 Calendar.compatible_calendars?/2），则会引发 ArgumentError。

示例

想象一下，有人实现了 Calendar.Holocene，一个基于格里高利日历的日历，它在当前的格里高利年份上增加了整整 10,000 年

iex> NaiveDateTime.convert!(~N[2000-01-01 13:30:15], Calendar.Holocene)
%NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
               hour: 13, minute: 30, second: 15, microsecond: {0, 0}}

@spec diff(
  Calendar.naive_datetime(),
  Calendar.naive_datetime(),
  :day | :hour | :minute | System.time_unit()
) :: integer()

diff(naive_datetime1, naive_datetime2, unit \\ :second)

答案可以用任何 :day、:hour、:minute 或来自 System.time_unit/0 的任何 unit 返回。该单位是根据 Calendar.ISO 测量的，默认为 :second。

不支持小数结果，并将其截断。

示例

iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10])
2
iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10], :microsecond)
2_000_000

iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021])
0
iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021], :millisecond)
21

iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[2014-10-02 00:29:12])
-2
iex> NaiveDateTime.diff(~N[-0001-10-02 00:29:10], ~N[-0001-10-02 00:29:12])
-2

它还可以计算天、小时或分钟的差值

iex> NaiveDateTime.diff(~N[2014-10-10 00:29:10], ~N[2014-10-02 00:29:10], :day)
8
iex> NaiveDateTime.diff(~N[2014-10-02 12:29:10], ~N[2014-10-02 00:29:10], :hour)
12
iex> NaiveDateTime.diff(~N[2014-10-02 00:39:10], ~N[2014-10-02 00:29:10], :minute)
10

但它也会将不完整的天数四舍五入为零

iex> NaiveDateTime.diff(~N[2014-10-10 00:29:09], ~N[2014-10-02 00:29:10], :day)
7

@spec end_of_day(Calendar.naive_datetime()) :: t()

计算一个 NaiveDateTime，它是给定 NaiveDateTime 的最后一个时刻。

要计算DateTime的当天结束时间，请调用此函数，然后转换回DateTime

datetime
|> NaiveDateTime.end_of_day()
|> DateTime.from_naive(datetime.time_zone)

请注意，在给定的时区中，当天结束时间可能不存在或模棱两可，因此您必须相应地处理这些情况。

示例

iex> NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.123456])
~N[2000-01-01 23:59:59.999999]

@spec from_erl(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) ::
  {:ok, t()} | {:error, atom()}

将 Erlang 日期时间元组转换为 NaiveDateTime 结构体。

尝试转换无效的 ISO 日历日期将产生一个错误元组。

示例

iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}})
{:ok, ~N[2000-01-01 13:30:15]}
iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
{:ok, ~N[2000-01-01 13:30:15.005]}
iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
{:error, :invalid_date}
iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
{:error, :invalid_date}

@spec from_erl!(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) ::
  t()

将 Erlang 日期时间元组转换为 NaiveDateTime 结构体。

如果日期时间无效，则会引发异常。尝试转换无效的 ISO 日历日期将产生一个错误元组。

示例

iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}})
~N[2000-01-01 13:30:15]
iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
~N[2000-01-01 13:30:15.005]
iex> NaiveDateTime.from_erl!({{2000, 13, 1}, {13, 30, 15}})
** (ArgumentError) cannot convert {{2000, 13, 1}, {13, 30, 15}} to naive datetime, reason: :invalid_date

@spec from_gregorian_seconds(integer(), Calendar.microsecond(), Calendar.calendar()) ::
  t()

将格里高利秒数转换为 NaiveDateTime 结构体。

示例

iex> NaiveDateTime.from_gregorian_seconds(1)
~N[0000-01-01 00:00:01]
iex> NaiveDateTime.from_gregorian_seconds(63_755_511_991, {5000, 3})
~N[2020-05-01 00:26:31.005]
iex> NaiveDateTime.from_gregorian_seconds(-1)
~N[-0001-12-31 23:59:59]

@spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t()} | {:error, atom()}

解析由 ISO 8601:2019 描述的扩展“日期和时间”格式。

时区偏移量可能包含在字符串中，但它们将被简单地丢弃，因为此类信息未包含在朴素日期时间中。

如标准中所述，如果需要，可以省略分隔符“T”，因为在此函数中没有歧义。

请注意，内置日历 ISO 不支持闰秒。

示例

iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07")
{:ok, ~N[2015-01-23 23:50:07]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07")
{:ok, ~N[2015-01-23 23:50:07]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07Z")
{:ok, ~N[2015-01-23 23:50:07]}

iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0")
{:ok, ~N[2015-01-23 23:50:07.0]}
iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07,0123456")
{:ok, ~N[2015-01-23 23:50:07.012345]}
iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0123456")
{:ok, ~N[2015-01-23 23:50:07.012345]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123Z")
{:ok, ~N[2015-01-23 23:50:07.123]}

iex> NaiveDateTime.from_iso8601("2015-01-23P23:50:07")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015:01:23 23-50-07")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07A")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:61")
{:error, :invalid_time}
iex> NaiveDateTime.from_iso8601("2015-01-32 23:50:07")
{:error, :invalid_date}

iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
{:ok, ~N[2015-01-23 23:50:07.123]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+00:00")
{:ok, ~N[2015-01-23 23:50:07.123]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-02:30")
{:ok, ~N[2015-01-23 23:50:07.123]}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
{:error, :invalid_format}
iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-24:00")
{:error, :invalid_format}

@spec from_iso8601!(String.t(), Calendar.calendar()) :: t()

解析由 ISO 8601:2019 描述的扩展“日期和时间”格式。

如果格式无效，则会引发异常。

示例

iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07.123Z")
~N[2015-01-23 23:50:07.123]
iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07,123Z")
~N[2015-01-23 23:50:07.123]
iex> NaiveDateTime.from_iso8601!("2015-01-23P23:50:07")
** (ArgumentError) cannot parse "2015-01-23P23:50:07" as naive datetime, reason: :invalid_format

@spec local_now(Calendar.calendar()) :: t()

返回 Elixir 程序正在运行的机器的“本地时间”。

警告：此函数会导致难以察觉的错误。它依赖于运行时的时区配置。这可能会发生变化，并设置为具有夏令时跳跃（春季提前或秋季倒退）的时区。

此函数可用于显示机器恰好拥有的时区配置的当前时间。例如，桌面程序向用户显示时钟。对于任何其他用途，使用此函数可能是一个坏主意。

在大多数情况下，请使用DateTime.now/2或DateTime.utc_now/1代替。

不包括小数秒。

示例

iex> naive_datetime = NaiveDateTime.local_now()
iex> naive_datetime.year >= 2019
true

@spec new(Date.t(), Time.t()) :: {:ok, t()}

从日期和时间结构体构建一个 NaiveDateTime。

示例

iex> NaiveDateTime.new(~D[2010-01-13], ~T[23:00:07.005])
{:ok, ~N[2010-01-13 23:00:07.005]}

@spec new(
  Calendar.year(),
  Calendar.month(),
  Calendar.day(),
  Calendar.hour(),
  Calendar.minute(),
  Calendar.second(),
  Calendar.microsecond() | non_neg_integer(),
  Calendar.calendar()
) :: {:ok, t()} | {:error, atom()}

构建一个新的 ISO NaiveDateTime。

期望所有值都是整数。如果每个条目都符合其相应的范围，则返回{:ok, naive_datetime}，否则返回{:error, reason}。

示例

iex> NaiveDateTime.new(2000, 1, 1, 0, 0, 0)
{:ok, ~N[2000-01-01 00:00:00]}
iex> NaiveDateTime.new(2000, 13, 1, 0, 0, 0)
{:error, :invalid_date}
iex> NaiveDateTime.new(2000, 2, 29, 0, 0, 0)
{:ok, ~N[2000-02-29 00:00:00]}
iex> NaiveDateTime.new(2000, 2, 30, 0, 0, 0)
{:error, :invalid_date}
iex> NaiveDateTime.new(2001, 2, 29, 0, 0, 0)
{:error, :invalid_date}

iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1})
{:ok, ~N[2000-01-01 23:59:59.0]}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 999_999)
{:ok, ~N[2000-01-01 23:59:59.999999]}
iex> NaiveDateTime.new(2000, 1, 1, 24, 59, 59, 999_999)
{:error, :invalid_time}
iex> NaiveDateTime.new(2000, 1, 1, 23, 60, 59, 999_999)
{:error, :invalid_time}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 60, 999_999)
{:error, :invalid_time}
iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 1_000_000)
{:error, :invalid_time}

iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
{:ok, ~N[2000-01-01 23:59:59.0]}

@spec new!(Date.t(), Time.t()) :: t()

从日期和时间结构体构建一个 NaiveDateTime。

示例

iex> NaiveDateTime.new!(~D[2010-01-13], ~T[23:00:07.005])
~N[2010-01-13 23:00:07.005]

@spec new!(
  Calendar.year(),
  Calendar.month(),
  Calendar.day(),
  Calendar.hour(),
  Calendar.minute(),
  Calendar.second(),
  Calendar.microsecond() | non_neg_integer(),
  Calendar.calendar()
) :: t()

构建一个新的 ISO NaiveDateTime。

期望所有值都是整数。如果每个条目都符合其相应的范围，则返回naive_datetime，如果时间或日期无效，则会引发异常。

示例

iex> NaiveDateTime.new!(2000, 1, 1, 0, 0, 0)
~N[2000-01-01 00:00:00]
iex> NaiveDateTime.new!(2000, 2, 29, 0, 0, 0)
~N[2000-02-29 00:00:00]
iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, {0, 1})
~N[2000-01-01 23:59:59.0]
iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, 999_999)
~N[2000-01-01 23:59:59.999999]
iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
~N[2000-01-01 23:59:59.0]
iex> NaiveDateTime.new!(2000, 1, 1, 24, 59, 59, 999_999)
** (ArgumentError) cannot build naive datetime, reason: :invalid_time

@spec to_date(Calendar.naive_datetime()) :: Date.t()

将 NaiveDateTime 转换为 Date。

由于Date不保存时间信息，因此在转换期间会丢失数据。

示例

iex> NaiveDateTime.to_date(~N[2002-01-13 23:00:07])
~D[2002-01-13]

@spec to_erl(Calendar.naive_datetime()) :: :calendar.datetime()

将 NaiveDateTime 结构体转换为 Erlang 日期时间元组。

只支持将处于 ISO 日历中的朴素日期时间进行转换，尝试将其他日历中的朴素日期时间进行转换将引发异常。

警告：可能会发生精度丢失，因为 Erlang 时间元组只存储小时/分钟/秒。

示例

iex> NaiveDateTime.to_erl(~N[2000-01-01 13:30:15])
{{2000, 1, 1}, {13, 30, 15}}

此函数还可用于将 DateTime 转换为 Erlang 日期时间元组，而无需时区信息

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> NaiveDateTime.to_erl(dt)
{{2000, 2, 29}, {23, 00, 07}}

@spec to_gregorian_seconds(Calendar.naive_datetime()) ::
  {integer(), non_neg_integer()}

将 NaiveDateTime 结构体转换为格里高利秒数和微秒数。

示例

iex> NaiveDateTime.to_gregorian_seconds(~N[0000-01-01 00:00:01])
{1, 0}
iex> NaiveDateTime.to_gregorian_seconds(~N[2020-05-01 00:26:31.005])
{63_755_511_991, 5000}

@spec to_iso8601(Calendar.naive_datetime(), :basic | :extended) :: String.t()

将给定的 NaiveDateTime 转换为 ISO 8601:2019。

默认情况下，NaiveDateTime.to_iso8601/2返回以“扩展”格式格式化的朴素日期时间，以便于人类阅读。它还支持通过传递:basic选项的“基本”格式。

只支持将处于 ISO 日历中的朴素日期时间进行转换，尝试将其他日历中的朴素日期时间进行转换将引发异常。

示例

iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13])
"2000-02-28T23:00:13"

iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001])
"2000-02-28T23:00:13.001"

iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001], :basic)
"20000228T230013.001"

此函数还可用于将 DateTime 转换为 ISO 8601，而无需时区信息

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> NaiveDateTime.to_iso8601(dt)
"2000-02-29T23:00:07"

@spec to_string(Calendar.naive_datetime()) :: String.t()

根据给定 NaiveDateTime 的日历，将其转换为字符串。

示例

iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13])
"2000-02-28 23:00:13"
iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13.001])
"2000-02-28 23:00:13.001"
iex> NaiveDateTime.to_string(~N[-0100-12-15 03:20:31])
"-0100-12-15 03:20:31"

此函数还可用于将 DateTime 转换为字符串，而无需时区信息

iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
iex> NaiveDateTime.to_string(dt)
"2000-02-29 23:00:07"

@spec to_time(Calendar.naive_datetime()) :: Time.t()

将 NaiveDateTime 转换为 Time。

由于Time不保存日期信息，因此在转换期间会丢失数据。

示例

iex> NaiveDateTime.to_time(~N[2002-01-13 23:00:07])
~T[23:00:07]

@spec truncate(t(), :microsecond | :millisecond | :second) :: t()

返回给定的 NaiveDateTime，其微秒字段被截断为给定的精度（:microsecond、:millisecond 或 :second）。

如果给定的朴素日期时间已经比给定精度低，则返回该日期时间不变。

示例

iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond)
~N[2017-11-06 00:23:51.123456]

iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond)
~N[2017-11-06 00:23:51.123]

iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second)
~N[2017-11-06 00:23:51]

@spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) ::
  t()

返回 UTC 中当前的 NaiveDateTime。

如果可能，请优先使用DateTime.utc_now/0，因为与NaiveDateTime相反，它将保留时区信息。

您还可以提供一个时间单位来自动截断朴素日期时间。此功能自 v1.15.0 起可用。

示例

iex> naive_datetime = NaiveDateTime.utc_now()
iex> naive_datetime.year >= 2016
true

iex> naive_datetime = NaiveDateTime.utc_now(:second)
iex> naive_datetime.microsecond
{0, 0}

@spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) ::
  t()

返回 UTC 中当前的 NaiveDateTime，支持特定日历和精度。

如果可能，请优先使用DateTime.utc_now/2，因为与NaiveDateTime相反，它将保留时区信息。

示例

iex> naive_datetime = NaiveDateTime.utc_now(:second, Calendar.ISO)
iex> naive_datetime.year >= 2016
true

iex> naive_datetime = NaiveDateTime.utc_now(:second, Calendar.ISO)
iex> naive_datetime.microsecond
{0, 0}