檢視原始碼 關鍵字 (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 下的值。
取得特定 鍵 下的所有值。
傳回給定的 鍵 是否存在於給定的 關鍵字 中。
傳回關鍵字清單中的所有鍵。
如果 項目 是關鍵字清單，則傳回 true，否則傳回 false。
將兩個關鍵字清單合併成一個。
將兩個關鍵字清單合併成一個。
傳回一個空的關鍵字清單，也就是一個空的清單。
從可列舉物件建立一個關鍵字清單。
透過轉換函數從可列舉物件建立一個關鍵字清單。
傳回 鍵 的第一個值，並移除關鍵字清單中所有相關的項目。
傳回 鍵 的第一個值，並移除關鍵字清單中所有相關的項目，如果 鍵 不存在，則會引發例外。
傳回並移除關鍵字清單中與 鍵 相關的第一個值。
延遲傳回並移除關鍵字清單中與 鍵 相關的所有值。
傳回 鍵 的所有值，並移除關鍵字清單中所有相關的項目。
將給定的 值 放入指定的 鍵 下。
將給定的 值 放入 鍵 下，除非項目 鍵 已存在。
評估 函數，並將結果放入關鍵字清單中的 鍵 下，除非 鍵 已存在。
傳回一個關鍵字清單，排除函數 函數 傳回真值結果的 關鍵字 中的項目。
僅在 鍵 已存在於 關鍵字 中時，才將值放入 鍵 下。
僅在 鍵 已存在於 關鍵字 中時，才將值放入 鍵 下。
僅在 鍵 已存在於 關鍵字 中時，才使用給定的函數取代 鍵 下的值。
取出與給定 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 取得值並更新，一次完成。
funkey 的值（如果 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，則會引發例外狀況。
funkey 下的值，並且必須傳回一個二元組：目前值（擷取的值，可以在傳回之前進行運算）和要儲存在 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取得特定 鍵 下的所有值。
範例
iex> Keyword.get_values([], :a)
[]
iex> Keyword.get_values([a: 1], :a)
[1]
iex> Keyword.get_values([a: 1, a: 2], :a)
[1, 2]傳回給定的 鍵 是否存在於給定的 關鍵字 中。
範例
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}如果 項目 是關鍵字清單，則傳回 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，它會傳回 {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, []}傳回 鍵 的第一個值，並移除關鍵字清單中所有相關的項目，如果 鍵 不存在，則會引發例外。
此函數的行為類似於 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]傳回並移除關鍵字清單中與 鍵 相關的第一個值。
在結果關鍵字清單中保留重複的鍵。
範例
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_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，它會傳回 {[], 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], []}將給定的 值 放入指定的 鍵 下。
如果 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]將給定的 值 放入 鍵 下，除非項目 鍵 已存在。
範例
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]評估 函數，並將結果放入關鍵字清單中的 鍵 下，除非 鍵 已存在。
如果計算值非常耗費資源，或通常難以設定和再次中斷，這會很有用。
範例
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]傳回一個關鍵字清單，排除函數 函數 傳回真值結果的 關鍵字 中的項目。
另請參閱 filter/2。
範例
iex> Keyword.reject([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
[two: 2]僅在 鍵 已存在於 關鍵字 中時，才將值放入 鍵 下。
如果關鍵字清單中有多個相同的關鍵字，它會移除較後出現的關鍵字。
範例
iex> Keyword.replace([a: 1, b: 2, a: 4], :a, 3)
[a: 3, b: 2]
iex> Keyword.replace([a: 1], :b, 2)
[a: 1]僅在 鍵 已存在於 關鍵字 中時，才將值放入 鍵 下。
如果 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]僅在 鍵 已存在於 關鍵字 中時，才使用給定的函數取代 鍵 下的值。
與 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]