Erlang 21

maps




erlang

maps

मॉड्यूल

नक्शे

मॉड्यूल सारांश

मानचित्र प्रसंस्करण कार्य।

विवरण

इस मॉड्यूल में मानचित्र प्रसंस्करण के कार्य शामिल हैं।

जानकारी का प्रकार

iterator()

मानचित्र में प्रमुख मूल्य संघों का प्रतिनिधित्व करने वाला एक पुनरावृति।

maps:iterator/1 का उपयोग करके बनाया गया maps:iterator/1

maps:next/1 द्वारा उपभोग maps:next/1 , maps:filter/2 , maps:fold/3 और maps:map/2

निर्यात

फ़िल्टर (पूर्व, MapOrIter) -> मानचित्र

प्रकार

एक नक्शा देता है, जिसके लिए MapOrIter भविष्यवाणी करता है जो MapOrIter में सही है।

कॉल एक {badmap,Map} अपवाद के साथ विफल हो जाता है अगर MapOrIter एक मैप या वैध MapOrIter नहीं है, या यदि badarg साथ है तो Pred 2 arity का फ़ंक्शन नहीं है।

उदाहरण:

> M = #{a => 2, b => 3, c=> 4, "a" => 1, "b" => 2, "c" => 4},
  Pred = fun(K,V) -> is_atom(K) andalso (V rem 2) =:= 0 end,
  maps:filter(Pred,M).
#{a => 2,c => 4}
खोज (कुंजी, मानचित्र) -> {ठीक है, मूल्य} | त्रुटि

प्रकार

एक टपल {ok, Value} , जहां Value Key जुड़ा Value है, या यदि Map में की के साथ कोई मूल्य जुड़ा नहीं है, तो error

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map = #{"hi" => 42},
  Key = "hi",
  maps:find(Key,Map).
{ok,42}
गुना (फन, इनिट, मैपऑइटर) -> Acc

प्रकार

किसी भी क्रम में MapOrIter में V एसोसिएशन को महत्व देने के लिए हर K लिए F(K, V, AccIn) को कॉल करता है। fun F/3 को एक नया संचायक वापस करना होगा, जो अगले क्रमिक कॉल के लिए दिया गया है। यह फ़ंक्शन संचायक का अंतिम मान लौटाता है। यदि मानचित्र खाली है, तो प्रारंभिक संचायक मान Init लौटा दिया जाता है।

यदि MapOrIter मैप 3 का फ़ंक्शन नहीं है, तो MapOrIter एक मैप या वैध badarg या badarg साथ कॉल {badmap,Map} अपवाद के साथ विफल रहता है।

उदाहरण:

> Fun = fun(K,V,AccIn) when is_list(K) -> AccIn + V end,
  Map = #{"k1" => 1, "k2" => 2, "k3" => 3},
  maps:fold(Fun,0,Map).
6
from_list (सूची) -> नक्शा

प्रकार

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

उदाहरण:

> List = [{"a",ignored},{1337,"value two"},{42,value_three},{"a",1}],
  maps:from_list(List).
#{42 => value_three,1337 => "value two","a" => 1}
get (की, मैप) -> मान

प्रकार

यदि Map में Key शामिल है, तो Key संबंधित मान लौटाता है।

यदि Map कोई मानचित्र नहीं है या {badkey,Key} अपवाद के साथ यदि कोई मान Key से संबद्ध नहीं है, तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Key = 1337,
  Map = #{42 => value_two,1337 => "value one","a" => 1},
  maps:get(Key,Map).
"value one"
get (की, मैप, डिफॉल्ट) -> वैल्यू | चूक

प्रकार

यदि Map में Key शामिल है, तो Key संबंधित मान लौटाता है। यदि कोई मान Key से संबद्ध नहीं है, तो Default लौटाया जाता है।

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map = #{ key1 => val1, key2 => val2 }.
#{key1 => val1,key2 => val2}
> maps:get(key1, Map, "Default value").
val1
> maps:get(key3, Map, "Default value").
"Default value"
is_key (कुंजी, मानचित्र) -> बूलियन ()

प्रकार

यदि Map में Key true तो true यदि Key में नहीं है तो यह false

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map = #{"42" => value}.
#{"42" => value}
> maps:is_key("42",Map).
true
> maps:is_key(value,Map).
false
itter (मैप) -> इटरेटर

प्रकार

