Elixir Language
सूचियाँ

वाक्य - विन्यास

• []
• [१, २, ३, ४]
• [१, २] ++ [३, ४] # -> [१,२,३,४]
• एचडी ([1, 2, 3, 4]) # -> 1
• tl ([1, 2, 3, 4]) # -> [2,3,4]
• [सिर | पूंछ]
• [१ | [२, ३, ४]] # -> [१,२,३,४]
• [१ | [२ | [३ | [४ | []]]]] -> [१,२,३,४]
• 'हैलो' = [? एच; ई; ई? एल; एल; ओ; ओ]
• keyword_list = [a: 123, b: 456, c: 789]
• keyword_list [: a] # -> 123

कीवर्ड सूची

कीवर्ड सूचियां वे सूचियां हैं जहां सूची में प्रत्येक आइटम एक परमाणु का एक टपल है जिसके बाद एक मूल्य है।

keyword_list = [{:a, 123}, {:b, 456}, {:c, 789}]

कीवर्ड सूचियों को लिखने के लिए एक आशुलिपि अंकन इस प्रकार है:

keyword_list = [a: 123, b: 456, c: 789]

कीवर्ड सूचियाँ आदेशित की-वैल्यू पेयर डेटा स्ट्रक्चर्स बनाने के लिए उपयोगी हैं, जहाँ दिए गए कुंजी के लिए कई आइटम मौजूद हो सकते हैं।

किसी दिए गए कुंजी के लिए कीवर्ड सूची में पहला आइटम इस तरह प्राप्त किया जा सकता है:

iex> keyword_list[:b]
456

कीवर्ड सूचियों का उपयोग मामला चलाने के लिए नामित कार्यों का एक क्रम हो सकता है:

defmodule TaskRunner do
  def run_tasks(tasks) do
    # Call a function for each item in the keyword list.
    # Use pattern matching on each {:key, value} tuple in the keyword list
    Enum.each(tasks, fn
      {:delete, x} ->
        IO.puts("Deleting record " <> to_string(x) <> "...")
      {:add, value} ->
        IO.puts("Adding record \"" <> value <> "\"...")
      {:update, {x, value}} ->
        IO.puts("Setting record " <> to_string(x) <> " to \"" <> value <> "\"...")
    end)
  end
end

इस कोड को कीवर्ड सूची के साथ बुलाया जा सकता है:

iex> tasks = [
...>   add: "foo",
...>   add: "bar",
...>   add: "test",
...>   delete: 2,
...>   update: {1, "asdf"}
...> ]

iex> TaskRunner.run_tasks(tasks)
Adding record "foo"...
Adding record "bar"...
Adding record "test"...
Deleting record 2...
Setting record 1 to "asdf"...

चार सूचियाँ

अमृत में तार "बायनेरिज़" हैं। हालाँकि, एरलांग कोड में, तार पारंपरिक रूप से "चार सूचियाँ" हैं, इसलिए जब Erlang फ़ंक्शन को कॉल करते हैं, तो आपको नियमित रूप से अमृत स्ट्रिंग के बजाय चार सूचियों का उपयोग करना पड़ सकता है।

जबकि नियमित रूप से तार दोहरे उद्धरण चिह्नों का उपयोग कर लिखा जाता है " , चार सूचियों एकल उद्धरण का उपयोग कर लिखा जाता है ' :

string = "Hello!"
char_list = 'Hello!'

चार सूचियाँ केवल प्रत्येक वर्ण के कोड बिंदुओं का प्रतिनिधित्व करने वाले पूर्णांकों की सूची हैं।

'hello' = [104, 101, 108, 108, 111]

एक स्ट्रिंग को to_charlist/1 साथ एक to_charlist/1 सूची में परिवर्तित किया जा सकता है:

iex> to_charlist("hello")
'hello'

और रिवर्स को to_string/1 साथ किया जा सकता है:

iex> to_string('hello')
"hello"

एक एरलांग फ़ंक्शन को कॉल करना और आउटपुट को एक नियमित अमृत स्ट्रिंग में परिवर्तित करना:

iex> :os.getenv |> hd |> to_string
"PATH=/usr/local/bin:/usr/bin:/bin"

विपक्ष सेल

Elixir की सूचियाँ लिस्टेड हैं। इसका मतलब है कि सूची में प्रत्येक आइटम में एक मान होता है, उसके बाद सूची में अगले आइटम के लिए एक सूचक होता है। यह एलिक्सिर में खराब कोशिकाओं का उपयोग करके कार्यान्वित किया जाता है।

विपक्ष कोशिकाओं एक "छोड़ दिया" और एक "सही" मूल्य, या एक "सिर" और एक "पूंछ" के साथ सरल डेटा संरचनाएं हैं।

ए | किसी दिए गए सिर और पूंछ के साथ (अनुचित) सूची को नोट करने के लिए सूची में अंतिम आइटम से पहले प्रतीक जोड़ा जा सकता है। निम्नलिखित 1 साथ एक एकल कंस सेल है और 2 पूंछ के रूप में है:

[1 | 2]

