मैप में

मैप के बारे में

मैप एक डेटा स्ट्रक्चर है जो की-वैल्यू जोड़े रखता है।

• की किसी भी टाइप की हो सकती हैं, लेकिन हर की यूनीक होनी ज़रूरी है।

• वैल्यू किसी भी टाइप की हो सकती हैं, उनका यूनीक होना ज़रूरी नहीं है।

• मैप अपने अंदर रखी चीज़ों का क्रम तय रहने की गारंटी नहीं देते, भले ही ऐसा लगता हो कि क्रम तय है।

  • भीतर से इन्हें जिस तरह लागू किया गया है, उसी से यह भ्रम पैदा होता है:
    • छोटे आकार (32 या उससे कम एंट्री) में इन्हें एक क्रमबद्ध कीवर्ड लिस्ट की तरह लागू किया जाता है।
    • बड़े आकार (32 से ज़्यादा एंट्री) में इन्हें एक हैश ऐरे मैप्ड ट्राई [1] की तरह लागू किया जाता है।

• मैप को लिटरल रूप में घोषित किया जा सकता है:

  # An empty map
  %{}
  
  # A map with the atom key :a associated to the integer value 1
  %{a: 1}
  
  # A map with the string key "a" associated to the float value 2.0
  %{"a" => 2.0}
  
  # A map with the map key %{} with the list value [1 ,2, 3]
  %{%{} => [1, 2, 3]}
  
  # A map with keys of different types
  %{:a => 1, "b" => 2}
  

• मैप को Map मॉड्यूल के Map.new की मदद से भी बनाया जा सकता है। इसका इस्तेमाल तब किया जा सकता है जब आपके पास पहले से कोई एन्यूमरेबल कलेक्शन हो जिसे ऐरे में बदलना हो:

  kw_list = [a: 1, b: 2]
  Map.new(kw_list)
  # => %{a: 1, b: 2}
  

• मैप की वैल्यू तक कई अलग-अलग तरीकों से पहुँचा जा सकता है:

  my_map = %{key: "value"}
  
  # with a dot if the key is an atom
  my_map.key
  # => "value"
  
  # with [], a syntax provided by the Access behaviour
  my_map[:key]
  # => "value"
  
  # with pattern matching
  %{key: x} = my_map
  x
  # => "value"
  
  # with Map.get/2
  Map.get(my_map, :key)
  # => "value"
  

• स्टैंडर्ड लाइब्रेरी के साथ दिए गए Map मॉड्यूल में मैप इस्तेमाल करने के लिए कई काम के फंक्शन हैं।

  Map.delete(%{a: 2, b: 3}, :a)
  # => %{b: 3}
  

• मैप Enumerable प्रोटोकॉल लागू करते हैं, जिससे Enum मॉड्यूल के फंक्शन भी इस्तेमाल किए जा सकते हैं।

• Map और Enum मॉड्यूल के फंक्शनों को आर्गुमेंट के तौर पर अक्सर अनॉनिमस फंक्शन या कैप्चर किए गए फंक्शन रेफरेंस देने पड़ते हैं

  # Increment the value by one, if it is not found, update it with 0
  Map.update(%{a: 1}, :a, 0, &(&1 + 1))
  # => %{a: 2}
  
  # Sorting by a specific sub-value
  list = [{"A", 4}, {"B", 3}, {"C", 2}, {"D", 1}]
  Enum.sort_by(list, &Kernel.elem(&1, 1))
  # => [{"D", 1}, {"C", 2}, {"B", 3}, {"A", 4}]