Elixir 1.7 - Access

पहुंच का व्यवहार




elixir

पहुंच का व्यवहार

डेटा संरचनाओं के लिए कुंजी-आधारित पहुंच।

अमृत ​​तीन मुख्य कुंजी-मूल्य निर्माणों का समर्थन करता है: कीवर्ड, मानचित्र और संरचना। यह उन कुंजियों तक पहुंचने के लिए दो तंत्रों का भी समर्थन करता है: कोष्ठक ( data[key] ) और डॉट-सिंटैक्स द्वारा ( data[key] माध्यम से)।

अगले भाग में हम संक्षेप में मुख्य-मूल्य निर्माणों को फिर से तैयार करेंगे और फिर पहुँच तंत्र पर चर्चा करेंगे।

कुंजी-मूल्य का निर्माण करता है

अमृत ​​तीन मुख्य कुंजी-मूल्य निर्माण प्रदान करता है, जिसका सारांश नीचे दिया गया है:

  • कीवर्ड सूची - वे दो-तत्व ट्यूपल्स की सूची हैं जहां पहला तत्व एक परमाणु है। आमतौर पर [key: value] सिंटैक्स में लिखा जाता है, वे केवल परमाणु कुंजी का समर्थन करते हैं। फ़ंक्शन और मैक्रोज़ के विकल्पों को पास करने के लिए कीवर्ड सूचियों का उपयोग लगभग विशेष रूप से किया जाता है। वे उपयोगकर्ता को आदेश देते रहते हैं और डुप्लिकेट कुंजियों की अनुमति देते हैं। Keyword मॉड्यूल देखें।

  • नक्शे - वे एलिक्सिर में "गो टू" की-वैल्यू डेटा संरचना हैं। वे किसी भी प्रकार की अरबों चाबियों का समर्थन करने में सक्षम हैं। वे %{key => value} सिंटैक्स का उपयोग करके लिखे गए हैं और कुंजी के परमाणुओं होने पर %{key: value} सिंटैक्स का भी समर्थन करते हैं। उनके पास कोई निर्दिष्ट आदेश नहीं है और डुप्लिकेट कुंजियों की अनुमति नहीं देते हैं। Map मॉड्यूल देखें।

  • संरचनाएं - उन्हें नक्शे का नाम पूर्व-निर्धारित कुंजी के साथ दिया जाता है। उन्हें defstruct/1 साथ परिभाषित किया गया है और %StructName{key: value} का उपयोग करके लिखा गया है %StructName{key: value} syntax।

की-बेस्ड एक्सेसर्स

अमृत ​​मुख्य रूप से डेटा संरचनाओं तक पहुंचने के लिए दो तंत्र प्रदान करता है, जिसे अगले वर्णित किया गया है।

ब्रैकेट-आधारित पहुंच

data[key] सिंटैक्स का उपयोग डेटा संरचनाओं को कुंजीशब्दों और मानचित्रों की एक गतिशील संख्या के साथ एक्सेस करने के लिए किया जाता है। कुंजी किसी भी प्रकार की हो सकती है। यदि कुंजी मौजूद नहीं है, तो ब्रैकेट-आधारित एक्सेस सिंटैक्स nil हो जाता है:

iex> keywords = [a: 1, b: 2]
iex> keywords[:a]
1
iex> keywords[:c]
nil

iex> map = %{a: 1, b: 2}
iex> map[:a]
1

iex> star_ratings = %{1.0 => "★", 1.5 => "★☆", 2.0 => "★★"}
iex> star_ratings[1.5]
"★☆"

यह सिंटैक्स बहुत सुविधाजनक है क्योंकि इसे मनमाने ढंग से घोंटा जा सकता है:

iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
iex> put_in(users["john"][:age], 28)
%{"john" => %{age: 28}, "meg" => %{age: 23}}