एक सूची के लिए मानक अमृत सिंटैक्स वास्तव में नेस्टेड कॉन्स कोशिकाओं की एक श्रृंखला लिखने के बराबर है:

[1, 2, 3, 4] = [1 | [2 | [3 | [4 | []]]]]

किसी सूची के अंत का प्रतिनिधित्व करने के लिए खाली सूची [] का उपयोग एक वाणिज्य सेल की पूंछ के रूप में किया जाता है।

एलिक्जिर की सभी सूचियाँ फॉर्म के बराबर हैं [head | tail] , जहां head सूची का पहला आइटम है और tail सूची का शेष भाग है, सिर को घटाती है।

iex> [head | tail] = [1, 2, 3, 4]
[1, 2, 3, 4]
iex> head
1
iex> tail
[2, 3, 4]

[head | tail] का उपयोग करना [head | tail] पुनरावर्ती कार्यों में पैटर्न मिलान के लिए अंकन उपयोगी है:

def sum([]), do: 0

def sum([head | tail]) do
  head + sum(tail)
end

मैपिंग सूची

map कार्यात्मक प्रोग्रामिंग में एक फ़ंक्शन है जिसने एक सूची और एक फ़ंक्शन दिया, उस सूची में प्रत्येक आइटम पर लागू फ़ंक्शन के साथ एक नई सूची देता है। अमृत में, map/2 फ़ंक्शन एनम मॉड्यूल में है।

iex> Enum.map([1, 2, 3, 4], fn(x) -> x + 1 end)
[2, 3, 4, 5]

अनाम फ़ंक्शंस के लिए वैकल्पिक कैप्चर सिंटैक्स का उपयोग करना:

iex> Enum.map([1, 2, 3, 4], &(&1 + 1))
[2, 3, 4, 5]

कैप्चर सिंटैक्स के साथ एक फ़ंक्शन का संदर्भ:

iex> Enum.map([1, 2, 3, 4], &to_string/1)
["1", "2", "3", "4"]

पाइप ऑपरेटर का उपयोग करके सूची संचालन का काम:

iex> [1, 2, 3, 4]
...> |> Enum.map(&to_string/1)
...> |> Enum.map(&("Chapter " <> &1))
["Chapter 1", "Chapter 2", "Chapter 3", "Chapter 4"]

सूची की समझ

अमृत में लूप नहीं है। उनके बजाय सूचियों के लिए महान Enum और List मॉड्यूल हैं, लेकिन सूची की समझ भी है।

सूची बोध उपयोगी हो सकता है:

• नई सूची बनाएं

iex(1)> for value <- [1, 2, 3], do: value + 1
[2, 3, 4] 

• फ़िल्टरिंग लिस्ट, guard एक्सप्रेशंस का उपयोग करके लेकिन when कीवर्ड के बिना उनका उपयोग करते हैं।

iex(2)> odd? = fn x -> rem(x, 2) == 1 end
iex(3)> for value <- [1, 2, 3], odd?.(value), do: value
[1, 3]

• कस्टम बनाने के नक्शे, का उपयोग कर into कीवर्ड:

iex(4)> for value <- [1, 2, 3], into: %{}, do: {value, value + 1}
%{1 => 2, 2=>3, 3 => 4}

संयुक्त उदाहरण

iex(5)> for value <- [1, 2, 3], odd?.(value), into: %{}, do: {value, value * value}
%{1 => 1, 3 => 9}

सारांश

सूची की समझ:

• सूचियों की तुलना में अन्य संरचना को वापस करते समय अल्पविराम और कीवर्ड into अतिरिक्त गार्ड के for..do सिंटैक्स का उपयोग करता है। नक्शा।
• अन्य मामलों में नई सूची लौटाते हैं
• संचायक का समर्थन नहीं करता है
• जब कुछ शर्त पूरी हो जाती है तो प्रसंस्करण बंद नहीं कर सकते
• guard बयान के बाद के क्रम में पहले होना है for और इससे पहले कि do या into प्रतीकों। प्रतीकों का क्रम मायने नहीं रखता

इन बाधाओं के अनुसार सूची बोध केवल सरल उपयोग के लिए सीमित हैं। Enum और List मॉड्यूल से कार्यों का उपयोग करने वाले अधिक उन्नत मामलों में सबसे अच्छा विचार होगा।

सूची का अंतर

iex> [1, 2, 3] -- [1, 3]
[2]

-- दाईं ओर प्रत्येक आइटम के लिए बाईं सूची में किसी आइटम की पहली घटना को हटाता है।

सूची सदस्यता

यदि कोई तत्व किसी सूची का सदस्य है, यह जाँचने के लिए ऑपरेटर in उपयोग करें।

iex> 2 in [1, 2, 3]
true
iex> "bob" in [1, 2, 3]
false

मानचित्र में सूचियों को परिवर्तित करना

समूह के तत्वों को उप-सूचियों में Enum.chunk/2 का उपयोग करें, और Map.new/2 को मानचित्र में बदलने के लिए:

[1, 2, 3, 4, 5, 6]
|> Enum.chunk(2)
|> Map.new(fn [k, v] -> {k, v} end)

देना होगा:

%{1 => 2, 3 => 4, 5 => 6}