关键词 | Keyword
关键词
一组用于处理关键字的函数。
关键字是由两个元素元组组成的列表，其中元组的第一个元素是一个原子，第二个元素可以是任意值。
例如，以下是关键字列表：
[{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]
Elixir为关键字列表提供了一个特殊且更简洁的语法，如下所示：
[exit_on_close: true, active: :once, packet_size: 1024]
这也是Elixir用于检查关键字列表的语法：
iex> [{:active, :once}]
[active: :once]
这两个语法完全等价。注意，当关键字列表作为函数的最后一个参数传递时，如果使用简短的语法，那么关键字列表周围的方括号也可以省略。例如，以下内容：
String.split("1-0", "-", trim: true, parts: 2)
相当于：
String.split("1-0", "-", [trim: true, parts: 2])
关键字可能有重复的键，所以它不是严格意义上的键值存储。然而，本模块中的大多数函数的行为与字典完全一样，因此它们的工作方式类似于您在Map模块。
例如，Keyword.get/3将获得与给定键匹配的第一个条目，而不管是否存在重复项。同样，Keyword.put/3和Keyword.delete/3确保在调用时删除给定密钥的所有重复项。注意，需要在关键字列表%28中找到键的操作类似于Keyword.get/3%29需要遍历列表才能找到键，因此这些操作可能比对应的映射慢。
有一些函数可以处理重复的键，特别是，Enum.into/2允许在不删除重复键的情况下创建新关键字，get_values/2返回给定键和delete_first/2只删除一个现有条目。
的功能Keyword在订购时，不要担保任何财产。但是，由于关键字列表只是一个列表，所以在Enum和List也可以应用，特别是在需要订购的时候。
摘要
类型
key()t()t(value)value()
功能
delete(keywords, key)
删除特定关键字列表中的条目 key
delete(keywords, key, value)
删除关键字列表的条目key与value
delete_first(keywords, key)
删除特定关键字列表中的第一个条目 key
drop(keywords, keys)
从关键字列表中删除给定的键。
equal?(left, right)
检查两个关键字是否相等
fetch(keywords, key)
获取特定key并以元组的形式返回
fetch!(keywords, key)
获取特定key
get(keywords, key, default \ nil)
获取指定的key
get_and_update(keywords, key, fun)
获取key并更新它，在一次传递中
get_and_update!(keywords, key, fun)
从中获取价值key并进行更新。如果没有，则引发key
get_lazy(keywords, key, fun)
获取指定的key
get_values(keywords, key)
获取特定的所有值 key
has_key?(keywords, key)
返回给定的key存在于给定的keywords
keys(keywords)
返回关键字列表中的所有键。
keyword?(term)
回报true如果term是关键字列表，否则返回false
merge(keywords1, keywords2)
将两个关键字列表合并为一个
merge(keywords1, keywords2, fun)
将两个关键字列表合并为一个
new()
返回空关键字列表，即空列表
new(pairs)
从可枚举的
new(pairs, transform)
从可枚举的转换函数中创建关键字。
pop(keywords, key, default \ nil)
返回并移除与key在关键字列表中
pop_first(keywords, key, default \ nil)
返回并移除与key在关键字列表中
pop_lazy(keywords, key, fun)
延迟返回和移除所有与key在关键字列表中
pop_lazy(keywords, key, fun)
把给定的value下key
put_new(keywords, key, value)
把给定的value下key除非key已经存在
put_new_lazy(keywords, key, fun)
除非已经存在，否则fun将结果评估并放入key关键字列表中key
replace(keywords, key, value)
更改存储在key到value，但前提是key已存在于关键字列表中。
replace!(keywords, key, value)
类似于replace/3，但KeyError如果条目key不存在，则会提高
split(keywords, keys)
获取与给定键对应的所有条目，并将它们提取到单独的关键字列表中。
take(keywords, keys)
获取与给定键对应的所有条目，并在新关键字列表中返回它们。
to_list(keyword)
返回关键字列表本身。
update(keywords, key, initial, fun)
更新key在keywords具有给定的函数
update!(keywords, key, fun)
更新key具有给定的函数
values(keywords)
返回关键字列表中的所有值。
类型
key()
key() :: atom
t()
t() :: [{key, value}]
t(value)
t(value) :: [{key, value}]
value()
value() :: any
函数
delete(keywords, key)
delete(t, key) :: t
删除特定关键字列表中的条目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]
delete(keywords, key, value)
delete(t, key, value) :: t
删除的关键字列表中的条目key用value。
如果没有key与value存在，返回关键字列表不变。
实例
iex> Keyword.delete([a: 1, b: 2], :a, 1)
[b: 2]
iex> Keyword.delete([a: 1, b: 2, a: 3], :a, 3)
[a: 1, b: 2]
iex> Keyword.delete([a: 1], :a, 5)
[a: 1]
iex> Keyword.delete([a: 1], :b, 5)
[a: 1]
delete_first(keywords, key)
delete_first(t, key) :: t
删除特定关键字列表中的第一个条目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]
drop(keywords, keys)
drop(t, [key]) :: t
从关键字列表中删除给定的键。
重复的键保留在新关键字列表中。
实例
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]
equal?(left, right)
equal?(t, t) :: boolean
检查两个关键字是否相等。
如果两个关键字包含相同的键，而这些关键字包含相同的值，则认为它们是相等的。
实例
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
fetch(keywords, key)
fetch(t, key) :: {:ok, value} | :error
获取特定值key并将其返回到元组中。
如果key不存在，则返回:error。
实例
iex> Keyword.fetch([a: 1], :a)
{:ok, 1}
iex> Keyword.fetch([a: 1], :b)
:error
fetch!(keywords, key)
fetch!(t, key) :: value | no_return
获取特定的值key。
如果key不存在，则引发KeyError。
实例
iex> Keyword.fetch!([a: 1], :a)
1
iex> Keyword.fetch!([a: 1], :b)
** (KeyError) key :b not found in: [a: 1]
get(keywords, key, default \ nil)
get(t, key, value) :: value
获取特定的值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
get_and_update(keywords, key, fun)
get_and_update(t, key, (value -> {get, value} | :pop)) :: {get, t} when get: term
获取key更新一下，一次就可以了。
该fun参数接收key（或者nil如果key不存在）的值，并且必须返回一个双元素元组：“获取”值（返回的值，可以在返回之前对其进行操作）以及要存储的新值key。该fun还可以返回:pop，这意味着当前值应从关键字列表中删除并返回。
返回的值是一个带有返回值“get”值的元组，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: 1], :a, fn _ -> :pop end)
{1, []}
iex> Keyword.get_and_update([a: 1], :b, fn _ -> :pop end)
{nil, [a: 1]}
get_and_update!(keywords, key, fun)
get_and_update!(t, key, (value -> {get, value})) ::
{get, t} |
no_return when get: term
从中获取价值key并进行更新。如果没有，则引发key。
该fun参数接收key和返回一个两元素元组的值，并且必须返回：“get”值（返回的值，可以在返回之前对其进行操作）以及要存储的新值key。
返回的值是一个带有返回值“get”值的元组，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, []}
get_lazy(keywords, key, fun)
get_lazy(t, key, (() -> value)) :: value
获取特定的值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
get_values(keywords, key)
get_values(t, key) :: [value]
获取特定的所有值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]
has_key?(keywords, key)
has_key?(t, key) :: boolean
返回给定中是否key存在给定keywords。
实例
iex> Keyword.has_key?([a: 1], :a)
true
iex> Keyword.has_key?([a: 1], :b)
false
keys(keywords)
keys(t) :: [key]
返回关键字列表中的所有键。
重复的键在最终的键列表中出现重复。
实例
iex> Keyword.keys([a: 1, b: 2])
[:a, :b]
iex> Keyword.keys([a: 1, b: 2, a: 3])
[:a, :b, :a]
keyword?(term)
keyword?(term) :: boolean
返回trueif term是关键字列表；否则返回false。
实例
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
merge(keywords1, keywords2)
merge(t, t) :: t
将两个关键字列表合并为一个。
所有的密钥，包括重复的密钥，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]
merge(keywords1, keywords2, fun)
merge(t, t, (key, value, value -> value)) :: t
将两个关键字列表合并为一个。
所有键，包括重复的键，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]
new()
new() :: []
返回空关键字列表，即空列表。
实例
iex> Keyword.new()
[]
new(pairs)
new(Enum.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]
new(pairs, transform)
new(Enum.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]
pop(keywords, key, default \ nil)
pop(t, key, value) :: {value, t}
返回并移除与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, []}
pop_first(keywords, key, default \ nil)
pop_first(t, key, value) :: {value, t}
返回并移除与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]}
pop_lazy(keywords, key, fun)
pop_lazy(t, key, (() -> value)) :: {value, t}
延迟返回和移除所有与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]}
put(keywords, key, value)
put(t, key, value) :: t
把value下面的给出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]
put_new(keywords, key, value)
put_new(t, key, value) :: t
除非条目已经存在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]
put_new_lazy(keywords, key, fun)
put_new_lazy(t, key, (() -> value)) :: t
除非已经存在，否则fun将结果评估并放入key关键字列表中key。
如果这个值计算起来非常昂贵，或者一般难以设置和拆卸，这很有用。
实例
iex> keyword = [a: 1]
iex> fun = fn ->
...> # some expensive operation here
...> 3
...> end
iex> Keyword.put_new_lazy(keyword, :a, fun)
[a: 1]
iex> Keyword.put_new_lazy(keyword, :b, fun)
[b: 3, a: 1]
replace(keywords, key, value)
replace(t, key, value) :: t
改变下存储的值key来value，但前提是该条目key已经在关键字列表中存在。
如果一个值被多次存储在关键字列表中，那么以后的事件就会被删除。
实例
iex> Keyword.replace([a: 1], :b, 2)
[a: 1]
iex> Keyword.replace([a: 1, b: 2, a: 4], :a, 3)
[a: 3, b: 2]
replace!(keywords, key, value)
replace!(t, key, value) :: t
类似于replace/3，但KeyError如果条目key不存在，则会提高。
实例
iex> Keyword.replace!([a: 1, b: 2, a: 4], :a, 3)
[a: 3, b: 2]
iex> Keyword.replace!([a: 1], :b, 2)
** (KeyError) key :b not found in: [a: 1]
split(keywords, keys)
split(t, [key]) :: {t, t}
获取与给定键相对应的所有条目，并将它们提取到单独的关键字列表中。
返回带有新列表的元组和带有移除键的旧列表。
关键字列表中没有条目的键将被忽略。
具有重复键的条目最终出现在同一个关键字列表中。
实例
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]}
take(keywords, keys)
take(t, [key]) :: t
获取与给定键相对应的所有条目，并将它们返回到新的关键字列表中。
重复的键保留在新关键字列表中。
实例
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]
to_list(keyword)
to_list(t) :: t
返回关键字列表本身。
实例
iex> Keyword.to_list([a: 1])
[a: 1]
update(keywords, key, initial, fun)
update(t, key, value, (value -> value)) :: t
更新key在keywords用给定的函数。
如果key不存在，则插入给定的initial价值。
如果有重复的键，它们都会被删除，并且只有二会被更新。
实例
iex> Keyword.update([a: 1], :a, 13, &(&1 * 2))
[a: 2]
iex> Keyword.update([a: 1, a: 2], :a, 13, &(&1 * 2))
[a: 2]
iex> Keyword.update([a: 1], :b, 11, &(&1 * 2))
[a: 1, b: 11]
update!(keywords, key, fun)
update!(t, key, (value -> value)) :: t | no_return
更新key用给定的函数。
如果key不存在，则引发KeyError。
如果有重复的键，它们都会被删除，并且只有二会被更新。
实例
iex> Keyword.update!([a: 1], :a, &(&1 * 2))
[a: 2]
iex> Keyword.update!([a: 1, a: 2], :a, &(&1 * 2))
[a: 2]
iex> Keyword.update!([a: 1], :b, &(&1 * 2))
** (KeyError) key :b not found in: [a: 1]
values(keywords)
values(t) :: [value]
返回关键字列表中的所有值。
来自重复键的值将保存在值的最终列表中。
实例
iex> Keyword.values([a: 1, b: 2])
[1, 2]
iex> Keyword.values([a: 1, b: 2, a: 3])
[1, 2, 3]