इसके अलावा, ब्रैकेट-आधारित एक्सेस सिंटैक्स पारदर्शी रूप से nil मानों की उपेक्षा करता है। nil मान पर कुछ भी एक्सेस करने का प्रयास करते समय, nil लौटाया जाता है:

iex> keywords = [a: 1, b: 2]
iex> keywords[:c][:unknown]
nil

iex> nil[:a]
nil

आंतरिक रूप से, data[key] Access.get(term, key, nil) । अपने स्वयं के कुंजी-मूल्य डेटा संरचनाओं को लागू करने में रुचि रखने वाले डेवलपर्स ब्रैकेट-आधारित एक्सेस सिंटैक्स प्रदान करने के लिए Access व्यवहार को लागू कर सकते हैं। Access को ===/2 ऑपरेटर का उपयोग करके लागू करने के लिए महत्वपूर्ण तुलना की आवश्यकता होती है।

डॉट-आधारित सिंटैक्स

data.field सिंटैक्स का उपयोग विशेष रूप से मानचित्र और संरचना में परमाणु क्षेत्रों तक पहुंचने के लिए किया जाता है। यदि पहुँच फ़ील्ड मौजूद नहीं है, तो एक त्रुटि उठाई गई है। यह एक जानबूझकर किया गया निर्णय है: क्योंकि किसी संरचना के सभी क्षेत्र पूर्व-निर्धारित हैं, इसलिए संरचनाएं केवल डॉट-आधारित सिंटैक्स का समर्थन करती हैं और एक का उपयोग नहीं करती हैं।

एक :name फ़ील्ड के साथ User नाम की एक संरचना की कल्पना करें। निम्नलिखित उठाएंगे:

user = %User{name: "John"}
user[:name]
# ** (UndefinedFunctionError) undefined function User.fetch/2 (User does not implement the Access behaviour)

इसके बजाय हमें खेतों तक पहुँचने के लिए user.name सिंटैक्स का उपयोग करना चाहिए:

user.name
#=> "John"

user[:name] से भिन्न रूप से, user.name एक व्यवहार के माध्यम से एक्स्टेंसिबल नहीं है और केवल नक्शे में संरचना और परमाणु कुंजी तक ही सीमित है।

उपसंहार

ब्रैकेट-आधारित सिंटैक्स, user[:name] , गतिशील संरचनाओं द्वारा उपयोग किया जाता है, एक्स्टेंसिबल है और गलत कुंजी पर रिटर्न देता है।

डॉट-बेस्ड सिंटैक्स, user.name , का उपयोग विशेष रूप से मैप्स और स्ट्रक्चर्स में एटम कीज को एक्सेस करने के लिए किया जाता है, और यह लापता कीज़ पर उठता है।

नेस्टेड डेटा संरचनाएँ

दोनों कुंजी-आधारित एक्सेस Kernel.get_in/2 Kernel में Kernel.get_in/2 अपडेट फ़ंक्शंस और मैक्रोज़ के साथ किया जा सकता है, जैसे कि Kernel.get_in/2 , Kernel.put_in/3 , Kernel.update_in/3 , Kernel.pop_in/2 , और Kernel.get_and_update_in/3

उदाहरण के लिए, किसी अन्य मानचित्र के अंदर मानचित्र को अपडेट करने के लिए:

iex> उपयोगकर्ता =% {"जॉन" =>% {आयु: 27}, "मेग" =>% {आयु: 23}} iex> put_in (उपयोगकर्ता ["जॉन"]। आयु, 28)% {"जॉन"। =>% {आयु: 28}, "मेग" =>% {आयु: 23}}

यह मॉड्यूल अन्य संरचनाएं जैसे टुपल्स और सूचियों को ट्रैवर्स करने के लिए सुविधा प्रदान करता है। इन फ़ंक्शंस का उपयोग Kernel में सभी Access संबद्ध कार्यों और मैक्रोज़ में किया जा सकता है।

