查看源代码 Keyword (Elixir v1.16.2)
关键字列表是一个仅包含两个元素元组的列表。
这些元组的第一个元素称为键，必须是原子。第二个元素称为值，可以是任何项。
关键字主要用于处理可选值。有关关键字及其与映射比较的总体介绍，请参阅我们的关键字和映射指南。
示例
例如，以下是关键字列表
[{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]Elixir 提供了关键字列表的特殊且更简洁的语法
[exit_on_close: true, active: :once, packet_size: 1024]这两种语法返回完全相同的值。
键可以是任何原子，包含 Unicode 字母、数字、下划线或@符号。如果键应该包含任何其他字符（例如空格），则可以将其用引号括起来
iex> ["exit on close": true]
["exit on close": true]用引号括起原子不会使其成为字符串。关键字列表键始终是原子。引号仅在必要时使用，否则 Elixir 会发出警告。
重复键和排序
关键字可能包含重复键，因此它不是严格意义上的键值数据类型。但是，此模块中的大多数函数都作用于键值结构，并且行为类似于您在Map模块中找到的函数。例如，Keyword.get/3将获取与给定键匹配的第一个条目，无论是否存在重复条目。类似地，Keyword.put/3和Keyword.delete/2确保调用时删除给定键的所有重复条目。但是，请注意，关键字列表操作需要遍历整个列表以查找键，因此这些操作比其映射对应项慢。
有一些函数用于处理重复键，例如，get_values/2返回给定键的所有值，而delete_first/2仅删除现有条目的第一个条目。
即使列表保留了现有顺序，Keyword中的函数也不保证任何排序。例如，如果您调用Keyword.put(opts, new_key, new_value)，则无法保证new_key将被添加到哪里（开头、结尾或任何其他地方）。
鉴于排序没有保证，也不建议对关键字列表进行模式匹配。例如，像这样的函数
def my_function([some_key: value, another_key: another_value])将匹配
my_function([some_key: :foo, another_key: :bar])但它不会匹配
my_function([another_key: :bar, some_key: :foo])此模块中的大多数函数都以线性时间运行。这意味着执行操作所需的时间与列表长度成正比。
调用语法
当关键字列表作为最后一个参数传递给函数时，可以省略关键字列表周围的方括号。例如，关键字列表语法
String.split("1-0", "-", [trim: true, parts: 2])可以在作为函数调用的最后一个参数时，省略封闭括号进行编写
String.split("1-0", "-", trim: true, parts: 2)由于元组、列表和映射在 Elixir 语法中与函数参数的处理方式类似，因此此属性也适用于它们
iex> {1, 2, foo: :bar}
{1, 2, [{:foo, :bar}]}
iex> [1, 2, foo: :bar]
[1, 2, {:foo, :bar}]
iex> %{1 => 2, foo: :bar}
%{1 => 2, :foo => :bar}摘要
函数
删除关键字列表中特定key下的条目。
删除关键字列表中特定key下的第一个条目。
从关键字列表中删除给定的keys。
检查两个关键字是否相等。
获取特定key的值并将其以元组形式返回。
获取特定key的值。
返回一个关键字列表，其中仅包含keywords中函数fun返回真值的条目。
从给定的keys和固定的value构建一个关键字。
获取给定key下的值。
获取key的值并更新它，一次完成。
获取key下的值并更新它。如果不存在key，则引发异常。
获取给定key下的值。
获取特定key下的所有值。
返回给定的key是否在给定的keywords中。
返回关键字列表中的所有键。
如果term是一个关键字列表，则返回true，否则返回false。
将两个关键字列表合并为一个。
将两个关键字列表合并为一个。
返回一个空关键字列表，即一个空列表。
从可枚举对象创建关键字列表。
通过转换函数从可枚举对象创建关键字列表。
返回key的第一个值，并删除关键字列表中所有关联的条目。
返回key的第一个值，并删除关键字列表中所有关联的条目，如果key不存在，则引发异常。
返回并删除关键字列表中与key关联的第一个值。
延迟返回并删除关键字列表中与key关联的所有值。
返回key的所有值，并删除关键字列表中所有关联的条目。
将给定的value放到指定的key下。
将给定的value放到key下，除非条目key已经存在。
评估fun并将结果放到关键字列表中的key下，除非key已存在。
返回一个关键字列表，其中排除了keywords中函数fun返回真值的条目。
仅当key已存在于keywords中时，才将值放到key下。
仅当key已存在于keywords中时，才将值放到key下。
仅当key已存在于keywords中时，才使用给定函数替换key下的值。
获取与给定keys对应的所有条目，并将它们提取到单独的关键字列表中。
根据给定的函数fun将keywords拆分为两个关键字列表。
获取与给定keys对应的所有条目，并将它们作为新的关键字列表返回。
返回关键字列表本身。
使用给定函数更新keywords中key下的值。
使用给定函数更新key下的值。
确保给定的keyword仅具有values中给出的键。
类似于validate/2，但返回关键字或引发错误。
返回关键字列表中的所有值。
类型
函数
删除关键字列表中特定key下的条目。
如果key不存在，则返回不变的关键字列表。使用delete_first/2仅删除重复键的第一个条目。
示例
iex> Keyword.delete([a: 1, b: 2], :a)
[b: 2]
iex> Keyword.delete([a: 1, b: 2, a: 3], :a)
[b: 2]
iex> Keyword.delete([b: 2], :a)
[b: 2]删除关键字列表中特定key下的第一个条目。
如果key不存在，则返回不变的关键字列表。
示例
iex> Keyword.delete_first([a: 1, b: 2, a: 3], :a)
[b: 2, a: 3]
iex> Keyword.delete_first([b: 2], :a)
[b: 2]从关键字列表中删除给定的keys。
从新的关键字列表中删除重复键。
示例
iex> Keyword.drop([a: 1, a: 2], [:a])
[]
iex> Keyword.drop([a: 1, b: 2, c: 3], [:b, :d])
[a: 1, c: 3]
iex> Keyword.drop([a: 1, b: 2, b: 3, c: 3, a: 5], [:b, :d])
[a: 1, c: 3, a: 5]检查两个关键字是否相等。
如果两个关键字包含相同的键，并且这些键包含相同的值，则认为它们相等。
示例
iex> Keyword.equal?([a: 1, b: 2], [b: 2, a: 1])
true
iex> Keyword.equal?([a: 1, b: 2], [b: 1, a: 2])
false
iex> Keyword.equal?([a: 1, b: 2, a: 3], [b: 2, a: 3, a: 1])
true值之间的比较使用===/3进行，这意味着整数不等于浮点数
iex> Keyword.equal?([a: 1.0], [a: 1])
false获取特定key的值并将其以元组形式返回。
如果key不存在，则返回:error。
示例
iex> Keyword.fetch([a: 1], :a)
{:ok, 1}
iex> Keyword.fetch([a: 1], :b)
:error获取特定key的值。
如果key不存在，则引发KeyError。
示例
iex> Keyword.fetch!([a: 1], :a)
1
iex> Keyword.fetch!([a: 1], :b)
** (KeyError) key :b not found in: [a: 1]返回一个关键字列表，其中仅包含keywords中函数fun返回真值的条目。
另请参阅reject/2，它将丢弃函数返回真值的条目。
示例
iex> Keyword.filter([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
[one: 1, three: 3]从给定的keys和固定的value构建一个关键字。
示例
iex> Keyword.from_keys([:foo, :bar, :baz], :atom)
[foo: :atom, bar: :atom, baz: :atom]
iex> Keyword.from_keys([], :atom)
[]获取给定key下的值。
如果 key 不存在，则返回默认值（如果没有提供默认值，则返回 nil）。
如果存在重复条目，则返回第一个条目。使用 get_values/2 获取所有条目。
示例
iex> Keyword.get([], :a)
nil
iex> Keyword.get([a: 1], :a)
1
iex> Keyword.get([a: 1], :b)
nil
iex> Keyword.get([a: 1], :b, 3)
3带有重复键
iex> Keyword.get([a: 1, a: 2], :a, 3)
1
iex> Keyword.get([a: 1, a: 2], :b, 3)
3@spec get_and_update( t(), key(), (value() | nil -> {current_value, new_value :: value()} | :pop) ) :: {current_value, new_keywords :: t()} when current_value: value()
获取key的值并更新它，一次完成。
fun 参数接收 key 的值（如果 key 不存在，则为 nil），并且必须返回一个包含两个元素的元组：当前值（检索到的值，可以在返回之前进行操作）以及要存储在 key 下的新值。该 fun 也可以返回 :pop，这意味着将从关键字列表中删除当前值并返回。
返回一个元组，其中包含 fun 返回的当前值，以及一个在 key 下更新了值的新关键字列表。
示例
iex> Keyword.get_and_update([a: 1], :a, fn current_value ->
...> {current_value, "new value!"}
...> end)
{1, [a: "new value!"]}
iex> Keyword.get_and_update([a: 1], :b, fn current_value ->
...> {current_value, "new value!"}
...> end)
{nil, [b: "new value!", a: 1]}
iex> Keyword.get_and_update([a: 2], :a, fn number ->
...> {2 * number, 3 * number}
...> end)
{4, [a: 6]}
iex> Keyword.get_and_update([a: 1], :a, fn _ -> :pop end)
{1, []}
iex> Keyword.get_and_update([a: 1], :b, fn _ -> :pop end)
{nil, [a: 1]}@spec get_and_update!( t(), key(), (value() -> {current_value, new_value :: value()} | :pop) ) :: {current_value, new_keywords :: t()} when current_value: value()
获取key下的值并更新它。如果不存在key，则引发异常。
fun 参数接收 key 下的值，并且必须返回一个包含两个元素的元组：当前值（检索到的值，可以在返回之前进行操作）以及要存储在 key 下的新值。
返回一个元组，其中包含 fun 返回的当前值，以及一个在 key 下更新了值的新关键字列表。
示例
iex> Keyword.get_and_update!([a: 1], :a, fn current_value ->
...> {current_value, "new value!"}
...> end)
{1, [a: "new value!"]}
iex> Keyword.get_and_update!([a: 1], :b, fn current_value ->
...> {current_value, "new value!"}
...> end)
** (KeyError) key :b not found in: [a: 1]
iex> Keyword.get_and_update!([a: 1], :a, fn _ ->
...> :pop
...> end)
{1, []}获取给定key下的值。
如果 key 不存在，则延迟地评估 fun 并返回其结果。
如果默认值非常昂贵才能计算或通常难以设置和再次拆卸，这将很有用。
如果存在重复条目，则返回第一个条目。使用 get_values/2 获取所有条目。
示例
iex> keyword = [a: 1]
iex> fun = fn ->
...> # some expensive operation here
...> 13
...> end
iex> Keyword.get_lazy(keyword, :a, fun)
1
iex> Keyword.get_lazy(keyword, :b, fun)
13获取特定key下的所有值。
示例
iex> Keyword.get_values([], :a)
[]
iex> Keyword.get_values([a: 1], :a)
[1]
iex> Keyword.get_values([a: 1, a: 2], :a)
[1, 2]返回给定的key是否在给定的keywords中。
示例
iex> Keyword.has_key?([a: 1], :a)
true
iex> Keyword.has_key?([a: 1], :b)
false返回关键字列表中的所有键。
在生成的键列表中保留重复键。
示例
iex> Keyword.keys(a: 1, b: 2)
[:a, :b]
iex> Keyword.keys(a: 1, b: 2, a: 3)
[:a, :b, :a]
iex> Keyword.keys([{:a, 1}, {"b", 2}, {:c, 3}])
** (ArgumentError) expected a keyword list, but an entry in the list is not a two-element tuple with an atom as its first element, got: {"b", 2}如果term是一个关键字列表，则返回true，否则返回false。
当 term 是一个列表时，它将遍历到列表的末尾。
示例
iex> Keyword.keyword?([])
true
iex> Keyword.keyword?(a: 1)
true
iex> Keyword.keyword?([{Foo, 1}])
true
iex> Keyword.keyword?([{}])
false
iex> Keyword.keyword?([:key])
false
iex> Keyword.keyword?(%{})
false将两个关键字列表合并为一个。
将 keywords2 中给出的所有键（包括重复键）添加到 keywords1 中，覆盖任何现有的键。
返回的关键字中键的顺序没有任何保证。
示例
iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4])
[b: 2, a: 3, d: 4]
iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5])
[b: 2, a: 3, d: 4, a: 5]
iex> Keyword.merge([a: 1], [2, 3])
** (ArgumentError) expected a keyword list as the second argument, got: [2, 3]将两个关键字列表合并为一个。
将 keywords2 中给出的所有键（包括重复键）添加到 keywords1 中。调用给定的函数来解决冲突。
如果 keywords2 具有重复键，它会对 keywords1 中的每个匹配对调用给定的函数。
返回的关键字中键的顺序没有任何保证。
示例
iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn _k, v1, v2 ->
...> v1 + v2
...> end)
[b: 2, a: 4, d: 4]
iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
...> v1 + v2
...> end)
[b: 2, a: 4, d: 4, a: 5]
iex> Keyword.merge([a: 1, b: 2, a: 3], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
...> v1 + v2
...> end)
[b: 2, a: 4, d: 4, a: 8]
iex> Keyword.merge([a: 1, b: 2], [:a, :b], fn :a, v1, v2 ->
...> v1 + v2
...> end)
** (ArgumentError) expected a keyword list as the second argument, got: [:a, :b]@spec new() :: []
返回一个空关键字列表，即一个空列表。
示例
iex> Keyword.new()
[]@spec new(Enumerable.t()) :: t()
从可枚举对象创建关键字列表。
删除重复条目，最后一个条目优先。与 Enum.into(enumerable, []) 不同，Keyword.new(enumerable) 保证键是唯一的。
示例
iex> Keyword.new([{:b, 1}, {:a, 2}])
[b: 1, a: 2]
iex> Keyword.new([{:a, 1}, {:a, 2}, {:a, 3}])
[a: 3]@spec new(Enumerable.t(), (term() -> {key(), value()})) :: t()
通过转换函数从可枚举对象创建关键字列表。
删除重复条目，最后一个条目优先。与 Enum.into(enumerable, [], fun) 不同，Keyword.new(enumerable, fun) 保证键是唯一的。
示例
iex> Keyword.new([:a, :b], fn x -> {x, x} end)
[a: :a, b: :b]返回key的第一个值，并删除关键字列表中所有关联的条目。
它返回一个元组，其中第一个元素是 key 的第一个值，第二个元素是删除了与 key 关联的所有条目的关键字列表。如果关键字列表中不存在该 key，则它返回 {default, keyword_list}。
如果你不想删除与 key 关联的所有条目，请使用 pop_first/3，它只会删除第一个条目。
示例
iex> Keyword.pop([a: 1], :a)
{1, []}
iex> Keyword.pop([a: 1], :b)
{nil, [a: 1]}
iex> Keyword.pop([a: 1], :b, 3)
{3, [a: 1]}
iex> Keyword.pop([a: 1, a: 2], :a)
{1, []}返回key的第一个值，并删除关键字列表中所有关联的条目，如果key不存在，则引发异常。
此函数的行为类似于 pop/3，但如果给定的 keywords 中不存在 key，则会引发异常。
示例
iex> Keyword.pop!([a: 1], :a)
{1, []}
iex> Keyword.pop!([a: 1, a: 2], :a)
{1, []}
iex> Keyword.pop!([a: 1], :b)
** (KeyError) key :b not found in: [a: 1]返回并删除关键字列表中与key关联的第一个值。
在生成的关键字列表中保留重复键。
示例
iex> Keyword.pop_first([a: 1], :a)
{1, []}
iex> Keyword.pop_first([a: 1], :b)
{nil, [a: 1]}
iex> Keyword.pop_first([a: 1], :b, 3)
{3, [a: 1]}
iex> Keyword.pop_first([a: 1, a: 2], :a)
{1, [a: 2]}延迟返回并删除关键字列表中与key关联的所有值。
如果默认值非常昂贵才能计算或通常难以设置和再次拆卸，这将很有用。
删除所有重复键。有关仅删除第一个条目的信息，请参见 pop_first/3。
示例
iex> keyword = [a: 1]
iex> fun = fn ->
...> # some expensive operation here
...> 13
...> end
iex> Keyword.pop_lazy(keyword, :a, fun)
{1, []}
iex> Keyword.pop_lazy(keyword, :b, fun)
{13, [a: 1]}返回key的所有值，并删除关键字列表中所有关联的条目。
它返回一个元组，其中第一个元素是 key 的值列表，第二个元素是删除了与 key 关联的所有条目的关键字列表。如果关键字列表中不存在该 key，则它返回 {[], keyword_list}。
如果你不想删除与 key 关联的所有条目，请使用 pop_first/3，它只会删除第一个条目。
示例
iex> Keyword.pop_values([a: 1], :a)
{[1], []}
iex> Keyword.pop_values([a: 1], :b)
{[], [a: 1]}
iex> Keyword.pop_values([a: 1, a: 2], :a)
{[1, 2], []}将给定的value放到指定的key下。
如果 key 下的值已经存在，则它会覆盖该值并删除所有重复条目。
示例
iex> Keyword.put([a: 1], :b, 2)
[b: 2, a: 1]
iex> Keyword.put([a: 1, b: 2], :a, 3)
[a: 3, b: 2]
iex> Keyword.put([a: 1, b: 2, a: 4], :a, 3)
[a: 3, b: 2]将给定的value放到key下，除非条目key已经存在。
示例
iex> Keyword.put_new([a: 1], :b, 2)
[b: 2, a: 1]
iex> Keyword.put_new([a: 1, b: 2], :a, 3)
[a: 1, b: 2]评估fun并将结果放到关键字列表中的key下，除非key已存在。
如果该值非常昂贵才能计算或通常难以设置和再次拆卸，这将很有用。
示例
iex> keyword = [a: 1]
iex> fun = fn ->
...> # some expensive operation here
...> 13
...> end
iex> Keyword.put_new_lazy(keyword, :a, fun)
[a: 1]
iex> Keyword.put_new_lazy(keyword, :b, fun)
[b: 13, a: 1]返回一个关键字列表，其中排除了keywords中函数fun返回真值的条目。
另请参见 filter/2。
示例
iex> Keyword.reject([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
[two: 2]仅当key已存在于keywords中时，才将值放到key下。
如果关键字列表中存在多次键，则它会删除后面的出现。
示例
iex> Keyword.replace([a: 1, b: 2, a: 4], :a, 3)
[a: 3, b: 2]
iex> Keyword.replace([a: 1], :b, 2)
[a: 1]仅当key已存在于keywords中时，才将值放到key下。
如果 keywords 中不存在 key，则会引发 KeyError。
示例
iex> Keyword.replace!([a: 1, b: 2, a: 3], :a, :new)
[a: :new, b: 2]
iex> Keyword.replace!([a: 1, b: 2, c: 3, b: 4], :b, :new)
[a: 1, b: :new, c: 3]
iex> Keyword.replace!([a: 1], :b, 2)
** (KeyError) key :b not found in: [a: 1]仅当key已存在于keywords中时，才使用给定函数替换key下的值。
与 replace/3 相比，这在计算值很昂贵时可能很有用。
如果 key 不存在，则返回原始关键字列表，保持不变。
示例
iex> Keyword.replace_lazy([a: 1, b: 2], :a, fn v -> v * 4 end)
[a: 4, b: 2]
iex> Keyword.replace_lazy([a: 2, b: 2, a: 1], :a, fn v -> v * 4 end)
[a: 8, b: 2]
iex> Keyword.replace_lazy([a: 1, b: 2], :c, fn v -> v * 4 end)
[a: 1, b: 2]获取与给定keys对应的所有条目，并将它们提取到单独的关键字列表中。
返回一个包含新列表和删除了键的旧列表的元组。
忽略关键字列表中没有条目的键。
具有重复键的条目最终将出现在同一个关键字列表中。
示例
iex> Keyword.split([a: 1, b: 2, c: 3], [:a, :c, :e])
{[a: 1, c: 3], [b: 2]}
iex> Keyword.split([a: 1, b: 2, c: 3, a: 4], [:a, :c, :e])
{[a: 1, c: 3, a: 4], [b: 2]}根据给定的函数fun将keywords拆分为两个关键字列表。
提供的 fun 将 keywords 中的每个 {key, value} 对作为其唯一参数接收。返回一个元组，其中第一个关键字列表包含 keywords 中所有应用 fun 返回真值的结果的元素，第二个关键字列表包含所有应用 fun 返回假值（false 或 nil）的元素。
示例
iex> Keyword.split_with([a: 1, b: 2, c: 3], fn {_k, v} -> rem(v, 2) == 0 end)
{[b: 2], [a: 1, c: 3]}
iex> Keyword.split_with([a: 1, b: 2, c: 3, b: 4], fn {_k, v} -> rem(v, 2) == 0 end)
{[b: 2, b: 4], [a: 1, c: 3]}
iex> Keyword.split_with([a: 1, b: 2, c: 3, b: 4], fn {k, v} -> k in [:a, :c] and rem(v, 2) == 0 end)
{[], [a: 1, b: 2, c: 3, b: 4]}
iex> Keyword.split_with([], fn {_k, v} -> rem(v, 2) == 0 end)
{[], []}获取与给定keys对应的所有条目，并将它们作为新的关键字列表返回。
在新的关键字列表中保留重复键。
示例
iex> Keyword.take([a: 1, b: 2, c: 3], [:a, :c, :e])
[a: 1, c: 3]
iex> Keyword.take([a: 1, b: 2, c: 3, a: 5], [:a, :c, :e])
[a: 1, c: 3, a: 5]返回关键字列表本身。
示例
iex> Keyword.to_list(a: 1)
[a: 1]@spec update( t(), key(), default :: value(), (existing_value :: value() -> new_value :: value()) ) :: t()
使用给定函数更新keywords中key下的值。
如果该 key 不存在，则插入给定的 default 值。不会将 default 值传递到更新函数中。
删除所有重复键，并且只更新第一个键。
示例
iex> Keyword.update([a: 1], :a, 13, fn existing_value -> existing_value * 2 end)
[a: 2]
iex> Keyword.update([a: 1, a: 2], :a, 13, fn existing_value -> existing_value * 2 end)
[a: 2]
iex> Keyword.update([a: 1], :b, 11, fn existing_value -> existing_value * 2 end)
[a: 1, b: 11]使用给定函数更新key下的值。
如果 key 不存在，则引发 KeyError。
删除所有重复键，并且只更新第一个键。
示例
iex> Keyword.update!([a: 1, b: 2, a: 3], :a, &(&1 * 2))
[a: 2, b: 2]
iex> Keyword.update!([a: 1, b: 2, c: 3], :b, &(&1 * 2))
[a: 1, b: 4, c: 3]
iex> Keyword.update!([a: 1], :b, &(&1 * 2))
** (KeyError) key :b not found in: [a: 1]@spec validate( keyword(), values :: [atom() | {atom(), term()}] ) :: {:ok, keyword()} | {:error, [atom()]}
确保给定的keyword仅具有values中给出的键。
第二个参数必须是一个原子列表，指定给定的键，或指定键和默认值的元组列表。
如果关键字列表只有给定的键，则它返回 {:ok, keyword}，并应用默认值。否则它返回 {:error, invalid_keys}，其中包含无效的键。
另请参见：validate!/2。
示例
iex> {:ok, result} = Keyword.validate([], [one: 1, two: 2])
iex> Enum.sort(result)
[one: 1, two: 2]
iex> {:ok, result} = Keyword.validate([two: 3], [one: 1, two: 2])
iex> Enum.sort(result)
[one: 1, two: 3]如果给定原子，则它们作为键受支持，但它们不提供默认值
iex> {:ok, result} = Keyword.validate([], [:one, two: 2])
iex> Enum.sort(result)
[two: 2]
iex> {:ok, result} = Keyword.validate([one: 1], [:one, two: 2])
iex> Enum.sort(result)
[one: 1, two: 2]传递未知键会返回错误
iex> Keyword.validate([three: 3, four: 4], [one: 1, two: 2])
{:error, [:four, :three]}多次传递相同的键也会导致错误
iex> Keyword.validate([one: 1, two: 2, one: 1], [:one, :two])
{:error, [:one]}类似于validate/2，但返回关键字或引发错误。
示例
iex> Keyword.validate!([], [one: 1, two: 2]) |> Enum.sort()
[one: 1, two: 2]
iex> Keyword.validate!([two: 3], [one: 1, two: 2]) |> Enum.sort()
[one: 1, two: 3]如果给定原子，则它们作为键受支持，但它们不提供默认值
iex> Keyword.validate!([], [:one, two: 2]) |> Enum.sort()
[two: 2]
iex> Keyword.validate!([one: 1], [:one, two: 2]) |> Enum.sort()
[one: 1, two: 2]传递未知键会导致错误
iex> Keyword.validate!([three: 3], [one: 1, two: 2])
** (ArgumentError) unknown keys [:three] in [three: 3], the allowed keys are: [:one, :two]多次传递相同的键也会导致错误
iex> Keyword.validate!([one: 1, two: 2, one: 1], [:one, :two])
** (ArgumentError) duplicate keys [:one] in [one: 1, two: 2, one: 1]返回关键字列表中的所有值。
在生成的键值对列表中保留重复键的值。
示例
iex> Keyword.values(a: 1, b: 2)
[1, 2]
iex> Keyword.values(a: 1, b: 2, a: 3)
[1, 2, 3]