एक मैप इटेटर Iterator लौटाता है जिसका उपयोग maps:next/1 द्वारा किया जा सकता है maps:next/1 मैप में कुंजी-मूल्य संघों को पार करने के लिए। जब एक मानचित्र पर पुनरावृत्ति होती है, तो स्मृति उपयोग को बिना किसी मानचित्र के आकार के बाध्य होने की गारंटी दी जाती है।

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> M = #{ a => 1, b => 2 }.
#{a => 1,b => 2}
> I = maps:iterator(M).
[{a,1},{b,2}]
> {K1, V1, I2} = maps:next(I).
{a,1,[{b,2}]}
> {K2, V2, I3} = maps:next(I2).
{b,2,[]}
> maps:next(I3).
none
चाबियाँ (मानचित्र) -> कुंजी

प्रकार

किसी भी क्रम में कुंजियों की एक पूरी सूची देता है, जो Map भीतर रहता है।

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map = #{42 => value_three,1337 => "value two","a" => 1},
  maps:keys(Map).
[42,1337,"a"]
नक्शा (मज़ा, MapOrIter) -> मानचित्र

प्रकार

किसी भी क्रम में MapOrIter में V1 एसोसिएशन को महत्व देने के लिए हर K लिए फ़ंक्शन fun F(K, V1) को कॉल करके एक नया मैप मैप का उत्पादन करता है। fun F/2 को नए मैप मैप के लिए कुंजी K साथ जुड़े रहने के लिए वेल्यू V2 को वापस करना होगा।

यदि MapOrIter मैप 2 का फ़ंक्शन नहीं है या यदि badarg 2 का फ़ंक्शन नहीं है, तो MapOrIter या मान्य MapOrIter नहीं है, या badarg साथ कॉल विफल हो जाता है।

उदाहरण:

> Fun = fun(K,V1) when is_list(K) -> V1*2 end,
  Map = #{"k1" => 1, "k2" => 2, "k3" => 3},
  maps:map(Fun,Map).
#{"k1" => 2,"k2" => 4,"k3" => 6}
मर्ज (Map1, Map2) -> Map3

प्रकार

एक ही नक्शे Map3 में दो नक्शे Map3 । यदि दोनों मानचित्रों में दो चाबियां मौजूद हैं, तो Map1 में मान Map2 में मान से अलग है।

यदि Map1 या मैप 2 मैप नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map1 = #{a => "value_one", b => "value_two"},
  Map2 = #{a => 1, c => 2},
  maps:merge(Map1,Map2).
#{a => 1,b => "value_two",c => 2}
नया () -> मानचित्र

प्रकार

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

उदाहरण:

> maps:new().
#{}
अगला (Iterator) -> {कुंजी, मान, NextIterator} | कोई नहीं

प्रकार

Iterator में अगले कुंजी-मूल्य संघ और Iterator में शेष संघों के लिए एक नया पुनरावृत्ति देता है।

यदि पुनरावृति में अधिक संघ नहीं हैं, तो none भी वापस none जाता है।

उदाहरण:

> Map = #{a => 1, b => 2, c => 3}.
#{a => 1,b => 2,c => 3}
> Iter = maps:iterator(Map).
[{a,1},{b,2},{c,3}]
> {_, _, Iter1} = maps:next(Iter).
{a,1,[{b,2},{c,3}]}
> {_, _, Iter2} = maps:next(Iter1).
{b,2,[{c,3}]}
> {_, _, Iter3} = maps:next(Iter2).
{c,3,[]}
> maps:next(Iter3).
none
put (की, वैल्यू, मैप 1) -> मैप 2

प्रकार

मूल्य Value साथ एसोसिएट्स Key और मैप 2 में एसोसिएशन को सम्मिलित करता है। यदि मुख्य Key पहले से ही मैप Map1 में मौजूद है, तो पुराने संबद्ध मूल्य को मूल्य मान से बदल दिया जाता है। फ़ंक्शन मैप 1 में एक नया मैप मैप 2 देता है जिसमें नए एसोसिएशन और पुराने एसोसिएशन Map1

यदि कॉल मैप नहीं है तो {badmap,Map} अपवाद के साथ कॉल विफल हो जाता है।

उदाहरण:

> Map = #{"a" => 1}.
#{"a" => 1}
> maps:put("a", 42, Map).
#{"a" => 42}
> maps:put("b", 1337, Map).
#{"a" => 1,"b" => 1337}
निकालें (कुंजी, Map1) -> Map2

प्रकार

Key निकालता है, अगर यह मौजूद है, और मैप 1 से इसका संबद्ध मूल्य और बिना चाबी के बिना एक नया मैप मैप 2 देता है।

यदि कॉल मैप नहीं है तो {badmap,Map} अपवाद के साथ कॉल विफल हो जाता है।

उदाहरण:

> Map = #{"a" => 1}.
#{"a" => 1}
> maps:remove("a",Map).
#{}
> maps:remove("b",Map).
#{"a" => 1}
आकार (मानचित्र) -> पूर्णांक ()> = 0

प्रकार

