शब्दकोश, संग्रह और Arrays की तुलना

Question

मैं संग्रह और सरणी की तुलना में शब्दकोशों के सापेक्ष लाभ और सुविधाओं को काम करने की कोशिश कर रहा हूं।

मुझे एक उत्कृष्ट लेख here मिला लेकिन सभी साधारण सुविधाओं की तुलना में एक साधारण तालिका नहीं मिल सकती है।

क्या किसी को भी पता है?

Answer 1

संग्रह और शब्दकोशों की तुलना में सुविधाओं की एक उपयोगी तालिका की संलग्न तस्वीर देखें।

(तालिका "प्रारंभिक और लेट बाइंडिंग" पर this page खंड अप करने के लिए दिखाता है। आपकी जानकारी के पेज भी शब्दकोशों का उपयोग कर के बारे में अधिक विस्तृत जानकारी है)

सारांश में यह आम तौर पर एक शब्दकोश या किसी सरणी का उपयोग करने के लिए सबसे अच्छा है।

संग्रहों का उपयोग करने पर विचार करते समय आकार बदलना नहीं है, या केवल दुर्लभ रूप से परिवर्तन होने पर सरणी का उपयोग करना अधिक उपयुक्त हो सकता है। इस मामले में एक सरणी संग्रह से अधिक कुशल होने की संभावना है क्योंकि Arrays एक ही समय में सभी वस्तुओं को पॉप्युलेट और पुनर्प्राप्त करने के लिए बहुत ही कुशल हैं (उदाहरण के लिए सरणी और सरणी को वापस श्रेणी तक)।

भी ध्यान रखें:

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

This cpearson page है शब्दकोशों, संग्रह और सरणियों के साथ काम करने के लिए बहुत उपयोगी कोड है

cpearson के पृष्ठ से कुछ पाठ (उन्हें छँटाई, और भी परिवर्तित उन्हें एक दूसरे तक!):

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

सरणी खराब विकल्प क्यों हो सकती है। Arrays फिर से आकार देने और मध्य में वस्तुओं को सम्मिलित करने में बहुत धीमे होते हैं क्योंकि प्रत्येक Redim पूरे मेमोरी ब्लॉक को एक बड़े स्थान पर प्रतिलिपि बनाता है, और यदि संरक्षित किया जाता है, तो सभी मान भी कॉपी हो जाते हैं। यह हर ऑपरेशन के लिए कथित सुस्ती से अनुवाद कर सकते हैं - एक संभावित आवेदन में)

Answer 2

Option Explicit 

Sub CollectionsVSdictionaries() ' Requires ref to "Microsoft Scripting Runtime" Library 
    Dim c As Collection   ' TypeName 1-based indexed 
    Dim d As Dictionary   ' 0-based arrays 
    Set c = New Collection  ' or: "Dim c As New Collection" 
    Set d = New Dictionary  ' or: "Dim d As New Dictionary" 

    c.Add Key:="A", Item:="AA": c.Add Key:="B", Item:="BB": c.Add Key:="C", Item:="CC" 
    d.Add Key:="A", Item:="AA": d.Add Key:="B", Item:="BB": d.Add Key:="C", Item:="CC" 

    Debug.Print TypeName(c) ' -> "Collection" 
    Debug.Print TypeName(d) ' -> "Dictionary" 

    Debug.Print c(3)   ' -> "CC" 
    Debug.Print c("C")   ' -> "CC" 
    'Debug.Print c("CC")  ' --- Invalid --- 

    Debug.Print d("C")   ' -> "CC" 
    Debug.Print d("CC")  ' Adds Key:="CC", Item:="" 
    Debug.Print d.Items(2)  ' -> "CC" 
    Debug.Print d.Keys(2)  ' -> "C" 
    Debug.Print d.Keys()(0)  ' -> "A" - Not well known *************************** 
    Debug.Print d.Items()(0) ' -> "AA" - Not well known *************************** 

    'Collection methods: 
    ' .Add     ' c.Add Item, [Key], [Before], [After] (Key is optional) 
    ' .Count 
    ' .Item(Index)   ' Default property; "c.Item(Index)" same as "c(Index)" 
    ' .Remove(Index) 
    'Dictionary methods: 
    ' .Add     ' d.Add Key, Item (Key is required, and must be unique) 
    ' .CompareMode   ' 1. BinaryCompare  - case-sensitive ("A" < "a") 
    ' .CompareMode   ' 2. DatabaseCompare - MS Access only 
    ' .CompareMode   ' 3. TextCompare  - case-insensitive ("A" = "a") 
    ' .Count 
    ' .Exists(Key)   ' Boolean ********************************************** 
    ' .Item(Key) 
    ' .Items     ' Returns full array: .Items(0)(0) 
    ' .Key(Key) 
    ' .Keys     ' Returns full array: .Keys(0)(0) 
    ' .Remove(Key) 
    ' .RemoveAll    ' ****************************************************** 
End Sub