Elixir 1.7

Map




elixir

Map

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

Enumerable प्रोटोकॉल को लागू करने वाले नक्शों के कई कार्य Enum मॉड्यूल में पाए जाते हैं। इसके अतिरिक्त, Kernel में मानचित्रों के निम्नलिखित कार्य पाए जाते हैं:

नक्शे अमृत में "जाने के लिए" कुंजी मूल्य संरचना है। मैप्स %{} वाक्य रचना के साथ बनाए जा सकते हैं, और कुंजी-मूल्य जोड़े key => value रूप में व्यक्त किए जा सकते हैं:

iex> %{}
%{}
iex> %{"one" => :two, 3 => "four"}
%{3 => "four", "one" => :two}

किसी मानचित्र में मुख्य-मूल्य वाले जोड़े किसी भी आदेश का पालन नहीं करते हैं (इसीलिए ऊपर दिए गए उदाहरण में मुद्रित मानचित्र के बनाए गए नक्शे की तुलना में एक अलग क्रम है)।

नक्शे प्रमुख प्रकार पर कोई प्रतिबंध नहीं लगाते हैं: कुछ भी एक नक्शे में एक कुंजी हो सकता है। एक कुंजी-मूल्य संरचना के रूप में, नक्शे नकली कुंजी की अनुमति नहीं देते हैं। कुंजी की तुलना सटीक-समानता ऑपरेटर ( ===/2 ) का उपयोग करके की जाती है। यदि टकराने वाली कुंजियों को मानचित्र के शाब्दिक में परिभाषित किया जाता है, तो अंतिम प्रबल होता है।

जब कुंजी-मूल्य जोड़ी में key: value एक परमाणु होती है, तो key: value शॉर्टहैंड सिंटैक्स का उपयोग किया जा सकता है (जैसा कि कई अन्य विशेष रूपों में), बशर्ते कुंजी-मूल्य जोड़े अंत में डाल दिए जाएं:

iex> %{"hello" => "world", a: 1, b: 2}
%{:a => 1, :b => 2, "hello" => "world"}

इस मॉड्यूल में कुछ फ़ंक्शन (जैसे Map.get/3 या Map.fetch/2 ) या map[] माध्यम से Access map[] सिंटैक्स Access मॉड्यूल द्वारा प्रदान किया जाता है:

iex> map = %{a: 1, b: 2}
iex> Map.fetch(map, :a)
{:ok, 1}
iex> map[:b]
2
iex> map["non_existing_key"]
nil

परमाणु कुंजियों तक पहुँचने के लिए, कोई भी map.key कर सकता है। ध्यान दें कि जब map[key] nil हो जाएगा, यदि map में key नहीं है, तो map उठाएगा यदि map में कुंजी नहीं है :key

iex> map = %{foo: "bar", baz: "bong"}
iex> map.foo
"bar"
iex> map.non_existing_key
** (KeyError) key :non_existing_key not found in: %{baz: "bong", foo: "bar"}

कुंजी तक पहुँचने के लिए दो वाक्यविन्यास नक्शे की दोहरी प्रकृति को प्रकट करते हैं। map[key] सिंटैक्स का उपयोग गतिशील रूप से बनाए गए मानचित्रों के लिए किया जाता है जिसमें किसी भी प्रकार की कोई भी कुंजी हो सकती है। map.key का उपयोग उन मानचित्रों के साथ किया जाता है जो परमाणुओं की चाबियों का एक पूर्व निर्धारित सेट रखते हैं, जो हमेशा मौजूद रहने की उम्मीद करते हैं। defstruct/1 माध्यम से परिभाषित defstruct/1 , ऐसे "स्थिर मानचित्र" का एक उदाहरण हैं, जहां संकलन समय के दौरान कुंजियों को भी जांचा जा सकता है।

मानचित्रों को पैटर्न से मिलान किया जा सकता है। जब एक पैटर्न पैटर्न मैच के बाईं ओर एक नक्शा होता है, तो यह मिलान करेगा कि क्या दाएं हाथ के नक्शे में बाएं हाथ की तरफ की चाबियाँ हैं और उनके मूल्य बाएं हाथ की तरफ से मेल खाते हैं। इसका मतलब है कि एक खाली नक्शा हर नक्शे से मेल खाता है