उदाहरण के लिए, :name और :languages कुंजियों के साथ एक उपयोगकर्ता मानचित्र दिया गया है, यहाँ बताया गया है कि नक्शे को कैसे गहरा किया जाए और सभी भाषा नामों को अपरकेस में परिवर्तित किया जाए:

iex> languages = [
...>   %{name: "elixir", type: :functional},
...>   %{name: "c", type: :procedural},
...> ]
iex> user = %{name: "john", languages: languages}
iex> update_in(user, [:languages, Access.all(), :name], &String.upcase/1)
%{name: "john",
  languages: [%{name: "ELIXIR", type: :functional},
              %{name: "C", type: :procedural}]}

कुछ उपलब्ध elem/1 के लिए फ़ंक्शन key/1 , key!/1 , elem/1 , और all/0

सारांश

प्रकार

access_fun (डेटा, get_value)
any_container()
container()
get_and_update_fun (डेटा, get_value)
get_fun (डेटा, get_value)
key()
nil_container()
t()
value()

कार्य

all/0

एक फ़ंक्शन देता है जो किसी सूची में सभी तत्वों को एक्सेस करता है

at(index)

किसी फ़ंक्शन को index के तत्व (शून्य आधारित) पर पहुंचता है

elem/1

एक फ़ंक्शन देता है जो तत्व को टपल में दिए गए इंडेक्स में एक्सेस करता है

लाने (कंटेनर, कुंजी)

किसी कंटेनर में दी गई कुंजी का मान प्राप्त करता है (एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करती है)

filter(func)

एक फ़ंक्शन देता है जो सूची के सभी तत्वों को एक्सेस करता है जो प्रदान किए गए विधेय से मेल खाता है

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

कंटेनर में दी गई कुंजी के लिए मान प्राप्त होता है (एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करती है)

get_and_update (कंटेनर, कुंजी, मज़ा)

container में दी गई कुंजी को जाता है और अपडेट करता है (एक नक्शा, एक कीवर्ड सूची, एक संरचना जो Access व्यवहार को लागू करता है)

key!/1

एक फ़ंक्शन देता है जो किसी मानचित्र / संरचना में दी गई कुंजी तक पहुंचता है

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

एक फ़ंक्शन देता है जो किसी मानचित्र / संरचना में दी गई कुंजी तक पहुंचता है

पॉप (कंटेनर, कुंजी)

कंटेनर से दी गई कुंजी के साथ प्रविष्टि को हटाता है (एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करता है)

कॉलबैक

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

दी गई अवधि में key तहत संग्रहीत मूल्य तक पहुंचने के लिए आमंत्रित किया गया है

get_and_update (डेटा, कुंजी, फ़ंक्शन)

मूल्य को key तहत एक्सेस करने और उसी समय अपडेट करने के लिए इनवाइट किया गया

पॉप (डेटा, कुंजी)

दिए गए डेटा संरचना से बाहर key तहत मूल्य "पॉप" करने के लिए आमंत्रित किया

प्रकार

access_fun (डेटा, get_value)

access_fun(data, get_value) ::
  get_fun(data, get_value) | get_and_update_fun(data, get_value)

any_container ()

any_container() :: any()

कंटेनर ()

container() :: keyword() | struct() | map()

get_and_update_fun (डेटा, get_value)

get_and_update_fun(data, get_value) ::
  (:get_and_update, data, (term() -> term()) ->
     {get_value, new_data :: container()} | :pop)

get_fun (डेटा, get_value)

get_fun(data, get_value) ::
  (:get, data, (term() -> term()) -> {get_value, new_data :: container()})

कुंजी ()

key() :: any()

nil_container ()

nil_container() :: nil

टी ()

t() :: container() | nil_container() | any_container()

मूल्य ()

value() :: any()

कार्य

सब()

all() :: access_fun(data :: list(), get_value :: list())

एक फ़ंक्शन देता है जो किसी सूची में सभी तत्वों को एक्सेस करता है।

