Elixir 1.7

Keyword




elixir

Keyword

कीवर्ड के साथ काम करने के लिए कार्यों का एक सेट।

एक कीवर्ड दो-तत्व tuples की एक सूची है जहां tuple का पहला तत्व एक परमाणु है और दूसरा तत्व किसी भी मूल्य का हो सकता है।

उदाहरण के लिए, निम्नलिखित एक खोजशब्द सूची है:

[{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]

Elixir कीवर्ड सूची के लिए एक विशेष और अधिक संक्षिप्त सिंटैक्स प्रदान करता है जो इस तरह दिखता है:

[exit_on_close: true, active: :once, packet_size: 1024]

यह सिंटैक्स भी है जिसका उपयोग कीवर्ड सूची का निरीक्षण करने के लिए अमृत करता है:

iex> [{:active, :once}]
[active: :once]

दो वाक्यविन्यास पूरी तरह से बराबर हैं। यदि कीवर्ड में विदेशी अक्षर हैं, जैसे रिक्त स्थान, तो आप इसे उद्धरणों में लपेट सकते हैं:

iex> ["exit on close": true]
["exit on close": true]

किसी कीवर्ड को उद्धरण चिह्नों में लपेटने से वह स्ट्रिंग नहीं बन जाता है। कीवर्ड हमेशा परमाणु होते हैं और उद्धरण केवल विदेशी पात्रों को संभालने के लिए उपयोग किए जाने चाहिए। वास्तव में, यदि आप आवश्यक नहीं होने पर उद्धरण का उपयोग करने का प्रयास करते हैं, तो अमृत चेतावनी देगा।

ध्यान दें कि जब कीवर्ड सूचियों को फ़ंक्शन के अंतिम तर्क के रूप में पास किया जाता है, यदि शॉर्ट-हैंड सिंटैक्स का उपयोग किया जाता है, तो कीवर्ड सूची के चारों ओर चौकोर कोष्ठक भी छोड़ा जा सकता है। उदाहरण के लिए, निम्नलिखित:

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 सुनिश्चित करने के लिए दिए गए कुंजी के लिए सभी डुप्लिकेट की गई प्रविष्टियों को हटा दिया जाता है। ध्यान दें कि जिन परिचालनों के लिए कुंजीशब्द सूची में पाए जाने की आवश्यकता होती है (जैसे Keyword.get/3 ) कुंजी खोजने के लिए सूची को पीछे करना पड़ता है, इसलिए ये कार्य उनके मानचित्र समकक्षों की तुलना में धीमा हो सकता है।

डुप्लिकेट कुंजियों को संभालने के लिए कुछ मुट्ठी भर कार्य मौजूद हैं, विशेष रूप से, Enum.into/2 डुप्लिकेट कीज़ को हटाए बिना नए कीवर्ड बनाने की अनुमति देता है, get_values/2 दिए गए कुंजी के लिए सभी मान लौटाता है और delete_first/2 मौजूदा प्रविष्टियों में से केवल एक को हटाता है।

Keyword कार्य किसी भी संपत्ति की गारंटी नहीं देते हैं जब ऑर्डर करने की बात आती है। हालाँकि, चूंकि एक कीवर्ड सूची बस एक सूची है, इसलिए Enum और List में परिभाषित सभी ऑपरेशनों को भी लागू किया जा सकता है, खासकर जब ऑर्डर करना आवश्यक हो।

सारांश

प्रकार

key()
t()
t(value)
value()

कार्य

हटाएं (कीवर्ड, कुंजी)

एक विशिष्ट key लिए कीवर्ड सूची में प्रविष्टियों को हटाता है

हटाएं (कीवर्ड, कुंजी, मान)

value साथ key लिए कीवर्ड सूची में प्रविष्टियों को हटाता है

delete_first/2

किसी विशिष्ट key लिए कीवर्ड सूची में पहली प्रविष्टि हटाता है

ड्रॉप (कीवर्ड, कुंजी)

कीवर्ड सूची से दिए गए कुंजी को गिराता है

बराबर (बाएं, दाएं)

जाँचता है कि क्या दो खोजशब्द समान हैं

लाने (कीवर्ड, कुंजी)

विशिष्ट key लिए मान निकालता है

लाने (कीवर्ड, कुंजी)

एक विशिष्ट key लिए मान निकालता है और इसे एक टपल में वापस करता है

प्राप्त करें (कीवर्ड, कुंजी, डिफ़ॉल्ट \\ nil)

एक विशिष्ट key लिए मूल्य हो जाता है

get_and_update! (कीवर्ड, कुंजी, मज़ा)

key से मूल्य प्राप्त key और इसे अपडेट करता है। अगर कोई key नहीं है तो उठाता है

get_and_update (कीवर्ड, कुंजी, मज़ा)

key से मूल्य प्राप्त key और इसे अपडेट करता है, सभी एक पास में

get_lazy (कीवर्ड, कुंजी, मज़ा)

एक विशिष्ट key लिए मूल्य हो जाता है

get_values/2

एक विशिष्ट key लिए सभी मान प्राप्त करता है

has_key? (कीवर्ड, कुंजी)

दिए गए keywords में दी गई key मौजूद है या नहीं

keys(keywords)

कीवर्ड सूची से सभी कुंजी लौटाता है

keyword?(term)

यदि term एक कीवर्ड सूची है, तो true है; अन्यथा false लौट आता false

मर्ज (कीवर्ड 1, कीवर्ड 2)

दो कीवर्ड सूचियों को एक में जोड़ता है

मर्ज (कीवर्ड 1, कीवर्ड 2, मज़ा)

दो कीवर्ड सूचियों को एक में जोड़ता है

new()

एक खाली कीवर्ड सूची, यानी एक खाली सूची लौटाता है

new(pairs)

एक enumerable से एक कीवर्ड बनाता है

नया (जोड़े, रूपांतर)

परिवर्तन फ़ंक्शन के माध्यम से एक enumerable से एक कीवर्ड बनाता है

पॉप (कीवर्ड, कुंजी, डिफ़ॉल्ट \\ nil)

कीवर्ड सूची में key जुड़े सभी मानों को लौटाता है और हटाता है

pop_first (कीवर्ड, कुंजी, डिफ़ॉल्ट \\ nil)

कीवर्ड सूची में key जुड़ा पहला मान लौटाता है और हटाता है

pop_lazy (कीवर्ड, कुंजी, मज़ा)

कीवर्ड सूची में key के साथ जुड़े सभी मानों को लौटाता है और हटाता है

डाल (कीवर्ड, कुंजी, मान)

key तहत दिए गए value को डालता है

put_new (कीवर्ड, कुंजी, मान)

जब तक प्रविष्टि key पहले से मौजूद नहीं है, तब तक दिए गए value को key नीचे रखता है

put_new_lazy (कीवर्ड, कुंजी, मज़ा)

fun मूल्यांकन करता fun और कीवर्ड सूची में key तहत परिणाम डालता है जब तक कि key पहले से मौजूद न हो

बदलें (कीवर्ड, कुंजी, मान)

मान के लिए key तहत संग्रहीत मूल्य को बदलता है, लेकिन केवल तभी जब प्रवेश key पहले से ही keywords में मौजूद हो

विभाजन (कीवर्ड, कुंजी)

दी गई कुंजियों के अनुरूप सभी प्रविष्टियाँ लेता है और उन्हें एक अलग खोजशब्द सूची में निकालता है

ले (कीवर्ड, कुंजी)

दी गई कुंजियों के अनुरूप सभी प्रविष्टियाँ लेता है और उन्हें एक नई कीवर्ड सूची में लौटाता है

to_list(keyword)

कीवर्ड सूची को स्वयं लौटाता है

अद्यतन। (कीवर्ड, कुंजी, मज़ा)

दिए गए फ़ंक्शन के साथ key को अपडेट करता है

अद्यतन (कीवर्ड, कुंजी, प्रारंभिक, मजेदार)

दिए गए फ़ंक्शन के साथ keywords में key को अपडेट करता है

values(keywords)

कीवर्ड सूची से सभी मान लौटाता है

प्रकार

कुंजी ()

key() :: atom()

टी ()

t() :: [{key(), value()}]

टी (मान)

t(value) :: [{key(), value}]

मूल्य ()

value() :: any()

कार्य

हटाएं (कीवर्ड, कुंजी)

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(t(), key(), value()) :: t()

value साथ key लिए कीवर्ड सूची में प्रविष्टियों को हटाता है।

यदि value कोई key मौजूद नहीं है, तो कीवर्ड सूची को अपरिवर्तित लौटाता है।

उदाहरण

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 (कीवर्ड, कुंजी)

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(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?(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!(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]

लाने (कीवर्ड, कुंजी)

fetch(t(), key()) :: {:ok, value()} | :error

एक विशिष्ट key लिए मान निकालता है और इसे एक टपल में वापस करता है।

यदि key मौजूद नहीं है, तो रिटर्न :error

उदाहरण

iex> Keyword.fetch([a: 1], :a)
{:ok, 1}
iex> Keyword.fetch([a: 1], :b)
:error

प्राप्त करें (कीवर्ड, कुंजी, डिफ़ॉल्ट \\ nil)

get(t(), key(), value()) :: value()

एक विशिष्ट key लिए मूल्य हो जाता है।

यदि key मौजूद नहीं है, तो डिफ़ॉल्ट मान लौटाएं (यदि कोई डिफ़ॉल्ट मान नहीं है)।

यदि डुप्लिकेट प्रविष्टियाँ मौजूद हैं, तो पहला वापस आ गया है। सभी प्रविष्टियों को पुनः प्राप्त करने के लिए 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! (कीवर्ड, कुंजी, मज़ा)

get_and_update!(t(), key(), (value() -> {get, value()})) ::
  {get, t()} | no_return()
when get: term()

key से मूल्य प्राप्त key और इसे अपडेट करता है। अगर कोई key नहीं है तो उठाता है।

यह fun तर्क key का मूल्य प्राप्त करता है और दो-तत्व का टपल लौटाया जाना चाहिए: "प्राप्त" मान (पुनर्प्राप्त मूल्य, जिसे लौटाए जाने से पहले संचालित किया जा सकता है) और key तहत संग्रहीत किया जाने वाला नया मान।

लौटाया गया मूल्य fun - 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_and_update (कीवर्ड, कुंजी, मज़ा)

get_and_update(t(), key(), (value() -> {get, value()} | :pop)) ::
  {get, t()}
when get: term()

key से मूल्य प्राप्त key और इसे अपडेट करता है, सभी एक पास में।

यह fun तर्क key का मान प्राप्त करता है (या यदि key मौजूद नहीं है तो nil ) और दो-तत्व टपल वापस करना होगा: "प्राप्त" मान (प्राप्त किया गया मान, जो लौटाए जाने से पहले संचालित किया जा सकता है) और प्राप्त करने के लिए नया मान key तहत संग्रहीत किया जाना चाहिए। fun भी वापस आ सकता है :pop , वर्तमान मूल्य का अर्थ कीवर्ड सूची से हटा दिया जाएगा और वापस आ जाएगा।

लौटाया गया मूल्य fun - 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_lazy (कीवर्ड, कुंजी, मज़ा)

get_lazy(t(), key(), (() -> value())) :: value()

एक विशिष्ट key लिए मूल्य हो जाता है।

यदि key मौजूद नहीं है, तो आलसी fun मूल्यांकन करता 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 ​​(कीवर्ड, कुंजी)

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? (कीवर्ड, कुंजी)

has_key?(t(), key()) :: boolean()

दिए गए keywords में दी गई key मौजूद है या नहीं।

उदाहरण

iex> Keyword.has_key?([a: 1], :a)
true
iex> Keyword.has_key?([a: 1], :b)
false

कुंजी (कीवर्ड्स)

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()) :: boolean()

यदि term एक कीवर्ड सूची है, तो true है; अन्यथा false लौट आता 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

मर्ज (कीवर्ड 1, कीवर्ड 2)

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]

मर्ज (कीवर्ड 1, कीवर्ड 2, मज़ा)

merge(t(), t(), (key(), value(), value() -> value())) :: t()

दो कीवर्ड सूचियों को एक में जोड़ता है।

keywords2 में दिए गए डुप्लिकेट कीज़ सहित सभी कुंजियाँ जोड़ी जाएँगी। दिए गए फ़ंक्शन को विवादों को हल करने के लिए आमंत्रित किया जाएगा।

यदि keywords2 में डुप्लिकेट कुंजियाँ हैं, तो दिए गए फ़ंक्शन को keywords1 1 में प्रत्येक मिलान जोड़ी के लिए आमंत्रित किया जाएगा।

लौटे कीवर्ड में कुंजियों के क्रम के बारे में कोई गारंटी नहीं है।

उदाहरण

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() :: []

एक खाली कीवर्ड सूची, यानी एक खाली सूची लौटाता है।

उदाहरण

iex> Keyword.new()
[]

नई (जोड़े)

new(Enum.t()) :: t()

एक enumerable से एक कीवर्ड बनाता है।

डुप्लिकेट प्रविष्टियों को हटा दिया जाता है, नवीनतम एक प्रबल होता है। 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(Enum.t(), (term() -> {key(), value()})) :: t()

परिवर्तन फ़ंक्शन के माध्यम से एक enumerable से एक कीवर्ड बनाता है।

डुप्लिकेट प्रविष्टियों को हटा दिया जाता है, नवीनतम एक प्रबल होता है। Enum.into(enumerable, [], fun) विपरीत, Keyword.new(enumerable, fun) गारंटी देता है कि चाबियाँ अद्वितीय हैं।

उदाहरण

iex> Keyword.new([:a, :b], fn x -> {x, x} end)
[a: :a, b: :b]

पॉप (कीवर्ड, कुंजी, डिफ़ॉल्ट \\ 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 (कीवर्ड, कुंजी, डिफ़ॉल्ट \\ 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 (कीवर्ड, कुंजी, मज़ा)

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(t(), key(), value()) :: t()

key तहत दिए गए value को डालता है।

यदि कोई पिछला मान पहले से संग्रहीत है, तो सभी प्रविष्टियाँ निकाल दी जाती हैं और मान ओवरराइड हो जाता है।

उदाहरण

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 (कीवर्ड, कुंजी, मान)

put_new(t(), key(), value()) :: t()

जब तक प्रविष्टि key पहले से मौजूद नहीं है, तब तक दिए गए value को 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 (कीवर्ड, कुंजी, मज़ा)

put_new_lazy(t(), key(), (() -> value())) :: t()

fun मूल्यांकन करता 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]

बदलें (कीवर्ड, कुंजी, मान) (1.5.0 के बाद से)

replace!(t(), key(), value()) :: t()

मान के लिए key तहत संग्रहीत मूल्य को बदलता है, लेकिन केवल तभी जब प्रवेश key पहले से ही keywords में मौजूद हो।

यदि key keywords में मौजूद नहीं है, तो एक KeyError अपवाद उठाया जाता है।

उदाहरण

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(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(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 (कीवर्ड)

to_list(t()) :: t()

कीवर्ड सूची को स्वयं लौटाता है।

उदाहरण

iex> Keyword.to_list([a: 1])
[a: 1]

अद्यतन। (कीवर्ड, कुंजी, मज़ा)

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]

अद्यतन (कीवर्ड, कुंजी, प्रारंभिक, मजेदार)

update(t(), key(), value(), (value() -> value())) :: t()

दिए गए फ़ंक्शन के साथ keywords में key को अपडेट करता है।

यदि 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]

मूल्यों (कीवर्ड्स)

values(t()) :: [value()]

कीवर्ड सूची से सभी मान लौटाता है।

डुप्लिकेट कीज़ से वैल्यूज़ को वैल्यूज़ की अंतिम सूची में रखा जाएगा।

उदाहरण

iex> Keyword.values([a: 1, b: 2])
[1, 2]
iex> Keyword.values([a: 1, b: 2, a: 3])
[1, 2, 3]