Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट · पाठ

मैपिंग और गतिशील ऐरे

कुंजी-मान युग्मों के लिए मैपिंग और डेटा की लचीली सूचियों के लिए गतिशील ऐरे जैसी जटिल डेटा संरचनाएँ लागू कीजिए।

पाठ 2, कुल 4 में से12 चरण

मैपिंग और गतिशील ऐरे, CoddyKit पर Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

लचीली डेटा संरचनाएँ

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

इन साधनों की मदद से आपके अनुबंध जानकारी को लचीले और विस्तार योग्य तरीकों से संग्रहीत और प्राप्त कर सकते हैं। मजबूत विकेंद्रीकृत ऐप्लिकेशन बनाने के लिए ये आवश्यक हैं।

मैपिंग क्या होती है

मैपिंग को किसी शब्दकोश या हैश तालिका की तरह समझिए। यह डेटा को कुंजी-मान युग्मों के रूप में संग्रहीत करती है।

आप एक अद्वितीय कुंजी प्रदान करते हैं (जैसे कोई पता या ID)।
मैपिंग उस कुंजी से संबद्ध मान लौटाती है (जैसे किसी उपयोगकर्ता का बैलेंस या नाम)।
कुंजियाँ संग्रहीत नहीं की जातीं, केवल उनका क्रिप्टोग्राफ़िक हैश संग्रहीत किया जाता है, जिससे खोज बहुत कुशल हो जाती है।

मैपिंग घोषित करना

मैपिंग घोषित करने के लिए आप कुंजी के प्रकार और मान के प्रकार को निर्दिष्ट करते हैं। इसे आमतौर पर public स्थिति चर के रूप में घोषित किया जाता है।

यहाँ प्रत्येक address (कुंजी) के लिए एक uint (मान) संग्रहीत करने वाली मैपिंग घोषित करने का तरीका दिया गया है:

pragma solidity ^0.8.0;

contract MyMappings {
    // A mapping from address to unsigned integer
    mapping(address => uint) public balances;

    // Another mapping: from uint ID to string name
    mapping(uint => string) public userNames;
}

मैपिंग में डेटा संग्रहीत करना

आप मैपिंग की कुंजी का उपयोग करके उसमें किसी मान को आसानी से असाइन या अपडेट कर सकते हैं। यदि कोई कुंजी अभी तक मौजूद नहीं है, तो उसे बना दिया जाता है।

आइए किसी उपयोगकर्ता का बैलेंस अपडेट करने के लिए एक फ़ंक्शन जोड़ते हैं:

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    // Try calling setBalance with your address and a number,
    // then check balances(yourAddress) in Remix.
}

मैपिंग से डेटा प्राप्त करना

डेटा तक पहुँचना सरल है: बस कुंजी का उपयोग करें। यदि आप ऐसी कुंजी का मान प्राप्त करने का प्रयास करते हैं जिसे अभी तक सेट नहीं किया गया है, तो Solidity उस प्रकार का डिफ़ॉल्ट मान लौटाता है (जैसे uint के लिए 0, string के लिए खाली स्ट्रिंग और address के लिए address(0))।

pragma solidity ^0.8.0;

contract MyMappings {
    mapping(address => uint) public balances;

    function setBalance(address _user, uint _amount) public {
        balances[_user] = _amount;
    }

    function getBalance(address _user) public view returns (uint) {
        return balances[_user];
    }

    // Deploy, call setBalance, then getBalance.
    // Try getBalance for an address not yet set.
}

डायनेमिक ऐरे क्या होते हैं

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

इनका आकार बढ़ या घट सकता है।
तत्वों तक उनके इंडेक्स से पहुँचा जाता है (0 से शुरू)।
Storage में निश्चित आकार वाले ऐरे की तुलना में इन पर अधिक गैस खर्च होती है।

डायनेमिक ऐरे घोषित करना

डायनेमिक ऐरे घोषित करने के लिए आप वर्गाकार कोष्ठकों में आकार को छोड़ देते हैं। आप इन्हें स्थिति चर या स्थानीय चर के रूप में घोषित कर सकते हैं (memory या calldata का उपयोग करके)।

यहाँ uint का डायनेमिक ऐरे का एक उदाहरण दिया गया है:

pragma solidity ^0.8.0;

contract MyArrays {
    // A dynamic array of unsigned integers stored in state
    uint[] public numbers;

    // A dynamic array of strings (for memory use)
    function createNameList() public pure returns (string[] memory) {
        string[] memory names = new string[](0); // Initialize empty
        return names;
    }
}