लौटाया गया फ़ंक्शन आमतौर पर Kernel.get_in/2 , Kernel.get_and_update_in/3 , और दोस्तों के Kernel.get_in/2 रूप में पास किया जाता है।

उदाहरण

iex> list = [%{name: "john"}, %{name: "mary"}]
iex> get_in(list, [Access.all(), :name])
["john", "mary"]
iex> get_and_update_in(list, [Access.all(), :name], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
iex> pop_in(list, [Access.all(), :name])
{["john", "mary"], [%{}, %{}]}

यहां एक उदाहरण दिया गया है कि सूची को छोड़ने वाली संख्याओं का पता लगाता है और विषम संख्याओं को 2 से गुणा करता है:

iex> require Integer
iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn num ->
...>   if Integer.is_even(num), do: :pop, else: {num, num * 2}
...> end)
{[1, 2, 3, 4, 5], [2, 6, 10]}

यदि कोई एक्सेस की गई सूची नहीं है, तो त्रुटि उठाई जाती है:

iex> get_in(%{}, [Access.all()])
** (RuntimeError) Access.all/0 expected a list, got: %{}

पर (इंडेक्स)

at(non_neg_integer()) :: access_fun(data :: list(), get_value :: term())

किसी फ़ंक्शन को index के तत्व (शून्य आधारित) पर पहुंचता है।

लौटाया गया फ़ंक्शन आमतौर पर Kernel.get_in/2 , Kernel.get_and_update_in/3 , और दोस्तों के Kernel.get_in/2 रूप में पास किया जाता है।

उदाहरण