iex> %{} = %{foo: "bar"}
%{foo: "bar"}
iex> %{a: a} = %{:a => 1, "b" => 2, [:c, :e, :e] => 3}
iex> a
1
iex> %{:c => 3} = %{:a => 1, 2 => :b}
** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}

वेरिएबल्स का उपयोग मैप कीज के रूप में किया जा सकता है जब मैप शाब्दिक लिखने के साथ-साथ मिलान करते समय

iex> n = 1
1
iex> %{n => :one}
%{1 => :one}
iex> %{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}
%{1 => :one, 2 => :two, 3 => :three}

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

iex> map = %{one: 1, two: 2}
iex> %{map | one: "one"}
%{one: "one", two: 2}
iex> %{map | three: 3}
** (KeyError) key :three not found

सारांश

प्रकार

key()
value()

कार्य

हटाएं (नक्शा, कुंजी)

विशिष्ट key लिए map में प्रविष्टि को हटाता है

ड्रॉप (नक्शा, कुंजियाँ)

दिए गए keys को map से map

बराबर। (मैप 1, मैप 2)

जाँच करता है कि क्या दो नक्शे बराबर हैं

लाने (मानचित्र, कुंजी)

दिए गए map में एक विशिष्ट key लिए मान निकालता है, यदि map में key नहीं है, तो यह पता लगाता है

लाने (नक्शा, कुंजी)

दिए गए map में एक विशिष्ट key लिए मूल्य प्राप्त करता है

from_struct(struct)

नक्शे के लिए एक struct परिवर्तित करता है

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

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

get_and_update! (मानचित्र, कुंजी, मज़ा)

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

get_and_update (मानचित्र, कुंजी, मज़ा)

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

get_lazy (नक्शा, कुंजी, मज़ा)

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

has_key? (मानचित्र, कुंजी)

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

keys(map)

map से सभी चाबियाँ लौटाता है

मर्ज (map1, map2)

एक में दो नक्शे जोड़ता है

मर्ज (map1, map2, मज़ा)

दिए गए fun माध्यम से दो मानचित्रों को एक में जोड़ता है, विरोधों को हल करता fun

new()

एक नया खाली नक्शा लौटाता है

new(enumerable)

एक enumerable से एक नक्शा बनाता है

नया (गणना करने योग्य, बदलना)

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

पॉप (नक्शा, कुंजी, डिफ़ॉल्ट \\ nil)

लौटता है और map में key के साथ जुड़े मूल्य को निकालता है

pop_lazy (मानचित्र, कुंजी, मज़ा)

आलसी लौटता है और map में key के साथ जुड़े मूल्य को निकालता है

डाल (नक्शा, कुंजी, मूल्य)

map में key तहत दिए गए value को डालता है

put_new (नक्शा, कुंजी, मूल्य)

दिए गए value को key तहत डालता है जब तक कि प्रवेश key पहले से ही map में मौजूद न हो

put_new_lazy (नक्शा, कुंजी, मज़ा)

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

बदलें (मानचित्र, कुंजी, मूल्य)

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

विभाजन (नक्शा, कुंजियाँ)

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

ले (मानचित्र, कुंजियाँ)

नक्शे में सभी कुंजी-मूल्य जोड़े के साथ एक नया मानचित्र लौटाता है जहां कुंजी keys में keys

to_list(map)

map को एक सूची में परिवर्तित करता है

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

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

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

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

values(map)

map से सभी मान लौटाता है

प्रकार

कुंजी ()

key() :: any()

मूल्य ()

value() :: any()

कार्य

हटाएं (नक्शा, कुंजी)

delete(map(), key()) :: map()

विशिष्ट key लिए map में प्रविष्टि को हटाता है।

यदि key मौजूद नहीं है, तो रिटर्न अपरिवर्तित होता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.delete(%{a: 1, b: 2}, :a)
%{b: 2}
iex> Map.delete(%{b: 2}, :a)
%{b: 2}

ड्रॉप (नक्शा, कुंजियाँ)

drop(map(), Enumerable.t()) :: map()

दिए गए keys को map से map

यदि keys में ऐसी कुंजी होती है जो map में नहीं होती हैं, तो उन्हें केवल अनदेखा कर दिया जाता है।

उदाहरण

iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
%{a: 1, c: 3}

बराबर। (मैप 1, मैप 2)

equal?(map(), map()) :: boolean()