Map में कुंजी-मूल्य संघों की संख्या लौटाता है। यह ऑपरेशन निरंतर समय में होता है।

उदाहरण:

> Map = #{42 => value_two,1337 => "value one","a" => 1},
  maps:size(Map).
3
take (की, Map1) -> {मान, Map2} | त्रुटि

प्रकार

फ़ंक्शन Key को हटा देता है, यदि यह मौजूद है, और Map1 से इसका संबद्ध मूल्य और कुंजी के बिना हटाए गए Value और नए मैप मैप 2 के साथ एक टपल लौटाता है। यदि कुंजी मौजूद नहीं है तो error वापस आ जाती है।

यदि Map1 कोई मानचित्र नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाएगी।

उदाहरण:

> Map = #{"a" => "hello", "b" => "world"}.
#{"a" => "hello", "b" => "world"}
> maps:take("a",Map).
{"hello",#{"b" => "world"}}
> maps:take("does not exist",Map).
error
to_list (मानचित्र) -> [{कुंजी, मान}]

प्रकार

Map के प्रमुख-मूल्य संघों का प्रतिनिधित्व करने वाले जोड़ों की सूची लौटाता है, जहां जोड़े [{K1,V1}, ..., {Kn,Vn}] मनमाने क्रम में वापस किए जाते हैं।

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map = #{42 => value_three,1337 => "value two","a" => 1},
  maps:to_list(Map).
[{42,value_three},{1337,"value two"},{"a",1}]
अद्यतन (कुंजी, मूल्य, Map1) -> Map2

प्रकार

यदि Map1 में Key मौजूद है, तो पुराने संबद्ध मान को मान मान से बदल दिया जाता है। फ़ंक्शन नया मैप मैप 2 देता है जिसमें नया संबद्ध मान होता है।

यदि कोई मैप से संबंधित नहीं है, तो कॉल 1 एक {badmap,Map} अपवाद के साथ विफल रहता है {badmap,Map} अगर मैप 1 कोई मैप नहीं है, या {badkey,Key} अपवाद के साथ है।

उदाहरण:

> Map = #{"a" => 1}.
#{"a" => 1}
> maps:update("a", 42, Map).
#{"a" => 42}
update_with (की, फन, मैप 1) -> मैप २

प्रकार

नया मान प्राप्त करने के लिए पुराने मूल्य पर Fun कहकर Key से जुड़े Map1 में एक मान अपडेट करें। यदि मानचित्र में Key मौजूद नहीं है तो एक अपवाद {badkey,Key} उत्पन्न होता है।

उदाहरण:

> Map = #{"counter" => 1},
  Fun = fun(V) -> V + 1 end,
  maps:update_with("counter",Fun,Map).
#{"counter" => 2}
update_with (की, फन, इनिट, मैप 1) -> मैप २

प्रकार

नया मान प्राप्त करने के लिए पुराने मूल्य पर Fun कहकर Key से जुड़े Map1 में एक मान अपडेट करें। यदि Key Map1 1 में मौजूद नहीं है, तो Init Key के साथ जुड़ा होगा।

उदाहरण:

> Map = #{"counter" => 1},
  Fun = fun(V) -> V + 1 end,
  maps:update_with("new counter",Fun,42,Map).
#{"counter" => 1,"new counter" => 42}
मान (मानचित्र) -> मान

प्रकार

मानचित्र Map में निहित, मनमाने क्रम में मूल्यों की एक पूरी सूची देता है।

यदि Map नहीं है तो कॉल {badmap,Map} अपवाद के साथ विफल हो जाती है।

उदाहरण:

> Map = #{42 => value_three,1337 => "value two","a" => 1},
  maps:values(Map).
[value_three,"value two",1]
(Ks, Map1) के साथ -> Map2

प्रकार

Map1 माध्यम से चाबियाँ K1 और मानचित्र Map1 से उनके संबंधित मूल्यों के साथ एक नया नक्शा Map2 Map1 Map1 1 में मौजूद Ks किसी भी कुंजी को अनदेखा नहीं किया गया है।

उदाहरण:

> Map = #{42 => value_three,1337 => "value two","a" => 1},
  Ks = ["a",42,"other key"],
  maps:with(Ks,Map).
#{42 => value_three,"a" => 1}
बिना (Ks, Map1) -> Map2

प्रकार

Kn माध्यम से K1 बिना एक नया मैप Map2 लौटाता है और Map1 मैप से उनके संबंधित मूल्य। Map1 1 में मौजूद Ks किसी भी कुंजी को अनदेखा नहीं किया गया है

उदाहरण:

> Map = #{42 => value_three,1337 => "value two","a" => 1},
  Ks = ["a",42,"other key"],
  maps:without(Ks,Map).
#{1337 => "value two"}