iex> list = [%{name: "john"}, %{name: "mary"}]
iex> get_in(list, [Access.at(1), :name])
"mary"
iex> get_and_update_in(list, [Access.at(0), :name], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{"john", [%{name: "JOHN"}, %{name: "mary"}]}

at(index) उपयोग सूची के बाहर तत्वों या सूची के अंदर एक कुंजी को पॉप करने के लिए भी किया जा सकता है:

iex> list = [%{name: "john"}, %{name: "mary"}]
iex> pop_in(list, [Access.at(0)])
{%{name: "john"}, [%{name: "mary"}]}
iex> pop_in(list, [Access.at(0), :name])
{"john", [%{}, %{name: "mary"}]}

जब सूचकांक सीमा से बाहर हो जाता है, तो nil वापस आ जाता है और अपडेट फ़ंक्शन को कभी नहीं कहा जाता है:

iex> list = [%{name: "john"}, %{name: "mary"}]
iex> get_in(list, [Access.at(10), :name])
nil
iex> get_and_update_in(list, [Access.at(10), :name], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{nil, [%{name: "john"}, %{name: "mary"}]}

नकारात्मक अनुक्रमित के लिए एक त्रुटि उठाई गई है:

iex> get_in([], [Access.at(-1)])
** (FunctionClauseError) no function clause matching in Access.at/1

यदि कोई एक्सेस की गई सूची नहीं है, तो त्रुटि उठाई जाती है:

iex> get_in(%{}, [Access.at(1)])
** (RuntimeError) Access.at/1 expected a list, got: %{}

ELEM (इंडेक्स)

elem(non_neg_integer()) :: access_fun(data :: tuple(), get_value :: term())

एक फ़ंक्शन देता है जो तत्व को टपल में दिए गए इंडेक्स में एक्सेस करता है।

लौटाया गया फ़ंक्शन आमतौर पर Kernel.get_in/2 , Kernel.get_and_update_in/3 , और दोस्तों के Kernel.get_in/2 रूप में पास किया जाता है।

यदि index सीमा से बाहर है, तो वापस लौटाया गया फ़ंक्शन उठाता है।

ध्यान दें कि टुपल्स से बाहर तत्वों को पॉप करना संभव नहीं है और एक त्रुटि उठाता है।

उदाहरण

iex> map = %{user: {"john", 27}}
iex> get_in(map, [:user, Access.elem(0)])
"john"
iex> get_and_update_in(map, [:user, Access.elem(0)], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{"john", %{user: {"JOHN", 27}}}
iex> pop_in(map, [:user, Access.elem(0)])
** (RuntimeError) cannot pop data from a tuple

यदि एक्सेस स्ट्रक्चर टुपल नहीं है, तो त्रुटि उठाई जाती है:

iex> get_in(%{}, [Access.elem(0)])
** (RuntimeError) Access.elem/1 expected a tuple, got: %{}

लाने (कंटेनर, कुंजी)

fetch(nil_container(), any()) :: :error
fetch(container(), term()) :: {:ok, term()} | :error

दिए गए कुंजी के लिए एक कंटेनर में मूल्य (एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करता है) प्राप्त करता है।

रिटर्न {:ok, value} जहां value key तहत value है अगर ऐसी कोई कुंजी है, या :error key नहीं मिलने पर :error

उदाहरण

iex> Access.fetch(%{name: "meg", age: 26}, :name)
{:ok, "meg"}

iex> Access.fetch([ordered: true, on_timeout: :exit], :timeout)
:error

फ़िल्टर (func) (1.6.0 से)

filter((term() -> boolean())) :: access_fun(data :: list(), get_value :: list())

एक फ़ंक्शन देता है जो सूची के सभी तत्वों को एक्सेस करता है जो प्रदान किए गए विधेय से मेल खाता है।

लौटाया गया फ़ंक्शन आमतौर पर Kernel.get_in/2 , Kernel.get_and_update_in/3 , और दोस्तों के Kernel.get_in/2 रूप में पास किया जाता है।

उदाहरण

iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
iex> get_in(list, [Access.filter(&(&1.salary > 20)), :name])
["francine"]
iex> get_and_update_in(list, [Access.filter(&(&1.salary <= 20)), :name], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{["john"], [%{name: "JOHN", salary: 10}, %{name: "francine", salary: 30}]}

filter(func) उपयोग सूची के बाहर तत्वों या सूची के अंदर एक कुंजी के लिए भी किया जा सकता है:

iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
iex> pop_in(list, [Access.filter(&(&1.salary >= 20))])
{[%{name: "francine", salary: 30}], [%{name: "john", salary: 10}]}
iex> pop_in(list, [Access.filter(&(&1.salary >= 20)), :name])
{["francine"], [%{name: "john", salary: 10}, %{salary: 30}]}

जब कोई मैच नहीं मिलता है, तो एक खाली सूची दी जाती है और अपडेट फ़ंक्शन को कभी नहीं बुलाया जाता है

iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
iex> get_in(list, [Access.filter(&(&1.salary >= 50)), :name])
[]
iex> get_and_update_in(list, [Access.filter(&(&1.salary >= 50)), :name], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}

एक त्रुटि उठाई जाती है, यदि विधेय कोई कार्य नहीं करता है या गलत आदतों का है:

iex> get_in([], [Access.filter(5)])
** (FunctionClauseError) no function clause matching in Access.filter/1

यदि कोई एक्सेस की गई सूची नहीं है, तो त्रुटि उठाई जाती है:

iex> get_in(%{}, [Access.filter(fn a -> a == 10 end)])
** (RuntimeError) Access.filter/1 expected a list, got: %{}

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

get(nil_container(), any(), default) :: default when default: var
get(container(), term(), term()) :: term()

कंटेनर में दिए गए कुंजी के लिए मान प्राप्त करता है (एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करता है)।

key तहत मान लौटाता है अगर ऐसी कोई कुंजी है, या यदि key नहीं मिली है तो default है।

उदाहरण

iex> Access.get(%{name: "john"}, :name, "default name")
"john"
iex> Access.get(%{name: "john"}, :age, 25)
25

iex> Access.get([ordered: true], :timeout)
nil

get_and_update (कंटेनर, कुंजी, मज़ा)

get_and_update(data, key(), (value() -> {get_value, value()} | :pop)) ::
  {get_value, data}
when data: container(), get_value: var

दिए गए कुंजी को container (एक मानचित्र, एक कीवर्ड सूची, एक संरचना जो Access व्यवहार को लागू करता है) में हो जाता है और अद्यतन करता है।

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

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

कुंजी! (key)

key!(key()) :: access_fun(data :: struct() | map(), get_value :: term())

एक फ़ंक्शन देता है जो किसी मानचित्र / संरचना में दी गई कुंजी तक पहुंचता है।

लौटाया गया फ़ंक्शन आमतौर पर Kernel.get_in/2 , Kernel.get_and_update_in/3 , और दोस्तों के Kernel.get_in/2 रूप में पास किया जाता है।

key/2 समान, लेकिन लौटाया गया फ़ंक्शन तब उठता है जब कुंजी मौजूद नहीं है।

उदाहरण

iex> map = %{user: %{name: "john"}}
iex> get_in(map, [Access.key!(:user), Access.key!(:name)])
"john"
iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{"john", %{user: %{name: "JOHN"}}}
iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
{"john", %{user: %{}}}
iex> get_in(map, [Access.key!(:user), Access.key!(:unknown)])
** (KeyError) key :unknown not found in: %{name: "john"}

यदि कोई एक्सेस मैप / स्ट्रक्चर नहीं है, तो त्रुटि उठाई जाती है:

iex> get_in([], [Access.key!(:foo)])
** (RuntimeError) Access.key!/1 expected a map/struct, got: []

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

key(key(), term()) ::
  access_fun(data :: struct() | map(), get_value :: term())

एक फ़ंक्शन देता है जो किसी मानचित्र / संरचना में दी गई कुंजी तक पहुंचता है।

लौटाया गया फ़ंक्शन आमतौर पर Kernel.get_in/2 , Kernel.get_and_update_in/3 , और दोस्तों के Kernel.get_in/2 रूप में पास किया जाता है।

यदि फ़ंक्शन मौजूद नहीं है, तो दिया गया फ़ंक्शन डिफ़ॉल्ट मान का उपयोग करता है। इसका उपयोग चूक को रोकने और सुरक्षित रूप से गुम हुई कुंजियों को निर्दिष्ट करने के लिए किया जा सकता है:

iex> get_in(%{}, [Access.key(:user, %{name: "meg"}), Access.key(:name)])
"meg"

अपडेट फ़ंक्शन का उपयोग करते समय यह भी उपयोगी है, जिससे हम मूल्यों को पेश करने की अनुमति देते हैं क्योंकि हम अपडेट के लिए डेटा संरचना को पार करते हैं:

iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name)], "Mary")
%{user: %{name: "Mary"}}

उदाहरण

iex> map = %{user: %{name: "john"}}
iex> get_in(map, [Access.key(:unknown, %{}), Access.key(:name, "john")])
"john"
iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn prev ->
...>   {prev, String.upcase(prev)}
...> end)
{"john", %{user: %{name: "JOHN"}}}
iex> pop_in(map, [Access.key(:user), Access.key(:name)])
{"john", %{user: %{}}}