जाँच करता है कि क्या दो नक्शे बराबर हैं।

दो मानचित्रों को समान माना जाता है यदि उनमें समान कुंजियाँ होती हैं और उन कुंजियों में समान मान होते हैं।

उदाहरण

iex> Map.equal?(%{a: 1, b: 2}, %{b: 2, a: 1})
true
iex> Map.equal?(%{a: 1, b: 2}, %{b: 1, a: 2})
false

लाने (मानचित्र, कुंजी)

fetch!(map(), key()) :: value() | no_return()

दिए गए map में एक विशिष्ट key लिए मान निकालता है, यदि map में key नहीं है, तो यह पता लगाता है।

यदि map में दी गई key , तो संबंधित मान वापस आ जाता है। यदि map में key नहीं है, तो KeyError अपवाद उठाया जाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.fetch!(%{a: 1}, :a)
1
iex> Map.fetch!(%{a: 1}, :b)
** (KeyError) key :b not found in: %{a: 1}

लाने (नक्शा, कुंजी)

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

दिए गए map में एक विशिष्ट key लिए मूल्य प्राप्त करता है।

यदि map में मान value साथ दी गई key , तो {:ok, value} वापस कर दी जाती है। यदि map में key नहीं है, तो :error वापस आ जाती है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.fetch(%{a: 1}, :a)
{:ok, 1}
iex> Map.fetch(%{a: 1}, :b)
:error

from_struct (struct)

from_struct(atom() | struct()) :: map()

नक्शे के लिए एक struct परिवर्तित करता है।

यह संरचना मॉड्यूल या स्वयं एक संरचना को स्वीकार करता है और बस दिए गए संरचना से __struct__ फ़ील्ड को हटा देता है या दिए गए मॉड्यूल से उत्पन्न नई संरचना से।

उदाहरण

defmodule User do
  defstruct [:name]
end

Map.from_struct(User)
#=> %{name: nil}

Map.from_struct(%User{name: "john"})
#=> %{name: "john"}

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

get(map(), key(), value()) :: value()

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

यदि मूल्य value साथ map में key मौजूद है, तो value लौटाया जाता है। अन्यथा, default लौटा दिया जाता है (जो अन्यथा निर्दिष्ट होने तक nil )।

उदाहरण

iex> Map.get(%{}, :a)
nil
iex> Map.get(%{a: 1}, :a)
1
iex> Map.get(%{a: 1}, :b)
nil
iex> Map.get(%{a: 1}, :b, 3)
3

get_and_update! (मानचित्र, कुंजी, मज़ा)

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

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

वास्तव में get_and_update/3 पसंद get_and_update/3 , लेकिन यदि की- map में मौजूद नहीं है, तो KeyError अपवाद उठाता है।

उदाहरण

iex> Map.get_and_update!(%{a: 1}, :a, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{1, %{a: "new value!"}}

iex> Map.get_and_update!(%{a: 1}, :b, fn current_value ->
...>   {current_value, "new value!"}
...> end)
** (KeyError) key :b not found in: %{a: 1}

iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
...>   :pop
...> end)
{1, %{}}

get_and_update (मानचित्र, कुंजी, मज़ा)

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

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

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

लौटाया गया मूल्य fun - fun द्वारा लौटाए गए "प्राप्त" मूल्य के साथ एक नया और key तहत अद्यतन मूल्य के साथ एक नया नक्शा है।

उदाहरण