डायनेमिक ऐरे में तत्व जोड़ना

डायनेमिक ऐरे में तत्व जोड़ने का सबसे सामान्य तरीका push() विधि का उपयोग करना है। यह ऐरे के अंत में एक नया तत्व जोड़ती है।

array.push(): शून्य से प्रारंभ किया गया तत्व जोड़ता है।
array.push(value): कोई विशिष्ट मान जोड़ता है।

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public numbers;

    function addNumber(uint _num) public {
        numbers.push(_num); // Add _num to the end
    }

    function addDefault() public {
        numbers.push(); // Add a 0 to the end
    }

    function getLength() public view returns (uint) {
        return numbers.length;
    }
}

तत्वों तक पहुँचना और उन्हें हटाना

आप तत्वों तक उनके इंडेक्स से पहुँच सकते हैं (0 से शुरू)। तत्वों को हटाने के लिए आप pop() का उपयोग कर सकते हैं, जो अंतिम तत्व को हटा देता है और ऐरे की length घटा देता है।

pragma solidity ^0.8.0;

contract MyArrays {
    uint[] public data = [10, 20, 30, 40];

    function getElement(uint _index) public view returns (uint) {
        require(_index < data.length, "Index out of bounds");
        return data[_index];
    }

    function removeLast() public {
        data.pop(); // Removes 40
    }

    function getLength() public view returns (uint) {
        return data.length;
    }
}

उन्नत: ऐरे की मैपिंग

आप इन संरचनाओं को एक साथ जोड़ सकते हैं! एक सामान्य तरीका ऐसी मैपिंग बनाना है जिसमें मान का प्रकार डायनेमिक ऐरे हो। इससे आप किसी कुंजी के साथ वस्तुओं की सूची जोड़ सकते हैं, जैसे किसी उपयोगकर्ता का लेन-देन इतिहास।

यहाँ किसी पते को uint के डायनेमिक ऐरे से मैप करने का उदाहरण दिया गया है:

pragma solidity ^0.8.0;

contract UserData {
    mapping(address => uint[]) public transactionHistory;

    function addTransaction(address _user, uint _amount) public {
        transactionHistory[_user].push(_amount);
    }

    function getUserTransactions(address _user) public view returns (uint[] memory) {
        return transactionHistory[_user];
    }

    // Add a few transactions for your address, then view them.
}

अपनी समझ जाँचें

निम्नलिखित Solidity कोड अंश पर विचार करें:

pragma solidity ^0.8.0;

contract DataStructures {
    mapping(address => uint) public scores;
    uint[] public participants;

    function recordScore(address _player, uint _score) public {
        if (scores[_player] == 0) {
            participants.push(_player);
        }
        scores[_player] = _score;
    }

    function getParticipantCount() public view returns (uint) {
        return participants.length;
    }
}

यदि recordScore(0xabc..., 100) को कॉल किया जाता है, फिर recordScore(0xdef..., 200) को और अंत में recordScore(0xabc..., 150) को, तो getParticipantCount() क्या लौटाएगा?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: मैपिंग और डायनेमिक ऐरे

आपने Solidity में दो आवश्यक डेटा संरचनाओं के बारे में सीखा है:

मैपिंग: कुंजी-मान का कुशल संग्रह, जो पतों जैसे अद्वितीय पहचानकर्ताओं के साथ डेटा जोड़ने के लिए उपयोगी है। ये ऐसी कुंजियों के लिए डिफ़ॉल्ट मान लौटाती हैं जिन्हें सेट नहीं किया गया है।
डायनेमिक ऐरे: ऐसी लचीली सूचियाँ जिनका आकार push() और pop() का उपयोग करके बढ़ या घट सकता है। ये तब आदर्श होती हैं जब वस्तुओं की संख्या निश्चित न हो।

इनमें दक्षता हासिल करने से मजबूत और विस्तार योग्य स्मार्ट अनुबंधों को डिज़ाइन करने की आपकी क्षमता में बहुत सुधार होगा!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “मैपिंग और गतिशील ऐरे” पाठ निःशुल्क है?

हाँ—“मैपिंग और गतिशील ऐरे” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“मैपिंग और गतिशील ऐरे” में मैं क्या सीखूँगा?

कुंजी-मान युग्मों के लिए मैपिंग और डेटा की लचीली सूचियों के लिए गतिशील ऐरे जैसी जटिल डेटा संरचनाएँ लागू कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“मैपिंग और गतिशील ऐरे” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Solidity के साथ ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट पर वापस जाएँ