सॉलिडिटी - ऐरे

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

नंबर चर, नंबर 1, ... और नंबर 99 जैसे अलग-अलग चर घोषित करने के बजाय, आप एक सरणी चर जैसे संख्याओं की घोषणा करते हैं और संख्याओं का उपयोग करते हैं [0], संख्या [1] और ..., संख्या [99] का प्रतिनिधित्व करने के लिए अलग-अलग चर। एक सरणी में एक विशिष्ट तत्व एक सूचकांक द्वारा पहुँचा जाता है।

सॉलिडिटी में, एक सरणी संकलन-समय निश्चित आकार या गतिशील आकार का हो सकता है। स्टोरेज ऐरे के लिए, इसमें विभिन्न प्रकार के तत्व भी हो सकते हैं। मेमोरी एरे के मामले में, एलिमेंट टाइप मैपिंग नहीं किया जा सकता है और अगर इसे फंक्शन पैरामीटर के रूप में इस्तेमाल किया जाना है, तो एलिमेंट टाइप एबीबीएस टाइप होना चाहिए।

सभी सरणियों में सन्निहित स्मृति स्थान शामिल हैं। निम्नतम पता पहले तत्व से मेल खाता है और अंतिम तत्व से उच्चतम पता।

घोषणाएँ

सॉलिडिटी में निश्चित आकार की एक सरणी घोषित करने के लिए, प्रोग्रामर तत्वों के प्रकार और एक सरणी द्वारा आवश्यक तत्वों की संख्या को निर्दिष्ट करता है: -

type arrayName [ arraySize ];

इसे एकल-आयाम सरणी कहा जाता है। arraySize शून्य से अधिक पूर्णांक स्थिरांक होना चाहिए और typeकिसी भी वैध वैधता डेटा प्रकार हो सकता है। उदाहरण के लिए, एक 10-तत्व सरणी घोषित करने के लिए जिसे प्रकार का संतुलन कहा जाता है, इस कथन का उपयोग करें -

uint balance[10];

सॉलिडिटी में डायनेमिक साइज़ की एक सरणी घोषित करने के लिए, प्रोग्रामर निम्न प्रकार के तत्वों को निर्दिष्ट करता है -

type[] arrayName;

आरंभिक सारणी

आप एक के बाद एक या एक स्टेटमेंट का उपयोग करके सॉलिडिटी ऐरे एलिमेंट्स को इनिशियलाइज़ कर सकते हैं -

uint balance[3] = [1, 2, 3];

ब्रेसिज़ [] के बीच मानों की संख्या उन तत्वों की संख्या से अधिक नहीं हो सकती है जिन्हें हम वर्ग कोष्ठक [] के बीच के सरणी के लिए घोषित करते हैं। निम्नलिखित सरणी के एकल तत्व को निर्दिष्ट करने के लिए एक उदाहरण है -

यदि आप सरणी के आकार को छोड़ देते हैं, तो आरंभीकरण धारण करने के लिए सिर्फ एक सरणी काफी बड़ी है। इसलिए, यदि आप लिखते हैं -

uint balance[] = [1, 2, 3];

आप बिलकुल वही एरे बनाएंगे जैसा आपने पिछले उदाहरण में किया था।

balance[2] = 5;

उपरोक्त कथन 5 के मान में सरणी में तत्व संख्या 3 rd प्रदान करता है ।

गतिशील स्मृति सरणियाँ बनाना

नए कीवर्ड का उपयोग करके डायनामिक मेमोरी एरेज़ बनाई जाती हैं।

uint size = 3;
uint balance[] = new uint[](size);

ऐरे तत्वों तक पहुँचना

सरणी नाम अनुक्रमित करके एक तत्व को एक्सेस किया जाता है। यह सरणी के नाम के बाद वर्ग ब्रैकेट के भीतर तत्व के सूचकांक को रखकर किया जाता है। उदाहरण के लिए -

uint salary = balance[2];

उपर्युक्त कथन सरणी से 3 rd तत्व लेगा और मान को वेतन चर में निर्दिष्ट करेगा। निम्नलिखित एक उदाहरण है, जो उपरोक्त सभी तीन अवधारणाओं का उपयोग करेगा। घोषणा, असाइनमेंट और पहुँच सरणियाँ -

सदस्यों

  • length- लंबाई सरणी का आकार लौटाती है। लंबाई का उपयोग गतिशील सरणी के आकार को बदलने के लिए किया जा सकता है।

  • push- पुश अंत में एक तत्व को डायनेमिक स्टोरेज सरणी में जोड़ने की अनुमति देता है। यह सरणी की नई लंबाई देता है।

उदाहरण

यह समझने के लिए कि कोड कैसे काम करता है, निम्न कोड को आज़माएं।

pragma solidity ^0.5.0;

contract test {
   function testArray() public pure{
      uint len = 7; 
      
      //dynamic array
      uint[] memory a = new uint[](7);
      
      //bytes is same as byte[]
      bytes memory b = new bytes(len);
      
      assert(a.length == 7);
      assert(b.length == len);
      
      //access array variable
      a[6] = 8;
      
      //test array variable
      assert(a[6] == 8);
      
      //static array
      uint[3] memory c = [uint(1) , 2, 3];
      assert(c.length == 3);
   }
}