यदि कोई एक्सेस मैप या स्ट्रक्चर नहीं है, तो त्रुटि उठाई जाती है:

iex> get_in(nil, [Access.key(:foo)])
** (BadMapError) expected a map, got: nil

iex> get_in([], [Access.key(:foo)])
** (BadMapError) expected a map, got: []

पॉप (कंटेनर, कुंजी)

pop(data, key()) :: {value(), data} when data: container()

कंटेनर से दिए गए कुंजी के साथ प्रविष्टि को हटाता है (एक नक्शा, कीवर्ड सूची, या संरचना जो Access व्यवहार को लागू करता है)।

कुंजी और अद्यतन कंटेनर के साथ जुड़े मूल्य युक्त एक टपल लौटाता है। यदि कंटेनर में कुंजी नहीं है, तो nil को मान के लिए लौटाया जाता है।

उदाहरण

एक नक्शे के साथ:

iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :name)
{"Elixir", %{creator: "Valim"}}

एक कीवर्ड सूची:

iex> Access.pop([name: "Elixir", creator: "Valim"], :name)
{"Elixir", [creator: "Valim"]}

एक अज्ञात कुंजी:

iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :year)
{nil, %{creator: "Valim", name: "Elixir"}}

कॉलबैक

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

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

दी गई अवधि में key तहत संग्रहीत मूल्य तक पहुंचने के लिए आमंत्रित किया गया है।

