कीवर्ड सूचियों का क्या लाभ है?

Question

अमृत ​​में हमारे पास नक्शे हैं:

> map = %{:a => "one", :b => "two"} # = %{a: "one", b: "two"}
> map.a                             # = "one"
> map[:a]                           # = "one"

हमारे पास कीवर्ड सूची भी है:

> kl = [a: "one", b: "two"]       # = [a: "one", b: "two"]
> kl2 = [{:a, "one"},{:b, "two"}] # = [a: "one", b: "two"]
> kl == kl2                       # = true
> kl[:a]                          # = "one"
> kl.a                            # = ** (ArgumentError)

दोनों क्यों?

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

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

प्रदर्शन? क्या इसलिए कि कीवर्ड सूचियों का प्रदर्शन बेहतर है? फिर मैप्स क्यों हैं? और क्या tuples की सूची की तुलना में कुंजी द्वारा सदस्यों को देखने पर नक्शे अधिक प्रदर्शन योग्य नहीं होने चाहिए?

जेएस अर्रे और रूबी हैश की तरह दिखते हैं? क्या यही है?

मैं समझता हूं कि संरचनात्मक रूप से वे अलग-अलग डेटा अभ्यावेदन हैं। मेरे लिए ऐसा लगता है कि अमृत में कीवर्ड सूची असाधारण वाक्यविन्यास (3 अलग-अलग वाक्य विन्यास) के माध्यम से भाषा को जटिल बनाने का काम करती है, नक्शे के साथ केस ओवरलैप का उपयोग करें, और एक अस्पष्ट लाभ।

कीवर्ड सूचियों का उपयोग करने का क्या लाभ है?

Answer 1

                   ┌──────────────┬────────────┬───────────────────────┐
                   │ Keyword List │ Map/Struct │ HashDict (deprecated) │
┌──────────────────┼──────────────┼────────────┼───────────────────────┤
│ Duplicate keys   │ yes          │ no         │ no                    │
│ Ordered          │ yes          │ no         │ no                    │
│ Pattern matching │ yes          │ yes        │ no                    │
│ Performance¹     │ —            │ —          │ —                     │
│ ├ Insert         │ very fast²   │ fast³      │ fast⁴                 │
│ └ Access         │ slow⁵        │ fast³      │ fast⁴                 │
└──────────────────┴──────────────┴────────────┴───────────────────────┘

कीवर्ड सूचियां हल्की हैं और उनके नीचे एक सरल संरचना है, जो उन्हें बहुत लचीला बनाती है। आप उन्हें एर्लांग सम्मेलन के शीर्ष पर सिंटैक्स चीनी के रूप में सोच सकते हैं, जिससे एर्लंग के साथ बहुत ही बदसूरत कोड लिखे बिना इंटरफेस करना आसान हो जाता है। उदाहरण के लिए, कीवर्ड सूचियों का उपयोग फ़ंक्शन तर्कों का प्रतिनिधित्व करने के लिए किया जाता है, जो एर्लैंग से विरासत में मिली संपत्ति है। कुछ मामलों में, कीवर्ड सूची आपकी एकमात्र पसंद है, खासकर यदि आपको डुप्लिकेट कुंजी या ऑर्डर करने की आवश्यकता है। उनके पास अन्य विकल्पों की तुलना में अलग-अलग गुण होते हैं, जो उन्हें कुछ स्थितियों के लिए अधिक उपयुक्त बनाते हैं और दूसरों के लिए कम।

मैप्स (और स्ट्रक्चर्स) का उपयोग वास्तविक पेलोड डेटा को स्टोर करने के लिए किया जाता है, क्योंकि उनके पास हैश-आधारित कार्यान्वयन है। कीवर्ड सूचियां आंतरिक रूप से केवल एक सूची होती हैं, जिन्हें प्रत्येक ऑपरेशन के लिए ट्रेस करने की आवश्यकता होती है, इसलिए उनके पास निरंतर समय तक पहुंच जैसे क्लासिक कुंजी-मूल्य डेटा संरचनाओं के गुण नहीं होते हैं।

जिस समय यह लिखा गया था, तब नक्शोंHashDict के खराब प्रदर्शन के लिए अमृत ​​को भी एक समाधान के रूप में पेश किया गया था । हालाँकि, यह अब Elixir 1.0.5 / Erlang 18.0 के रूप में तय HashDict किया गया है और इसे भविष्य के संस्करणों में हटा दिया जाएगा ।