iex> Map.get_and_update(%{a: 1}, :a, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{1, %{a: "new value!"}}

iex> Map.get_and_update(%{a: 1}, :b, fn current_value ->
...>   {current_value, "new value!"}
...> end)
{nil, %{b: "new value!", a: 1}}

iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
{1, %{}}

iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
{nil, %{a: 1}}

get_lazy (नक्शा, कुंजी, मज़ा)

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

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

यदि मूल्य value साथ map में key मौजूद है, तो value लौटाया जाता है। अन्यथा, fun का मूल्यांकन किया जाता है और इसका परिणाम वापस आ जाता है।

यह तब उपयोगी होता है जब डिफ़ॉल्ट मान की गणना करना या फिर सेटअप और फाड़ के लिए आम तौर पर मुश्किल होता है।

उदाहरण

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Map.get_lazy(map, :a, fun)
1
iex> Map.get_lazy(map, :b, fun)
13

has_key? (मानचित्र, कुंजी)

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

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

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.has_key?(%{a: 1}, :a)
true
iex> Map.has_key?(%{a: 1}, :b)
false

कुंजी (नक्शा)

keys(map()) :: [key()]

map से सभी चाबियाँ लौटाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.keys(%{a: 1, b: 2})
[:a, :b]

मर्ज (map1, map2)

merge(map(), map()) :: map()

एक में दो नक्शे जोड़ता है।

map2 में सभी कुंजियों को map2 में जोड़ा जाएगा, जो किसी भी मौजूदा एक (यानी, map2 में कुंजियों को " map2 " पूर्वता है "को map1 ) को map1

यदि आपके पास एक संरचना है और आप संरचना में कुंजियों के एक सेट को मर्ज करना चाहते हैं, तो इस फ़ंक्शन का उपयोग न करें, क्योंकि यह सभी कुंजी को संरचना में दाईं ओर मर्ज करेगा, भले ही कुंजी संरचना का हिस्सा न हो। इसके बजाय, Kernel.struct/2 उपयोग करें। Kernel.struct/2

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
%{a: 3, b: 2, d: 4}

मर्ज (map1, map2, मज़ा)

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

दिए गए fun माध्यम से दो मानचित्रों को एक में जोड़ता है, विरोधों को हल करता fun

map2 में सभी कुंजियों को map2 में जोड़ा जाएगा। डुप्लिकेट कुंजियाँ होने पर दिए गए फ़ंक्शन को लागू किया जाएगा; इसके तर्क key (डुप्लिकेट कुंजी), value1 ( map1 में key का मूल्य), और value2 ( map2 में key का मूल्य)। fun द्वारा लौटाए गए मूल्य का उपयोग परिणामी नक्शे में key तहत मूल्य के रूप में किया जाता है।

उदाहरण

iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4}, fn _k, v1, v2 ->
...>   v1 + v2
...> end)
%{a: 4, b: 2, d: 4}

नया()

new() :: map()

एक नया खाली नक्शा लौटाता है।

उदाहरण

iex> Map.new()
%{}

नई (गणनीय)

new(Enumerable.t()) :: map()

एक enumerable से एक नक्शा बनाता है।

डुप्लिकेट कुंजियाँ हटा दी जाती हैं; नवीनतम एक प्रबल है।

उदाहरण

iex> Map.new([{:b, 1}, {:a, 2}])
%{a: 2, b: 1}
iex> Map.new([a: 1, a: 2, a: 3])
%{a: 3}

नया (गणना करने योग्य, बदलना)

new(Enumerable.t(), (term() -> {key(), value()})) :: map()

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

डुप्लिकेट कीज़ को हटा दिया जाता है; नवीनतम एक प्रबल है।

उदाहरण

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

पॉप (नक्शा, कुंजी, डिफ़ॉल्ट \\ nil)

pop(map(), key(), value()) :: {value(), map()}

लौटता है और map में key के साथ जुड़े मूल्य को निकालता है।

यदि मान value साथ map में मौजूद है, तो {value, new_map} वापस कर new_map जाता है, जहां new_map map से key निकालने का परिणाम है। यदि key map में मौजूद नहीं है, तो {default, map} वापस कर दिया जाता है।

उदाहरण

iex> Map.pop(%{a: 1}, :a)
{1, %{}}
iex> Map.pop(%{a: 1}, :b)
{nil, %{a: 1}}
iex> Map.pop(%{a: 1}, :b, 3)
{3, %{a: 1}}

pop_lazy (मानचित्र, कुंजी, मज़ा)

pop_lazy(map(), key(), (() -> value())) :: {value(), map()}

आलसी लौटता है और map में key के साथ जुड़े मूल्य को निकालता है।

यदि मान value साथ map में मौजूद है, तो {value, new_map} वापस कर new_map जाता है, जहां new_map map से key निकालने का परिणाम है। यदि key map में मौजूद नहीं है, तो {fun_result, map} लौटाया जाता है, जहाँ fun_result , fun लागू करने का परिणाम fun

यह तब उपयोगी होता है जब डिफ़ॉल्ट मान की गणना करना या फिर सेटअप और फाड़ के लिए आम तौर पर मुश्किल होता है।