इस फ़ंक्शन को वापस लौटना चाहिए {:ok, value} जहां value key तहत value है अगर कुंजी शब्द में मौजूद है, या :error यदि कुंजी शब्द में मौजूद नहीं है, तो :error

Access मॉड्यूल में परिभाषित कई फ़ंक्शन इस फ़ंक्शन को आंतरिक रूप से कहते हैं। इस फ़ंक्शन का उपयोग तब भी किया जाता है जब वर्ग-ब्रैकेट सिंटैक्स ( structure[key] ) का उपयोग किया जाता है: structure को परिभाषित करने वाले मॉड्यूल द्वारा लागू किए गए fetch/2 कॉलबैक को आमंत्रित किया जाता है और यदि यह वापस आ जाता है {:ok, value} तो value है लौटा, या यदि यह लौटा :error तो nil वापस आ गया है।

इस कॉलबैक को कैसे लागू किया जाए, इसके उदाहरणों के लिए Map.fetch/2 और Keyword.fetch/2 कार्यान्वयन देखें।

get_and_update (डेटा, कुंजी, फ़ंक्शन)

get_and_update(data, key(), (value() -> {get_value, value()} | :pop)) ::
  {get_value, data}
when data: container() | any_container(), get_value: var

मूल्य को key तहत एक्सेस करने और उसी समय अपडेट करने के लिए इनवाइट किया गया।

इस कॉलबैक के कार्यान्वयन को पारित संरचना data में key तहत मूल्य के साथ, या यदि इसमें मौजूद नहीं है, तो nil साथ fun आमंत्रित करना चाहिए। इस फ़ंक्शन को {get_value, update_value} या :pop वापस लौटना होगा।

यदि उत्तीर्ण फ़ंक्शन {get_value, update_value} , तो इस कॉलबैक का रिटर्न मान {get_value, new_data} होना चाहिए, जहां:

  • get_value पुनर्प्राप्त मान है (जिसे लौटाए जाने से पहले संचालित किया जा सकता है)

  • update_value key तहत संग्रहीत किया जाने वाला नया मान है

  • new_data साथ key का मान अपडेट करने के बाद new_data data

यदि उत्तीर्ण फ़ंक्शन वापस आता है :pop , इस कॉलबैक का रिटर्न मान {value, new_data} होना चाहिए {value, new_data} जहां value key अंतर्गत value है (या मौजूद नहीं है तो nil ) और new_data key बिना data

अधिक उदाहरणों के लिए Map.get_and_update/3 या Keyword.get_and_update/3 का कार्यान्वयन देखें।

पॉप (डेटा, कुंजी)

pop(data, key()) :: {value(), data} when data: container() | any_container()

दिए गए डेटा संरचना से बाहर key तहत मूल्य "पॉप" करने के लिए आमंत्रित किया।

जब दिए गए संरचना data में key मौजूद होती data , तो कार्यान्वयन को एक {value, new_data} tuple वापस करना चाहिए {value, new_data} जहां value वह value है जो key अंतर्गत था और new_data बिना key term

जब दी गई संरचना में key मौजूद नहीं है, तो एक टपल {value, data} को लौटाया जाना चाहिए, जहां value कार्यान्वयन-परिभाषित है।

अधिक उदाहरणों के लिए Map.pop/3 या Keyword.pop/3 लिए कार्यान्वयन देखें।