यदि आप एरलंग मानक पुस्तकालय में गहराई से खुदाई करते हैं, तो और भी डेटा संरचनाएँ हैं जो कुंजी / मान युग्मों को संग्रहीत करती हैं:

• proplists - अमृत कीवर्ड सूचियों के समान
• नक्शे - अमृत के नक्शे के समान
• dict - मुख्य मान शब्दकोशों Erlang पुरातन से बनाया गया
• gb_trees - सामान्य संतुलित वृक्ष

जब आपके पास कई प्रक्रियाओं और / या VMs में कुंजी / मान जोड़े रखने की आवश्यकता हो, तो आपके पास ये विकल्प भी हैं:

• ets / dets - (डिस्क आधारित) Erlang टर्म स्टोरेज
• mnesia - वितरित डेटाबेस

---

But आम तौर पर बोल, लेकिन निश्चित रूप से यह ™ पर निर्भर करता है ।

² सबसे अच्छा मामला सिर्फ एक सूची में शामिल है।

.5 1.0.5 और इसके बाद के संस्करण पर लागू पुराने संस्करणों में धीमा हो सकता है।

Dep HashDictअब पदावनत किया जा रहा है।

The एक रैखिक खोज की आवश्यकता होती है जो औसतन आधे तत्वों को स्कैन करती है।

Comments

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

— सही

कड़ाई से बोलना, हाँ, लेकिन वे उन लाभों की ज़रूरत होने पर लाभान्वित हो सकते हैं - यही मेरा मतलब है।

— पैट्रिक ऑस्सिटी

@PatrickOscity: ऐसे मामले में, निश्चित रूप से उन्हें आवश्यकताओं के रूप में बेहतर वर्गीकृत किया जाएगा ?

— को ऑर्बिट

@greggreg कीवर्ड सूची होने का एक और निहित लाभ है: हम संरचित और गैर-संरचित डेटा के बारे में भेद करते हैं। मैप्स संरचित डेटा के लिए बेहद उपयोगी होते हैं, जिनमें कुंजी और कीवर्ड के ज्ञात सेट नहीं होते हैं। आज, अधिकांश मानचित्र उपयोग संरचित डेटा के लिए हैं और हम वैकल्पिक लोगों के लिए कीवर्ड छोड़ते हैं। यदि हमारे पास केवल नक्शे हैं तो मुझे लगता है कि इस अंतर का एक अच्छा हिस्सा खो जाएगा।

— जोस वेलिम

वास्तव में यह किया था, नक्शे erlang 18 से जाने का रास्ता है।

— Papipo

Answer 2

कीवर्ड सूचियों का मुख्य लाभ मौजूदा अमृत और इरलांग कोडबेस के साथ एक पिछड़ी संगतता है।

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

def some_fun(arg, opts \\ []), do: ...
some_fun arg, opt1: 1, opt2: 2

कीवर्ड सूचियों का उपयोग करने का मुख्य दोष यह है कि उन पर मिलान करने वाला आंशिक पैटर्न प्रदर्शन करना संभव नहीं है:

iex(1)> m = %{a: 1, b: 2}
%{a: 1, b: 2}
iex(2)> %{a: a} = m
%{a: 1, b: 2}
iex(3)> a
1
iex(4)> k = [a: 1, b: 2]
[a: 1, b: 2]
iex(5)> [a: a] = k
** (MatchError) no match of right hand side value: [a: 1, b: 2]

चलिए इसे तर्कों को विस्तार देने के लिए बढ़ाते हैं। कल्पना करें कि हमें विकल्पों में से एक के आधार पर एक मल्टीकलॉज फ़ंक्शन को संभालने की आवश्यकता है:

def fun1(arg, opt1: opt1) when is_nil(opt1), do: do_special_thing
def fun1(arg, opts), do: do_regular_thing

def fun2(arg, %{opt1: opt1}) when is_nil(opt1), do: do_special_thing
def fun2(arg, opts), do: do_regular_thing

यह कभी निष्पादित नहीं होगा do_special_thing:

fun1("arg", opt1: nil, opt2: "some value")
doing regular thing  

नक्शे के तर्कों के साथ यह काम करेगा:

fun2("arg", %{opt1: nil, opt2: "some value"})
doing special thing

Answer 3

मैप्स एक विशेष कुंजी के लिए केवल एक प्रविष्टि की अनुमति देते हैं, जबकि कीवर्ड सूची कुंजी को दोहराए जाने की अनुमति देती है। नक्शे कुशल हैं (विशेषकर जैसे-जैसे वे बढ़ते हैं), और उनका उपयोग अमृत के पैटर्न मिलान में किया जा सकता है।

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