उदाहरण

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   13
...> end
iex> Map.pop_lazy(map, :a, fun)
{1, %{}}
iex> Map.pop_lazy(map, :b, fun)
{13, %{a: 1}}

डाल (नक्शा, कुंजी, मूल्य)

put(map(), key(), value()) :: map()

map में key तहत दिए गए value को डालता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.put(%{a: 1}, :b, 2)
%{a: 1, b: 2}
iex> Map.put(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

put_new (नक्शा, कुंजी, मूल्य)

put_new(map(), key(), value()) :: map()

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

उदाहरण

iex> Map.put_new(%{a: 1}, :b, 2)
%{a: 1, b: 2}
iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
%{a: 1, b: 2}

put_new_lazy (नक्शा, कुंजी, मज़ा)

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

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

यदि आप पहले से ही मौजूद नहीं हैं, तो यह फ़ंक्शन उपयोगी है यदि आप key नीचे रखने के लिए मूल्य की गणना करना चाहते हैं (उदाहरण के लिए, मूल्य की गणना करना या फिर सेटअप और फाड़ना के लिए आम तौर पर मुश्किल है)।

उदाहरण

iex> map = %{a: 1}
iex> fun = fn ->
...>   # some expensive operation here
...>   3
...> end
iex> Map.put_new_lazy(map, :a, fun)
%{a: 1}
iex> Map.put_new_lazy(map, :b, fun)
%{a: 1, b: 3}

बदलें (मानचित्र, कुंजी, मूल्य) (1.5.0 के बाद से)

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

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

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

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
%{a: 3, b: 2}

iex> Map.replace!(%{a: 1}, :b, 2)
** (KeyError) key :b not found in: %{a: 1}

विभाजन (नक्शा, कुंजियाँ)

split(map(), Enumerable.t()) :: {map(), map()}

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

हटाए गए कुंजी के साथ नए नक्शे और पुराने नक्शे के साथ एक टपल लौटाता है।

उन कुंजियों को जिनके लिए map में कोई प्रविष्टि नहीं है, को अनदेखा किया जाता है।

उदाहरण

iex> Map.split(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
{%{a: 1, c: 3}, %{b: 2}}

ले (मानचित्र, कुंजियाँ)

take(map(), Enumerable.t()) :: map()

नक्शे में सभी कुंजी-मूल्य जोड़े के साथ एक नया मानचित्र लौटाता है जहां कुंजी keys में keys

यदि keys में ऐसी कुंजी होती है जो map में नहीं होती हैं, तो उन्हें केवल अनदेखा कर दिया जाता है।

उदाहरण

iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
%{a: 1, c: 3}

to_list (नक्शा)

to_list(map()) :: [{term(), term()}]

map को एक सूची में परिवर्तित करता है।

मानचित्र में प्रत्येक कुंजी-मान जोड़ी परिणामस्वरूप सूची में एक दो-तत्व टपल {key, value} में बदल जाती है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.to_list(%{a: 1})
[a: 1]
iex> Map.to_list(%{1 => 2})
[{1, 2}]

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

update!(map(), key(), (value() -> value())) :: map()

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

यदि मूल्य value साथ map में key मौजूद है, तो fun को तर्क value साथ लागू किया जाता है और इसके परिणाम को key के नए मूल्य के रूप में उपयोग किया जाता है। यदि key map में मौजूद नहीं है, तो एक KeyError अपवाद उठाया जाता है।

उदाहरण

iex> Map.update!(%{a: 1}, :a, &(&1 * 2))
%{a: 2}

iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
** (KeyError) key :b not found in: %{a: 1}

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

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

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

यदि मूल्य value साथ map में key मौजूद है, तो fun को तर्क value साथ लागू किया जाता है और इसका परिणाम key के नए मूल्य के रूप में उपयोग किया जाता है। यदि key map में मौजूद नहीं है, तो initial को key के मूल्य के रूप में डाला जाता है। प्रारंभिक मान अपडेट फ़ंक्शन के माध्यम से पारित नहीं किया जाएगा।

उदाहरण

iex> Map.update(%{a: 1}, :a, 13, &(&1 * 2))
%{a: 2}
iex> Map.update(%{a: 1}, :b, 11, &(&1 * 2))
%{a: 1, b: 11}

मूल्यों (नक्शा)

values(map()) :: [value()]

map से सभी मान लौटाता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Map.values(%{a: 1, b: 2})
[1, 2]