सॉलिडिटी - क्विक गाइड

सॉलिडिटी स्मार्ट कॉन्ट्रैक्ट्स को लागू करने के लिए एक अनुबंध-उन्मुख, उच्च-स्तरीय प्रोग्रामिंग भाषा है। सॉलिडिटी C ++, पायथन और जावास्क्रिप्ट से अत्यधिक प्रभावित है और इसे एथेरियम वर्चुअल मशीन (EVM) को लक्षित करने के लिए डिज़ाइन किया गया है।

सॉलिडिटी सांख्यिकीय रूप से टाइप की जाती है, वंशानुक्रम, लाइब्रेरी और जटिल उपयोगकर्ता-परिभाषित प्रकार की प्रोग्रामिंग भाषा का समर्थन करती है।

आप वोटिंग, क्राउडफंडिंग, ब्लाइंड नीलामियों, और बहु-हस्ताक्षर वाले पर्स जैसे उपयोगों के लिए अनुबंध बनाने के लिए सॉलिडिटी का उपयोग कर सकते हैं।

इथेरियम क्या है?

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

एथेरम वर्चुअल मशीन (EVM)

Ethereum Virtual Machine, जिसे EVM के रूप में भी जाना जाता है, Ethereum में स्मार्ट कॉन्ट्रैक्ट्स के लिए रनटाइम वातावरण है। एथेरियम वर्चुअल मशीन पूरी दुनिया में कंप्यूटरों द्वारा सुरक्षा प्रदान करने और अविश्वास कोड को लागू करने पर केंद्रित है।

ईवीएम डेनियल-ऑफ-सर्विस हमलों को रोकने में विशेष है और यह सुनिश्चित करता है कि कार्यक्रमों को एक-दूसरे की राज्य तक पहुंच नहीं है, यह सुनिश्चित करना कि संचार किसी भी संभावित हस्तक्षेप के बिना स्थापित किया जा सकता है।

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

स्मार्ट कॉन्ट्रैक्ट क्या है?

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

स्मार्ट कॉन्ट्रैक्ट की अवधारणा पहली बार निक स्जाबो द्वारा 1994 में प्रस्तावित की गई थी। स्ज़ैबो एक कानूनी विद्वान और क्रिप्टोग्राफर है जिसे डिजिटल मुद्रा के लिए आधार बनाने के लिए जाना जाता है।

यह ठीक है अगर आप अभी स्मार्ट कॉन्ट्रैक्ट को नहीं समझते हैं, तो हम बाद में और विस्तार करेंगे।

यह अध्याय बताता है कि कैसे हम CentOS मशीन पर सॉलिडिटी कंपाइलर सेटअप कर सकते हैं। यदि आपके पास लिनक्स मशीन नहीं है, तो आप हमारे ऑनलाइन कंपाइलर का उपयोग छोटे अनुबंधों के लिए और जल्दी से सॉलिडिटी सीखने के लिए कर सकते हैं।

विधि 1 - npm / Node.js

यह आपके सेंटो मशीन पर सॉलिडिटी कंपाइलर को स्थापित करने का सबसे तेज़ तरीका है। हमारे पास सॉलिडिटी कंपाइलर स्थापित करने के लिए निम्नलिखित चरण हैं -

Node.js स्थापित करें

पहले सुनिश्चित करें कि आपके पास अपने CentOS मशीन पर नोड.जेएस उपलब्ध है। यदि यह उपलब्ध नहीं है, तो निम्न कमांड का उपयोग करके इसे स्थापित करें -

# First install epel-release
$sudo yum install epel-release # Now install nodejs $sudo yum install nodejs

# Next install npm (Nodejs Package Manager )
$sudo yum install npm # Finally verify installation $npm --version

अगर सब कुछ स्थापित हो गया है, तो आपको आउटपुट कुछ इस तरह दिखाई देगा -

3.10.10

सोल स्थापित करें

एक बार जब आपके पास Node.js पैकेज मैनेजर स्थापित हो जाता है, तो आप नीचे संकलित संकलक को स्थापित करने के लिए आगे बढ़ सकते हैं -

$sudonpm install -g solc

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

$solcjs-version

अगर सब कुछ ठीक रहा, तो यह कुछ इस प्रकार छपेगा -

0.5.2+commit.1df8f40c.Emscripten.clang

अब आप ऐसे सॉलजेस का उपयोग करने के लिए तैयार हैं, जिसमें मानक सॉलिडिटी कंपाइलर की तुलना में कम विशेषताएं हैं, लेकिन यह आपको एक अच्छा शुरुआती बिंदु देगा।

विधि 2 - डॉकर छवि

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

$docker pull ethereum/solc:stable

एक बार डॉक इमेज डाउनलोड हो जाने के बाद हम इसे निम्न कमांड का उपयोग करके सत्यापित कर सकते हैं।

$docker run ethereum/solc:stable-version

यह कुछ इस प्रकार मुद्रित करेगा -

$ docker run ethereum/solc:stable -version

solc, the solidity compiler commandlineinterfaceVersion: 0.5.2+commit.1df8f40c.Linux.g++

विधि 3: बाइनरी पैकेज स्थापना

यदि आप अपने लिनक्स मशीन पर पूर्ण विकसित संकलक स्थापित करने के इच्छुक हैं, तो कृपया आधिकारिक वेबसाइट संस्थापन सॉलिडिटी संकलक की जाँच करें।

एक सॉलिडिटी सोर्स फाइल्स में किसी भी तरह की कॉन्ट्रैक्ट परिभाषा, आयात निर्देश और प्रज्ञा निर्देश हो सकते हैं।

चलिए सॉलिडिटी की एक सरल स्रोत फ़ाइल के साथ शुरू करते हैं। निम्नलिखित एक सॉलिडिटी फ़ाइल का एक उदाहरण है -

pragma solidity >=0.4.0 <0.6.0;
contract SimpleStorage {
   uint storedData;
   function set(uint x) public {
      storedData = x;
   }
   function get() public view returns (uint) {
      return storedData;
   }
}

pragma

पहली पंक्ति एक व्यावहारिक निर्देश है, जो बताता है कि स्रोत कोड सॉलिडिटी संस्करण 0.4.0 या कुछ भी नया नहीं है जो कार्यक्षमता को तोड़ता नहीं है, लेकिन शामिल नहीं है, संस्करण 0.6.0।

प्रागमा निर्देश हमेशा एक स्रोत फ़ाइल के लिए स्थानीय होता है और यदि आप किसी अन्य फ़ाइल को आयात करते हैं, तो उस फ़ाइल से प्रागमा स्वचालित रूप से आयात करने वाली फ़ाइल पर लागू नहीं होगा।

तो एक फ़ाइल के लिए एक प्रज्ञा जो संस्करण 0.4.0 से पहले संकलित नहीं होगी और यह संस्करण 0.5.0 से शुरू होने वाले कंपाइलर पर भी काम नहीं करेगी, इस प्रकार लिखा जाएगा -

pragma solidity ^0.4.0;

यहां ^ का उपयोग करके दूसरी शर्त जोड़ी जाती है।

अनुबंध

एक सॉलिडिटी कॉन्ट्रैक्ट कोड (इसके कार्यों) और डेटा (इसकी स्थिति) का एक संग्रह है जो एथेरेम्ब्लोकैचिन पर एक विशिष्ट पते पर रहता है।

लाइन uintstoredData एक स्टेट वैरिएबल घोषित करती है जिसे स्टोरडैट ऑफ टाइप यूइंट कहा जाता है और सेट और प्राप्त कार्यों को वेरिएबल के मान को संशोधित करने या पुनः प्राप्त करने के लिए उपयोग किया जा सकता है।

फ़ाइलें आयात करना

हालाँकि उपरोक्त उदाहरण में आयात विवरण नहीं है, लेकिन सॉलिडिटी आयात विवरणों का समर्थन करती है जो जावास्क्रिप्ट में उपलब्ध लोगों के समान हैं।

निम्न कथन "फ़ाइलनाम" से सभी वैश्विक प्रतीकों को आयात करता है।

import "filename";

निम्न उदाहरण एक नया वैश्विक प्रतीक प्रतीक बनाता है जिसके सदस्य "फ़ाइल नाम" से सभी वैश्विक प्रतीक हैं।

import * as symbolName from "filename";

वर्तमान फ़ाइल के समान निर्देशिका से फ़ाइल x आयात करने के लिए, "./x" का उपयोग x के रूप में करें; यदि आप x के रूप में "x" आयात का उपयोग करते हैं; इसके बजाय, एक वैश्विक "निर्देशिका शामिल" में एक अलग फ़ाइल को संदर्भित किया जा सकता है।

आरक्षित खोजशब्द

सॉलिडिटी में आरक्षित कीवर्ड निम्नलिखित हैं -

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

हम रीमिक्स आईडीई का उपयोग संकलन और हमारे सॉलिडिटी कोड आधार को चलाने के लिए कर रहे हैं ।

Step 1 - दिए गए कोड को रीमिक्स आईडीई कोड सेक्शन में कॉपी करें।

उदाहरण

pragma solidity ^0.5.0;
contract SolidityTest {
   constructor() public{
   }
   function getResult() public view returns(uint){
      uint a = 1;
      uint b = 2;
      uint result = a + b;
      return result;
   }
}

Step 2 - संकलन टैब के तहत, क्लिक करें Start to Compile बटन।

Step 3 - रन टैब के तहत, क्लिक करें Deploy बटन।

Step 4 - रन टैब के तहत, सेलेक्ट करें SolidityTest at 0x... बूंद-बूंद में।

Step 5 - क्लिक करें getResult परिणाम प्रदर्शित करने के लिए बटन।

उत्पादन

0: uint256: 3

सॉलिडिटी C- शैली और C ++ - दोनों शैली टिप्पणियों का समर्थन करती है, इस प्रकार -

एक पंक्ति के अंत और / के बीच के किसी भी पाठ को एक टिप्पणी के रूप में माना जाता है और सॉलिडिटी कंपाइलर द्वारा अनदेखा किया जाता है।
पात्रों के बीच किसी भी पाठ / * और * को एक टिप्पणी के रूप में माना जाता है। यह कई लाइनों को फैला सकता है।

उदाहरण

निम्न उदाहरण दिखाता है कि सॉलिडिटी में टिप्पणियों का उपयोग कैसे किया जाए।

function getResult() public view returns(uint){
   // This is a comment. It is similar to comments in C++

   /*
      * This is a multi-line comment in solidity
      * It is very similar to comments in C Programming
   */
   uint a = 1;
   uint b = 2;
   uint result = a + b;
   return result;
}

किसी भी भाषा में प्रोग्राम लिखते समय, आपको विभिन्न जानकारी संग्रहीत करने के लिए विभिन्न चर का उपयोग करने की आवश्यकता होती है। वेरिएबल्स मूल्यों को संग्रहीत करने के लिए आरक्षित मेमोरी स्थानों के अलावा कुछ भी नहीं हैं। इसका मतलब यह है कि जब आप एक चर बनाते हैं तो आप स्मृति में कुछ स्थान आरक्षित करते हैं।

आप विभिन्न डेटा प्रकारों की जानकारी जैसे चरित्र, विस्तृत चरित्र, पूर्णांक, फ्लोटिंग पॉइंट, डबल फ़्लोटिंग पॉइंट, बूलियन आदि को संग्रहीत करना पसंद कर सकते हैं। एक चर के डेटा प्रकार के आधार पर, ऑपरेटिंग सिस्टम मेमोरी आवंटित करता है और यह तय करता है कि क्या स्टोर किया जा सकता है। आरक्षित मेमोरी।

मान प्रकार

सॉलिडिटी प्रोग्रामर को बिल्ट-इन के साथ-साथ उपयोगकर्ता परिभाषित डेटा प्रकारों का एक समृद्ध वर्गीकरण प्रदान करता है। निम्न तालिका सात मूल C ++ डेटा प्रकारों को सूचीबद्ध करती है -

प्रकार	कीवर्ड	मूल्यों
बूलियन	bool	सही गलत
पूर्णांक	पूर्णांक / uint	अलग-अलग आकार के हस्ताक्षरित और अहस्ताक्षरित पूर्णांक।
पूर्णांक	int8 से int256	8 बिट्स से 256 बिट्स पर इंट साइन किया गया। int256 int के समान है।
पूर्णांक	uint8 से uint256	8 बिट्स से 256 बिट्स तक अनसाइनड इंट। uint256 यूंट के समान है।
फिक्स्ड प्वाइंट नंबर	तय / unfixed	अलग-अलग आकार के हस्ताक्षरित और अहस्ताक्षरित निश्चित बिंदु संख्या।
फिक्स्ड प्वाइंट नंबर	तय / unfixed	अलग-अलग आकार के हस्ताक्षरित और अहस्ताक्षरित निश्चित बिंदु संख्या।
फिक्स्ड प्वाइंट नंबर	fixedMxN	हस्ताक्षरित निश्चित बिंदु संख्या जहां M प्रकार द्वारा ली गई बिट्स की संख्या का प्रतिनिधित्व करता है और N दशमलव बिंदुओं का प्रतिनिधित्व करता है। M को 8 से विभाजित किया जाना चाहिए और 8 से 256 तक जाता है। N 0 से 80 तक हो सकता है। फिक्स्ड12812818 के समान है।
फिक्स्ड प्वाइंट नंबर	ufixedMxN	Unsign नियत बिंदु संख्या जहाँ M प्रकार द्वारा ली गई बिट्स की संख्या का प्रतिनिधित्व करता है और N दशमलव बिंदुओं का प्रतिनिधित्व करता है। M को 8 से विभाज्य होना चाहिए और 8 से 256 तक जाता है। N 0 से 80 तक हो सकता है। ufixed ufixed128x18 के समान है।

पता

पता एक Ethereum पते के आकार का प्रतिनिधित्व करते हुए 20 बाइट मान रखता है। एक पते का उपयोग। संतुलन विधि का उपयोग कर संतुलन प्राप्त करने के लिए किया जा सकता है और इसका उपयोग .transfer विधि का उपयोग करके दूसरे पते पर शेष राशि को स्थानांतरित करने के लिए किया जा सकता है।

address x = 0x212;
address myAddress = this;
if (x.balance < 10 && myAddress.balance >= 10) x.transfer(10);

सॉलिडिटी तीन प्रकार के चर का समर्थन करती है।

State Variables - चर जिनका मान स्थायी रूप से एक अनुबंध भंडारण में संग्रहीत किया जाता है।
Local Variables - चर, जिनके मान फ़ंक्शन तक मौजूद हैं निष्पादित कर रहे हैं।
Global Variables - ब्लॉकचैन के बारे में जानकारी प्राप्त करने के लिए उपयोग किए जाने वाले वैश्विक नामस्थान में विशेष चर मौजूद हैं।

सॉलिडिटी एक सांख्यिकीय रूप से टाइप की जाने वाली भाषा है, जिसका अर्थ है कि घोषणा के दौरान राज्य या स्थानीय चर प्रकार को निर्दिष्ट करने की आवश्यकता होती है। प्रत्येक घोषित चर में हमेशा अपने प्रकार के आधार पर एक डिफ़ॉल्ट मान होता है। "अपरिभाषित" या "अशक्त" की कोई अवधारणा नहीं है।

अवस्था चर

चर जिनके मान स्थायी रूप से एक अनुबंध भंडारण में संग्रहीत किए जाते हैं।

pragma solidity ^0.5.0;
contract SolidityTest {
   uint storedData;      // State variable
   constructor() public {
      storedData = 10;   // Using State variable
   }
}

स्थानीय चर

चर जिनके मान केवल एक फ़ंक्शन के भीतर उपलब्ध हैं, जहां इसे परिभाषित किया गया है। फ़ंक्शन पैरामीटर हमेशा उस फ़ंक्शन के लिए स्थानीय होते हैं।

pragma solidity ^0.5.0;
contract SolidityTest {
   uint storedData; // State variable
   constructor() public {
      storedData = 10;   
   }
   function getResult() public view returns(uint){
      uint a = 1; // local variable
      uint b = 2;
      uint result = a + b;
      return result; //access the local variable
   }
}

उदाहरण

pragma solidity ^0.5.0;
contract SolidityTest {
   uint storedData; // State variable
   constructor() public {
      storedData = 10;   
   }
   function getResult() public view returns(uint){
      uint a = 1; // local variable
      uint b = 2;
      uint result = a + b;
      return storedData; //access the state variable
   }
}

सॉलिडिटी फर्स्ट एप्लीकेशन चैप्टर में दिए गए चरणों का उपयोग करके उपरोक्त प्रोग्राम को चलाएं ।

उत्पादन

0: uint256: 10

सार्वत्रिक चर

ये विशेष चर हैं जो वैश्विक कार्यक्षेत्र में मौजूद हैं और ब्लॉकचेन और लेनदेन गुणों के बारे में जानकारी प्रदान करते हैं।

नाम	रिटर्न
ब्लॉकश (यूंट ब्लॉकनंबर) रिटर्न (बाइट्स 32)	दिए गए ब्लॉक का हैश - वर्तमान, ब्लॉक को छोड़कर केवल 256 सबसे हाल के लिए काम करता है
block.coinbase (पता देय)	वर्तमान ब्लॉक की खान का पता
block.difficulty (uint)	वर्तमान ब्लॉक कठिनाई
block.gaslimit (uint)	करंट ब्लॉक गैसलिमिट
ब्लॉक.नंबर (यूंट)	वर्तमान ब्लॉक संख्या
block.timestamp (uint)	यूनिक्स युग के बाद से सेकंड के रूप में वर्तमान ब्लॉक टाइमस्टैम्प
गैसलिफ्ट () रिटर्न (uint256)	शेष गैस
msg.data (बाइट्स कैलडटा)	पूर्ण कैलता
msg.sender (पता देय)	संदेश भेजने वाला (वर्तमान कॉलर)
msg.sig (बाइट्स 4)	कालदत्ता के पहले चार बाइट्स (फ़ंक्शन पहचानकर्ता)
msg.value (uint)	संदेश के साथ भेजे गए वी की संख्या
अब (uint)	वर्तमान ब्लॉक टाइमस्टैम्प
tx.gasprice (uint)	लेन-देन की गैस की कीमत
tx.origin (पता देय)	लेन-देन करने वाला

ठोसता नामकरण

सॉलिडिटी में अपने चरों का नामकरण करते समय, निम्नलिखित नियमों को ध्यान में रखें।

आपको चर नाम के रूप में किसी भी सॉलिडिटी आरक्षित कीवर्ड का उपयोग नहीं करना चाहिए। इन खोजशब्दों का उल्लेख अगले भाग में किया गया है। उदाहरण के लिए, विराम या बूलियन चर नाम मान्य नहीं हैं।
सॉलिडिटी चर नाम एक अंक (0-9) से शुरू नहीं होने चाहिए। उन्हें एक पत्र या एक अंडरस्कोर चरित्र के साथ शुरू करना चाहिए। उदाहरण के लिए, 123test एक अमान्य चर नाम है, लेकिन _123test एक वैध है।
सॉलिडिटी चर नाम केस-संवेदी होते हैं। उदाहरण के लिए, नाम और नाम दो अलग-अलग चर हैं।

स्थानीय चर का दायरा कार्य करने के लिए सीमित है जिसमें वे परिभाषित हैं लेकिन राज्य चर में तीन प्रकार के स्कोप हो सकते हैं।

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

उदाहरण

pragma solidity ^0.5.0;
contract C {
   uint public data = 30;
   uint internal iData= 10;
   
   function x() public returns (uint) {
      data = 3; // internal access
      return data;
   }
}
contract Caller {
   C c = new C();
   function f() public view returns (uint) {
      return c.data(); //external access
   }
}
contract D is C {
   function y() public returns (uint) {
      iData = 3; // internal access
      return iData;
   }
   function getResult() public view returns(uint){
      uint a = 1; // local variable
      uint b = 2;
      uint result = a + b;
      return storedData; //access the state variable
   }
}

एक ऑपरेटर क्या है?

आइए हम एक सरल अभिव्यक्ति लेते हैं 4 + 5 is equal to 9। यहां 4 और 5 कहा जाता हैoperands और '+' को कहा जाता है operator। सॉलिडिटी निम्नलिखित प्रकार के ऑपरेटरों का समर्थन करती है।

अंकगणितीय आपरेटर
तुलना संचालक
तार्किक (या संबंधपरक) संचालक
असाइनमेंट ऑपरेटर्स
सशर्त (या टर्नरी) संचालक

एक-एक करके सभी ऑपरेटरों पर नजर डालते हैं।

अंकगणितीय आपरेटर

सॉलिडिटी निम्नलिखित अंकगणितीय ऑपरेटरों का समर्थन करती है -

चर ए मान लें 10 और चर बी 20 रखती है, तो -

उदाहरण दिखाएँ

अनु क्रमांक।	ऑपरेटर और विवरण
1	+ (Addition) दो ऑपरेंड जोड़ता है Ex: A + B 30 देगा
2	- (Subtraction) पहले से दूसरे ऑपरेंड को घटाता है Ex: A - B देगा -10
3	* (Multiplication) दोनों ऑपरेंड को गुणा करें Ex: A * B 200 देगा
4	/ (Division) भाजक को अंश से विभाजित करें Ex: B / A 2 देगा
5	% (Modulus) एक पूर्णांक विभाजन के शेष आउटपुट Ex: ब% ए द 0 दे खोगे
6	++ (Increment) एक पूर्णांक मान बढ़ाता है Ex: A ++ 11 देगा
7	-- (Decrement) एक पूर्णांक मान घटाता है Ex: A-- 9 देंगे

तुलना संचालक

सॉलिडिटी निम्नलिखित तुलना ऑपरेटरों का समर्थन करती है -

चर ए मान लें 10 और चर बी 20 रखती है, तो -

उदाहरण दिखाएँ

अनु क्रमांक।	ऑपरेटर और विवरण
1	= = (Equal) चेक करता है कि दो ऑपरेंड का मूल्य बराबर है या नहीं, यदि हाँ, तो स्थिति सच हो जाती है। Ex: (ए == बी) सच नहीं है।
2	!= (Not Equal) चेक करता है कि दो ऑपरेंड का मान बराबर है या नहीं, यदि मान बराबर नहीं हैं, तो स्थिति सही हो जाती है। Ex: (ए! = बी) सच है।
3	> (Greater than) जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक है, यदि हाँ, तो स्थिति सच हो जाती है। Ex: (ए> बी) सच नहीं है।
4	< (Less than) जाँच करता है कि यदि बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से कम है, यदि हाँ, तो स्थिति सच हो जाती है। Ex: (ए <बी) सच है।
5	>= (Greater than or Equal to) जाँच करता है कि यदि बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या उसके बराबर है, यदि हाँ, तो स्थिति सही हो जाती है। Ex: (ए> = बी) सच नहीं है।
6	<= (Less than or Equal to) जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से कम या उसके बराबर है, यदि हाँ, तो स्थिति सही हो जाती है। Ex: (ए <= बी) सच है।

लॉजिकल ऑपरेटर्स

सॉलिडिटी निम्नलिखित तार्किक ऑपरेटरों का समर्थन करती है -

चर ए मान लें 10 और चर बी 20 रखती है, तो -

उदाहरण दिखाएँ

अनु क्रमांक।	ऑपरेटर और विवरण
1	&& (Logical AND) यदि दोनों ऑपरेशंस गैर-शून्य हैं, तो स्थिति सच हो जाती है। Ex: (A && B) सत्य है।
2	\|\| (Logical OR) यदि दोनों संचालकों में से कोई भी गैर-शून्य है, तो स्थिति सच हो जाती है। Ex: (ए \|\| बी) सच है
3	! (Logical NOT) अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सत्य है, तो लॉजिकल नॉट ऑपरेटर इसे गलत बना देगा। Ex:! (A && B) गलत है।

बिटवाइज ऑपरेटर्स

सॉलिडिटी निम्नलिखित बिटवाइज़ ऑपरेटरों का समर्थन करती है -

चर A मानें 2 और चर B 3 धारण करता है, तो -

उदाहरण दिखाएँ

अनु क्रमांक।	ऑपरेटर और विवरण
1	& (Bitwise AND) यह अपने पूर्णांक तर्कों के प्रत्येक बिट पर एक बूलियन और ऑपरेशन करता है। Ex: (A & B) 2 है।
2	\| (BitWise OR) यह अपने पूर्णांक तर्कों के प्रत्येक बिट पर एक बूलियन या ऑपरेशन करता है। Ex: (ए \| बी) 3 है।
3	^ (Bitwise XOR) यह अपने पूर्णांक तर्कों के प्रत्येक बिट पर एक बूलियन अनन्य या ऑपरेशन करता है। एक्सक्लूसिव OR का मतलब है कि या तो ऑपरेंड एक सच है या ऑपरेंड दो सही है, लेकिन दोनों नहीं। Ex: (ए ^ बी) 1 है।
4	~ (Bitwise Not) यह एक अपरिपक्व ऑपरेटर है और ऑपरेंड में सभी बिट्स को उलट कर संचालित करता है। Ex: (~ बी) -4 है।
5	<< (Left Shift) यह दूसरे ऑपरेंड में निर्दिष्ट स्थानों की संख्या से अपने पहले ऑपरेंड में सभी बिट्स को बाईं ओर ले जाता है। नए बिट्स शून्य से भरे हुए हैं। एक स्थिति द्वारा छोड़े गए मूल्य को 2 से गुणा करने के बराबर है, दो पदों को स्थानांतरित करना 4 से गुणा करने के बराबर है, और इसी तरह। Ex: (ए << 1) 4 है।
6	>> (Right Shift) बाइनरी राइट शिफ्ट ऑपरेटर। बाएं ऑपरेंड का मान दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या द्वारा दाईं ओर ले जाया जाता है। Ex: (ए >> 1) 1 है।
7	>>> (Right shift with Zero) यह ऑपरेटर >> ऑपरेटर की तरह ही है, सिवाय इसके कि बाईं ओर स्थानांतरित बिट्स हमेशा शून्य हैं। Ex: (ए >>> 1) 1 है।

असाइनमेंट ऑपरेटर्स

सॉलिडिटी निम्नलिखित असाइनमेंट ऑपरेटरों का समर्थन करती है -

उदाहरण दिखाएँ

अनु क्रमांक।	ऑपरेटर और विवरण
1	= (Simple Assignment ) राइट साइड ऑपरेंड से लेफ्ट साइड ऑपरेंड तक वैल्यू असाइन करता है Ex: C = A + B A + B के C में मान प्रदान करेगा
2	+= (Add and Assignment) यह बाएं ऑपरेंड में दाईं ओर ऑपरेंड जोड़ता है और परिणाम को बाएं ऑपरेंड में असाइन करता है। Ex: C + = A C = C + A के बराबर है
3	−= (Subtract and Assignment) यह बाएं ऑपरेंड से दाएं ऑपरेंड को घटाता है और लेफ्ट ऑपरेंड को रिजल्ट सौंपता है। Ex: C - = A C = C - A के बराबर है
4	= (Multiply and Assignment) यह बाएं ऑपरेंड के साथ दाहिने ऑपरेंड को गुणा करता है और परिणाम को बाएं ओपैंड पर असाइन करता है। Ex:* C * = A C = C * A के बराबर है
5	/= (Divide and Assignment) यह बाएं ऑपरेंड को दाएं ऑपरेंड के साथ विभाजित करता है और परिणाम को बाएं ऑपरेंड को सौंपता है। Ex: C / = A C = C / A के बराबर है
6	%= (Modules and Assignment) यह दो ऑपरेंड का उपयोग करके मापांक लेता है और परिणाम को बाएं ऑपरेंड में असाइन करता है। Ex: C% = A C = C% A के बराबर है

Note - समान तर्क बिटवाइज ऑपरेटरों के लिए लागू होते हैं, इसलिए वे << =, >> =, >> =, और =, | = = और ^ = जैसे बन जाएंगे।

सशर्त संचालक (:)

सशर्त ऑपरेटर पहले एक सच्चे या गलत मूल्य के लिए एक अभिव्यक्ति का मूल्यांकन करता है और फिर मूल्यांकन के परिणाम के आधार पर दो दिए गए कथनों में से एक को निष्पादित करता है।

उदाहरण दिखाएँ

अनु क्रमांक।	ऑपरेटर और विवरण
1	? : (Conditional ) अगर हालत सच है? तब X मान: अन्यथा Y मान

एक अनुबंध लिखते समय, आप एक ऐसी स्थिति का सामना कर सकते हैं जहां आपको बार-बार कार्रवाई करने की आवश्यकता होती है। ऐसी स्थितियों में, आपको लाइनों की संख्या कम करने के लिए लूप स्टेटमेंट लिखना होगा।

सॉलिडिटी प्रोग्रामिंग के दबाव को कम करने के लिए सभी आवश्यक छोरों का समर्थन करती है।

अनु क्रमांक	लूप्स और विवरण
1	घुमाव के दौरान सॉलिडिटी में सबसे बुनियादी लूप है जबकि लूप है जिसकी चर्चा इस अध्याय में की जाएगी।
2	करते हैं ... जबकि लूप करें ... जबकि लूप, लूप के समान है, सिवाय इसके कि लूप के अंत में कंडीशन चेक होती है।
3	पाश के लिए लूप के लिए लूपिंग का सबसे कॉम्पैक्ट रूप है। इसमें निम्नलिखित तीन महत्वपूर्ण भाग शामिल हैं।
4	लूप नियंत्रण सॉलिडिटी लूप को संभालने और स्टेटमेंट को स्विच करने के लिए पूर्ण नियंत्रण प्रदान करता है।

एक कार्यक्रम लिखते समय, एक स्थिति हो सकती है जब आपको दिए गए सेटों में से एक को अपनाने की आवश्यकता होती है। ऐसे मामलों में, आपको सशर्त बयानों का उपयोग करने की आवश्यकता होती है जो आपके कार्यक्रम को सही निर्णय लेने और सही कार्य करने की अनुमति देते हैं।

सॉलिडिटी सशर्त बयानों का समर्थन करती है जो विभिन्न स्थितियों के आधार पर विभिन्न कार्यों को करने के लिए उपयोग किए जाते हैं। यहां हम बताएंगेif..else बयान।

अगर-और का फ्लो चार्ट

निम्न प्रवाह चार्ट दिखाता है कि कैसे-और स्टेटमेंट काम करता है।

सॉलिडिटी निम्नलिखित रूपों का समर्थन करती है if..else कथन -

अनु क्रमांक	कथन और विवरण
1	अगर बयान अगर स्टेटमेंट मौलिक नियंत्रण कथन है जो सॉलिडिटी को निर्णय लेने और सशर्त रूप से निष्पादित करने की अनुमति देता है।
2	अगर ... और बयान 'If ... else' स्टेटमेंट कंट्रोल स्टेटमेंट का अगला रूप है जो सॉलिडिटी को अधिक नियंत्रित तरीके से स्टेटमेंट्स को निष्पादित करने की अनुमति देता है।
3	अगर ... और अगर ... बयान। If ... if if ... स्टेटमेंट if का एक उन्नत रूप है ... और तो और यह कि सॉलिडिटी को कई स्थितियों में से एक सही निर्णय लेने की अनुमति देता है।

सॉलिडिटी स्ट्रिंग बोली को दोहरे उद्धरण चिह्नों (") और एकल उद्धरण (') दोनों का उपयोग करते हुए समर्थन करती है। यह स्ट्रिंग के एक वेरिएबल को घोषित करने के लिए डेटा प्रकार के रूप में स्ट्रिंग प्रदान करता है।

pragma solidity ^0.5.0;

contract SolidityTest {
   string data = "test";
}

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

pragma solidity ^0.5.0;

contract SolidityTest {
   bytes32 data = "test";
}

वर्ण से बचो

अनु क्रमांक।	चरित्र विवरण, चारित्रिक व्यौरा, वर्णन, व्याख्या
1	\n एक नई लाइन शुरू करता है।
2	\\ बैकस्लैश
3	\' एकल बोली
4	\" दोहरे उद्धरण
5	\b बैकस्पेस
6	\f फ़ीड बनाएं
7	\r कैरिज रिटर्न
8	\t टैब
9	\v लंबवत टैब
10	\xNN हेक्स मूल्य का प्रतिनिधित्व करता है और उपयुक्त बाइट्स सम्मिलित करता है।
1 1	\uNNNN यूनिकोड मूल्य का प्रतिनिधित्व करता है और UTF-8 अनुक्रम सम्मिलित करता है।

बाइट्स से स्ट्रिंग रूपांतरण

बाइट्स स्ट्रिंग () कंस्ट्रक्टर का उपयोग करके स्ट्रिंग में परिवर्तित किया जा सकता है।

bytes memory bstr = new bytes(10);
string message = string(bstr);

उदाहरण

निम्नलिखित कोड को समझने की कोशिश करें कि स्ट्रिंग सॉलिडिटी में कैसे काम करती है।

pragma solidity ^0.5.0;

contract SolidityTest {   
   constructor() public{       
   }
   function getResult() public view returns(string memory){
      uint a = 1; 
      uint b = 2;
      uint result = a + b;
      return integerToString(result); 
   }
   function integerToString(uint _i) internal pure 
      returns (string memory) {
      
      if (_i == 0) {
         return "0";
      }
      uint j = _i;
      uint len;
      
      while (j != 0) {
         len++;
         j /= 10;
      }
      bytes memory bstr = new bytes(len);
      uint k = len - 1;
      
      while (_i != 0) {
         bstr[k--] = byte(uint8(48 + _i % 10));
         _i /= 10;
      }
      return string(bstr);
   }
}

उत्पादन

0: string: 3

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

नंबर चर, नंबर 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);
   }
}

Enums केवल कुछ पूर्वनिर्धारित मूल्यों में से एक होने के लिए एक चर को प्रतिबंधित करते हैं। इस प्रगणित सूची के मूल्यों को एनम कहा जाता है।

Enums के उपयोग से आपके कोड में बगों की संख्या को कम करना संभव है।

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

उदाहरण

निम्न कोड को समझने की कोशिश करें कि एनुम सॉलिडिटी में कैसे काम करता है।

pragma solidity ^0.5.0;

contract test {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize choice;
   FreshJuiceSize constant defaultChoice = FreshJuiceSize.MEDIUM;

   function setLarge() public {
      choice = FreshJuiceSize.LARGE;
   }
   function getChoice() public view returns (FreshJuiceSize) {
      return choice;
   }
   function getDefaultChoice() public pure returns (uint) {
      return uint(defaultChoice);
   }
}

पहला क्लिक करें setLarge मान को LARGE के रूप में सेट करने के लिए बटन पर क्लिक करें getChoice चयनित विकल्प पाने के लिए।

उत्पादन

uint8: 2

क्लिक getDefaultChoice डिफ़ॉल्ट विकल्प प्राप्त करने के लिए बटन।

उत्पादन

uint256: 1

एक रिकॉर्ड का प्रतिनिधित्व करने के लिए संरचना प्रकार का उपयोग किया जाता है। मान लीजिए कि आप किसी लाइब्रेरी में अपनी पुस्तकों पर नज़र रखना चाहते हैं। आप प्रत्येक पुस्तक के बारे में निम्नलिखित विशेषताओं को ट्रैक करना चाहते हैं -

Title
Author
Subject
बुक आईडी

एक संरचना को परिभाषित करना

एक संरचना को परिभाषित करने के लिए, आपको इसका उपयोग करना होगा structकीवर्ड। एक से अधिक सदस्यों के साथ एक नया डेटा प्रकार को परिभाषित करता है। संरचना विवरण का प्रारूप इस प्रकार है -

struct struct_name { 
   type1 type_name_1;
   type2 type_name_2;
   type3 type_name_3;
}

उदाहरण

struct Book { 
   string title;
   string author;
   uint book_id;
}

एक संरचना और उसके चर पर पहुँचना

किसी संरचना के किसी भी सदस्य को एक्सेस करने के लिए, हम सदस्य एक्सेस ऑपरेटर (।) का उपयोग करते हैं। सदस्य एक्सेस ऑपरेटर को संरचना चर नाम और संरचना सदस्य के बीच की अवधि के रूप में कोडित किया जाता है जिसे हम एक्सेस करना चाहते हैं। आप संरचना प्रकार के चर को परिभाषित करने के लिए संरचना का उपयोग करेंगे। निम्न उदाहरण दिखाता है कि किसी प्रोग्राम में संरचना का उपयोग कैसे किया जाए।

उदाहरण

सॉलिडिटी में संरचना कैसे काम करती है, यह समझने के लिए निम्न कोड का प्रयास करें।

pragma solidity ^0.5.0;

contract test {
   struct Book { 
      string title;
      string author;
      uint book_id;
   }
   Book book;

   function setBook() public {
      book = Book('Learn Java', 'TP', 1);
   }
   function getBookId() public view returns (uint) {
      return book.book_id;
   }
}

पहला क्लिक करें setBook मान को LARGE के रूप में सेट करने के लिए बटन पर क्लिक करें getBookId चयनित पुस्तक आईडी पाने के लिए।

उत्पादन

uint256: 1

मानचित्रण एक संदर्भ प्रकार है जो सरणियों और संरचनाओं के रूप में है। मैपिंग प्रकार घोषित करने के लिए सिंटैक्स निम्नलिखित है।

mapping(_KeyType => _ValueType)

कहाँ पे

_KeyType- किसी भी प्रकार में निर्मित बाइट्स और स्ट्रिंग हो सकते हैं। कोई संदर्भ प्रकार या जटिल ऑब्जेक्ट की अनुमति नहीं है।
_ValueType - कोई भी प्रकार हो सकता है।

विचार

मानचित्रण केवल प्रकार का हो सकता है storage और आम तौर पर राज्य चर के लिए उपयोग किया जाता है।
मैपिंग को सार्वजनिक किया जा सकता है। सॉलिडिटी स्वचालित रूप से इसके लिए गेटटर बनाती है।

उदाहरण

सॉलिडिटी में मैपिंग प्रकार कैसे काम करता है, यह समझने के लिए निम्न कोड का प्रयास करें।

pragma solidity ^0.5.0;

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

   function updateBalance(uint newBalance) public {
      balances[msg.sender] = newBalance;
   }
}
contract Updater {
   function updateBalance() public returns (uint) {
      LedgerBalance ledgerBalance = new LedgerBalance();
      ledgerBalance.updateBalance(10);
      return ledgerBalance.balances(address(this));
   }
}

पहला क्लिक करें updateBalance मान को 10 के रूप में सेट करने के लिए बटन तब लॉग में देखें जो डिकोडेड आउटपुट को दिखाएगा -

उत्पादन

{
   "0": "uint256: 10"
}

सॉलिडिटी निहित और साथ ही स्पष्ट रूपांतरण की अनुमति देती है। सॉलिडिटी कंपाइलर दो डेटा प्रकारों के बीच अंतर्निहित रूपांतरण की अनुमति देता है, बशर्ते कि कोई भी रूपांतरण संभव नहीं है और जानकारी का कोई नुकसान नहीं है। उदाहरण के लिए uint8 uint16 के लिए परिवर्तनीय है, लेकिन int8 uint256 के लिए परिवर्तनीय है क्योंकि int8 में uint256 में नकारात्मक मूल्य की अनुमति नहीं है।

स्पष्ट रूपांतरण

हम स्पष्ट रूप से एक डेटा प्रकार को कंस्ट्रक्टर सिंटैक्स का उपयोग करके परिवर्तित कर सकते हैं।

int8 y = -3;
uint x = uint(y);
//Now x = 0xfffff..fd == two complement representation of -3 in 256 bit format.

छोटे प्रकार के रूपांतरण से उच्चतर बिट्स का खर्च होता है।

uint32 a = 0x12345678;
uint16 b = uint16(a); // b = 0x5678

उच्च प्रकार में रूपांतरण बाईं ओर गद्दी बिट्स जोड़ता है।

uint16 a = 0x1234;
uint32 b = uint32(a); // b = 0x00001234

छोटे बाइट में रूपांतरण से उच्चतर डेटा खर्च होता है।

bytes2 a = 0x1234;
bytes1 b = bytes1(a); // b = 0x12

बड़े बाइट में रूपांतरण दाईं ओर पैडिंग बिट्स जोड़ते हैं।

bytes2 a = 0x1234;
bytes4 b = bytes4(a); // b = 0x12340000

निश्चित आकार के बाइट और इंट के बीच रूपांतरण केवल तभी संभव है जब दोनों समान आकार के हों।

bytes2 a = 0x1234;
uint32 b = uint16(a); // b = 0x00001234
uint32 c = uint32(bytes4(a)); // c = 0x12340000
uint8 d = uint8(uint16(a)); // d = 0x34
uint8 e = uint8(bytes1(a)); // e = 0x12

हेक्साडेसिमल संख्याओं को किसी भी पूर्णांक प्रकार को सौंपा जा सकता है यदि कोई ट्रंकेशन की आवश्यकता नहीं है।

uint8 a = 12; // no error
uint32 b = 1234; // no error
uint16 c = 0x123456; // error, as truncation required to 0x3456

ठोसता में हम विभिन्न ईथर आधारित संप्रदायों को परिवर्तित करने के लिए इस्तेमाल किए जाने वाले शाब्दिक के लिए एक प्रत्यय के रूप में वी, फिननी, सब्ज़ो या ईथर का उपयोग कर सकते हैं। निम्नतम इकाई मूत है और 1e12 1 x 10 ^{12 का} प्रतिनिधित्व करता है ।

assert(1 wei == 1);
assert(1 szabo == 1e12);
assert(1 finney == 1e15);
assert(1 ether == 1e18);
assert(2 ether == 2000 fenny);

समय इकाइयाँ

मुद्रा के समान, सॉलिडिटी में समय इकाइयाँ होती हैं जहाँ सबसे कम इकाई दूसरी होती है और हम समय को दर्शाने के लिए प्रत्यय के रूप में सेकंड, मिनट, घंटे, दिन और सप्ताह का उपयोग कर सकते हैं।

assert(1 seconds == 1);
assert(1 minutes == 60 seconds);
assert(1 hours == 60 minutes);
assert(1 day == 24 hours);
assert(1 week == 7 days);

विशेष चर विश्व स्तर पर उपलब्ध चर हैं और ब्लॉकचेन के बारे में जानकारी प्रदान करते हैं। निम्नलिखित विशेष चर की सूची है -

अनु क्रमांक।	विशेष चर और विवरण
1	blockhash(uint blockNumber) returns (bytes32) दिए गए ब्लॉक का हैश - वर्तमान, ब्लॉक को छोड़कर केवल 256 सबसे हाल के लिए काम करता है।
2	block.coinbase (address payable) वर्तमान ब्लॉक की खान का पता।
3	block.difficulty (uint) वर्तमान ब्लॉक कठिनाई।
4	block.gaslimit (uint) करंट ब्लॉक गैसलिमिट।
5	block.number (uint) वर्तमान ब्लॉक संख्या।
6	block.timestamp यूनिक्स युग के बाद से सेकंड के रूप में वर्तमान ब्लॉक टाइमस्टैम्प।
7	gasleft() returns (uint256) शेष गैस।
8	msg.data (bytes calldata) पूर्ण कैलता।
9	msg.sender (address payable) संदेश भेजने वाला (वर्तमान कॉल)।
10	msg.sig (bytes4) कालदत्ता के पहले चार बाइट्स (यानी फ़ंक्शन पहचानकर्ता)
1 1	msg.value (uint) संदेश के साथ भेजे गए वी की संख्या।
12	now (uint) वर्तमान ब्लॉक टाइमस्टैम्प (ब्लॉक के लिए उपनाम)।
13	tx.gasprice (uint) लेन-देन की गैस की कीमत।
14	tx.origin (address payable) लेन-देन का प्रेषक (पूर्ण कॉल श्रृंखला)।

उदाहरण

सॉलिडिटी में प्रेषक का पता प्राप्त करने के लिए एक विशेष चर मैसेंजर का उपयोग देखने के लिए निम्न कोड का प्रयास करें।

pragma solidity ^0.5.0;

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

   function updateBalance(uint newBalance) public {
      balances[msg.sender] = newBalance;
   }
}
contract Updater {
   function updateBalance() public returns (uint) {
      LedgerBalance ledgerBalance = new LedgerBalance();
      ledgerBalance.updateBalance(10);
      return ledgerBalance.balances(address(this));
   }
}

उत्पादन

{
   "0": "uint256: 10"
}

स्टाइल गाइड कोड लेआउट को बनाए रखने और कोड को अधिक पठनीय बनाने में मदद करता है। सॉलिडिटी के साथ अनुबंध लिखते समय निम्नलिखित सर्वोत्तम अभ्यास हैं।

कोड लेआउट

Indentation- इंडेंटेशन लेवल बनाए रखने के लिए टैब की जगह 4 स्पेस का इस्तेमाल करें। टैब के साथ रिक्त स्थान मिलाने से बचें।
Two Blank Lines Rule - दो अनुबंध परिभाषाओं के बीच 2 खाली लाइनों का उपयोग करें।

pragma solidity ^0.5.0;

contract LedgerBalance {
   //...
}
contract Updater {
   //...
}

One Blank Line Rule- दो कामों के बीच ब्लैंक लाइन का प्रयोग करें। केवल घोषणा के मामले में, खाली लाइनों की आवश्यकता नहीं है।

pragma solidity ^0.5.0;

contract A {
   function balance() public pure;
   function account() public pure;
}
contract B is A {
   function balance() public pure {
      // ...
   }
   function account() public pure {
      // ...
   }
}

Maximum Line Length - एकल पंक्ति को 79 वर्णों को पार नहीं करना चाहिए ताकि पाठक आसानी से कोड को पार्स कर सकें।
Wrapping rules- पहले तर्क बिना कोष्ठक खोले नई लाइन में हो। प्रति तर्क एकल इंडेंट का उपयोग करें। समापन तत्व); आखिरी होना चाहिए।

function_with_a_long_name(
   longArgument1,
   longArgument2,
   longArgument3
);
variable = function_with_a_long_name(
   longArgument1,
   longArgument2,
   longArgument3
);
event multipleArguments(
   address sender,
   address recipient,
   uint256 publicKey,
   uint256 amount,
   bytes32[] options
);
MultipleArguments(
   sender,
   recipient,
   publicKey,
   amount,
   options
);

Source Code Encoding - UTF-8 या ASCII एन्कोडिंग का उपयोग अधिमानतः किया जाना है।
Imports - आयात विवरणों को केवल घोषणा के बाद फ़ाइल के शीर्ष पर रखा जाना चाहिए।
Order of Functions - कार्यों को उनकी दृश्यता के अनुसार समूहीकृत किया जाना चाहिए।

pragma solidity ^0.5.0;

contract A {
   constructor() public {
      // ...
   }
   function() external {
      // ...
   }

   // External functions
   // ...

   // External view functions
   // ...

   // External pure functions 
   // ...

   // Public functions
   // ...

   // Internal functions
   // ...

   // Private functions
   // ...
}

Avoid extra whitespaces - कोष्ठक, कोष्ठक या ब्रेस के अंदर तुरंत व्हाट्सएप से बचें।
Control structures- ब्रेसिज़ को घोषणा के रूप में एक ही लाइन पर खोलना चाहिए। उसी इंडेंटेशन को बनाए रखते हुए अपनी लाइन को बंद करें। ब्रेसिंग खोलने के साथ एक स्थान का उपयोग करें।

pragma solidity ^0.5.0;

contract Coin {
   struct Bank {
      address owner;
      uint balance;
   }
}
if (x < 3) {
   x += 1;
} else if (x > 7) {
   x -= 1;
} else {
   x = 5;
}
if (x < 3)
   x += 1;
else
   x -= 1;

Function Declaration- ब्रेसिज़ के लिए उपरोक्त नियम का उपयोग करें। हमेशा एक दृश्यता लेबल जोड़ें। किसी भी कस्टम संशोधक से पहले दृश्यता लेबल पहले आना चाहिए।

function kill() public onlyowner {
   selfdestruct(owner);
}

Mappings - मैपिंग वैरिएबल की घोषणा करते समय व्हाट्सएप से बचें।

mapping(uint => uint) map;
mapping(address => bool) registeredAddresses;
mapping(uint => mapping(bool => Data[])) public data;
mapping(uint => mapping(uint => s)) data;

Variable declaration - ऐरे वेरिएबल की घोषणा करते समय व्हाट्सएप से बचें।

uint[] x;  // not unit [] x;

String declaration - सिंगल कोट्स के बजाय स्ट्रिंग घोषित करने के लिए डबल कोट्स का उपयोग करें।

str = "foo";
str = "Hamlet says, 'To be or not to be...'";

लेआउट का आदेश

तत्वों को निम्नलिखित क्रम में लेआउट होना चाहिए।

प्रज्ञा कथन
आयात बयान
Interfaces
Libraries
Contracts

Interfaces, पुस्तकालयों या अनुबंधों के अनुसार क्रम निम्नानुसार होना चाहिए -

घोषणाएं लिखें
चर बताएं
Events
Functions

नामकरण की परंपरा

कॉन्ट्रैक्ट और लाइब्रेरी का नाम कैपिटोस स्टाइल का उपयोग करके रखा जाना चाहिए। उदाहरण के लिए, SmartContract, स्वामी आदि।
अनुबंध और लाइब्रेरी का नाम उनके फ़ाइल नामों से मेल खाना चाहिए।
एक फ़ाइल में कई अनुबंधों / पुस्तकालयों के मामले में, कोर अनुबंध / पुस्तकालय के नाम का उपयोग करें।

Owned.sol

pragma solidity ^0.5.0;

// Owned.sol
contract Owned {
   address public owner;
   constructor() public {
      owner = msg.sender;
   }
   modifier onlyOwner {
      //....
   }
   function transferOwnership(address newOwner) public onlyOwner {
      //...
   }
}

Congress.sol

pragma solidity ^0.5.0;

// Congress.sol
import "./Owned.sol";

contract Congress is Owned, TokenRecipient {
   //...
}

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

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

किसी भी अन्य उन्नत प्रोग्रामिंग भाषा की तरह, सॉलिडिटी भी फ़ंक्शन का उपयोग करके मॉड्यूलर कोड लिखने के लिए आवश्यक सभी सुविधाओं का समर्थन करती है। यह खंड बताता है कि सॉलिडिटी में अपने स्वयं के कार्यों को कैसे लिखना है।

कार्य की परिभाषा

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

वाक्य - विन्यास

मूल वाक्यविन्यास यहाँ दिखाया गया है।

function function-name(parameter-list) scope returns() {
   //statements
}

उदाहरण

निम्न उदाहरण का प्रयास करें। यह getResult नामक एक फ़ंक्शन को परिभाषित करता है जो कोई पैरामीटर नहीं लेता है -

pragma solidity ^0.5.0;

contract Test {
   function getResult() public view returns(uint){
      uint a = 1; // local variable
      uint b = 2;
      uint result = a + b;
      return result;
   }
}

एक समारोह बुला रहा है

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

pragma solidity ^0.5.0;

contract SolidityTest {   
   constructor() public{       
   }
   function getResult() public view returns(string memory){
      uint a = 1; 
      uint b = 2;
      uint result = a + b;
      return integerToString(result); 
   }
   function integerToString(uint _i) internal pure 
      returns (string memory) {
      
      if (_i == 0) {
         return "0";
      }
      uint j = _i;
      uint len;
      
      while (j != 0) {
         len++;
         j /= 10;
      }
      bytes memory bstr = new bytes(len);
      uint k = len - 1;
      
      while (_i != 0) {
         bstr[k--] = byte(uint8(48 + _i % 10));
         _i /= 10;
      }
      return string(bstr);//access local variable
   }
}

उत्पादन

0: string: 3

फ़ंक्शन पैरामीटर

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

उदाहरण

निम्न उदाहरण का प्रयास करें। हमने एक का उपयोग किया हैuint2strयहां कार्य करें। यह एक पैरामीटर लेता है।

pragma solidity ^0.5.0;

contract SolidityTest {   
   constructor() public{       
   }
   function getResult() public view returns(string memory){
      uint a = 1; 
      uint b = 2;
      uint result = a + b;
      return integerToString(result); 
   }
   function integerToString(uint _i) internal pure 
      returns (string memory) {
      
      if (_i == 0) {
         return "0";
      }
      uint j = _i;
      uint len;
      
      while (j != 0) {
         len++;
         j /= 10;
      }
      bytes memory bstr = new bytes(len);
      uint k = len - 1;
      
      while (_i != 0) {
         bstr[k--] = byte(uint8(48 + _i % 10));
         _i /= 10;
      }
      return string(bstr);//access local variable
   }
}

उत्पादन

0: string: 3

वापसी विवरण

एक सॉलिडिटी फ़ंक्शन एक वैकल्पिक हो सकता है returnबयान। यह आवश्यक है यदि आप किसी फ़ंक्शन से मान वापस करना चाहते हैं। यह कथन किसी फ़ंक्शन में अंतिम कथन होना चाहिए।

उपरोक्त उदाहरण के अनुसार, हम स्ट्रिंग वापस करने के लिए uint2str फ़ंक्शन का उपयोग कर रहे हैं।

सॉलिडिटी में, एक फ़ंक्शन कई मानों को भी वापस कर सकता है। नीचे दिए गए उदाहरण देखें -

pragma solidity ^0.5.0;

contract Test {
   function getResult() public view returns(uint product, uint sum){
      uint a = 1; // local variable
      uint b = 2;
      product = a * b;
      sum = a + b;
  
      //alternative return statement to return 
      //multiple values
      //return(a*b, a+b);
   }
}

उत्पादन

0: uint256: product 2
1: uint256: sum 3

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

पहले हम पैरामीटर के साथ या उसके बिना एक संशोधक बनाते हैं।

contract Owner {
   modifier onlyOwner {
      require(msg.sender == owner);
      _;
   }
   modifier costs(uint price) {
      if (msg.value >= price) {
         _;
      }
   }
}

फ़ंक्शन बॉडी को सम्मिलित किया जाता है जहां विशेष प्रतीक "_;" एक संशोधक की परिभाषा में दिखाई देता है। इसलिए यदि इस फ़ंक्शन को कॉल करते समय संशोधक की स्थिति संतुष्ट है, तो फ़ंक्शन निष्पादित किया जाता है और अन्यथा, एक अपवाद फेंक दिया जाता है।

नीचे दिए गए उदाहरण देखें -

pragma solidity ^0.5.0;

contract Owner {
   address owner;
   constructor() public {
      owner = msg.sender;
   }
   modifier onlyOwner {
      require(msg.sender == owner);
      _;
   }
   modifier costs(uint price) {
      if (msg.value >= price) {
         _;
      }
   }
}
contract Register is Owner {
   mapping (address => bool) registeredAddresses;
   uint price;
   constructor(uint initialPrice) public { price = initialPrice; }
   
   function register() public payable costs(price) {
      registeredAddresses[msg.sender] = true;
   }
   function changePrice(uint _price) public onlyOwner {
      price = _price;
   }
}

कार्य देखें यह सुनिश्चित करते हैं कि वे राज्य को संशोधित नहीं करेंगे। एक समारोह के रूप में घोषित किया जा सकता हैview। यदि फ़ंक्शन में मौजूद निम्न स्टेटमेंट को राज्य को संशोधित करने पर विचार किया जाता है और संकलक ऐसे मामलों में चेतावनी फेंक देगा।

राज्य चर संशोधित करना।
घटनाओं का उत्सर्जन।
अन्य अनुबंध बनाना।
आत्मशोधन का उपयोग करना।
कॉल के माध्यम से ईथर भेजना।
किसी भी फ़ंक्शन को कॉल करना जो चिह्नित या शुद्ध नहीं है।
निम्न-स्तरीय कॉल का उपयोग करना।
कुछ अफीम युक्त इनलाइन असेंबली का उपयोग करना।

डिफॉल्ट व्यू फ़ंक्शंस द्वारा गेट्टर विधि है।

दृश्य फ़ंक्शन का उपयोग करके नीचे दिए गए उदाहरण देखें।

उदाहरण

pragma solidity ^0.5.0;

contract Test {
   function getResult() public view returns(uint product, uint sum){
      uint a = 1; // local variable
      uint b = 2;
      product = a * b;
      sum = a + b; 
   }
}

उत्पादन

0: uint256: product 2
1: uint256: sum 3

शुद्ध कार्य यह सुनिश्चित करते हैं कि वे राज्य को पढ़े या संशोधित न करें। एक समारोह के रूप में घोषित किया जा सकता हैpure। निम्नलिखित कथन यदि फ़ंक्शन में मौजूद हैं, तो राज्य को पढ़ने पर विचार किया जाता है और संकलक ऐसे मामलों में चेतावनी देगा।

राज्य चर पढ़ना।
अभिगम संबोधन (यह)। असंतुलन या <पता>।
ब्लॉक, tx, msg (msg.sig और msg.data) के किसी भी विशेष चर को एक्सेस करके पढ़ा जा सकता है।
किसी भी फ़ंक्शन को कॉल करना शुद्ध नहीं है।
इनलाइन असेंबली का उपयोग करना जिसमें कुछ ऑपकोड होते हैं।

शुद्ध फ़ंक्शन रिवर्ट () का उपयोग कर सकते हैं और यदि कोई त्रुटि होती है, तो संभावित स्थिति परिवर्तनों को वापस करने के लिए () फ़ंक्शन की आवश्यकता होती है।

दृश्य फ़ंक्शन का उपयोग करके नीचे दिए गए उदाहरण देखें।

उदाहरण

pragma solidity ^0.5.0;

contract Test {
   function getResult() public pure returns(uint product, uint sum){
      uint a = 1; 
      uint b = 2;
      product = a * b;
      sum = a + b; 
   }
}

उत्पादन

0: uint256: product 2
1: uint256: sum 3

फालबैक फ़ंक्शन एक अनुबंध के लिए उपलब्ध एक विशेष फ़ंक्शन है। इसकी निम्नलिखित विशेषताएं हैं -

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

निम्नलिखित उदाहरण प्रति अनुबंध में एक फॉलबैक फ़ंक्शन की अवधारणा को दर्शाता है।

उदाहरण

pragma solidity ^0.5.0;

contract Test {
   uint public x ;
   function() external { x = 1; }    
}
contract Sink {
   function() external payable { }
}
contract Caller {
   function callTest(Test test) public returns (bool) {
      (bool success,) = address(test).call(abi.encodeWithSignature("nonExistingFunction()"));
      require(success);
      // test.x is now 1

      address payable testPayable = address(uint160(address(test)));

      // Sending ether to Test contract,
      // the transfer will fail, i.e. this returns false here.
      return (testPayable.send(2 ether));
   }
   function callSink(Sink sink) public returns (bool) {
      address payable sinkPayable = address(sink);
      return (sinkPayable.send(2 ether));
   }
}

समान दायरे में समान फ़ंक्शन नाम के लिए आपके पास कई परिभाषाएँ हो सकती हैं। फ़ंक्शन की परिभाषा तर्क सूची में प्रकारों और / या तर्कों की संख्या से एक दूसरे से भिन्न होनी चाहिए। आप फ़ंक्शन घोषणाओं को ओवरलोड नहीं कर सकते हैं जो केवल रिटर्न प्रकार से भिन्न होते हैं।

एक उदाहरण के बाद एक फ़ंक्शन की अवधारणा को ओवरलोडिंग में दिखाया गया है।

उदाहरण

pragma solidity ^0.5.0;

contract Test {
   function getSum(uint a, uint b) public pure returns(uint){      
      return a + b;
   }
   function getSum(uint a, uint b, uint c) public pure returns(uint){      
      return a + b + c;
   }
   function callSumWithTwoArguments() public pure returns(uint){
      return getSum(1,2);
   }
   function callSumWithThreeArguments() public pure returns(uint){
      return getSum(1,2,3);
   }
}

पहले CallSumWithTwoArguments बटन पर क्लिक करें और फिर परिणाम देखने के लिए callSumWithThreeArguments बटन पर क्लिक करें।

उत्पादन

0: uint256: 3
0: uint256: 6

सॉलिडिटी इनबिल्ट गणितीय कार्यों को भी प्रदान करती है। निम्नलिखित भारी तरीके हैं -

addmod(uint x, uint y, uint k) returns (uint)- गणना (x + y)% k जहां मनमाना परिशुद्धता के साथ जोड़ दिया जाता है और 2 ²⁵⁶ पर नहीं लपेटता है ।
mulmod(uint x, uint y, uint k) returns (uint)- गणना (x * y)% k जहां मनमाना परिशुद्धता के साथ जोड़ दिया जाता है और 2 ²⁵⁶ पर नहीं लपेटता है ।

निम्नलिखित उदाहरण से सॉलिडिटी में गणितीय कार्यों के उपयोग का पता चलता है।

उदाहरण

pragma solidity ^0.5.0;

contract Test {   
   function callAddMod() public pure returns(uint){
      return addmod(4, 5, 3);
   }
   function callMulMod() public pure returns(uint){
      return mulmod(4, 5, 3);
   }
}

परिणाम देखने के लिए पहले callAddMod बटन पर क्लिक करें और फिर कॉल करेंMMMod बटन।

उत्पादन

0: uint256: 0
0: uint256: 2

सॉलिडिटी इनबिल्ट क्रिप्टोग्राफिक कार्यों को भी प्रदान करती है। निम्नलिखित महत्वपूर्ण तरीके हैं -

keccak256(bytes memory) returns (bytes32) - इनपुट के Keekak-256 हैश की गणना करता है।
sha256(bytes memory) returns (bytes32) - इनपुट के SHA-256 हैश की गणना करता है।
ripemd160(bytes memory) returns (bytes20) - इनपुट के RIPEMD-160 हैश की गणना करें।
sha256(bytes memory) returns (bytes32) - इनपुट के SHA-256 हैश की गणना करता है।
ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) returns (address)- अण्डाकार वक्र हस्ताक्षर से सार्वजनिक कुंजी से जुड़े पते को पुनर्प्राप्त करें या त्रुटि पर शून्य लौटें। फ़ंक्शन पैरामीटर हस्ताक्षर के ईसीडीएसए मूल्यों के अनुरूप हैं: आर - हस्ताक्षर के पहले 32 बाइट्स; एस: हस्ताक्षर के दूसरे 32 बाइट्स; v: हस्ताक्षर के अंतिम 1 बाइट। यह विधि एक पता देती है।

निम्नलिखित उदाहरण से सॉलिडिटी में क्रिप्टोग्राफिक फ़ंक्शन के उपयोग से पता चलता है।

उदाहरण

pragma solidity ^0.5.0;

contract Test {   
   function callKeccak256() public pure returns(bytes32 result){
      return keccak256("ABC");
   }  
}

उत्पादन

0: bytes32: result 0xe1629b9dda060bb30c7908346f6af189c16773fa148d3366701fbaa35d54f3c8

निकासी पैटर्न यह सुनिश्चित करता है कि डायरेक्ट ट्रांसफर कॉल न की जाए जिससे सुरक्षा को खतरा हो। निम्नलिखित अनुबंध ईथर भेजने के लिए स्थानांतरण कॉल का असुरक्षित उपयोग दिखा रहा है।

pragma solidity ^0.5.0;

contract Test {
   address payable public richest;
   uint public mostSent;

   constructor() public payable {
      richest = msg.sender;
      mostSent = msg.value;
   }
   function becomeRichest() public payable returns (bool) {
      if (msg.value > mostSent) {
         // Insecure practice
         richest.transfer(msg.value);
         richest = msg.sender;
         mostSent = msg.value;
         return true;
      } else {
         return false;
      }
   }
}

उपरोक्त अनुबंध को अनुपयोगी स्थिति में प्रस्तुत किया जा सकता है, जिसके कारण सबसे अमीर व्यक्ति फेलबैक फंक्शन का अनुबंध कर सकता है। जब फॉलबैक फ़ंक्शन विफल होता है, तोRRestest () फ़ंक्शन भी विफल हो जाता है और अनुबंध हमेशा के लिए अटक जाएगा। इस समस्या को कम करने के लिए, हम विथड्राल पैटर्न का उपयोग कर सकते हैं।

निकासी पैटर्न में, हम प्रत्येक हस्तांतरण से पहले लंबित राशि को रीसेट कर देंगे। यह सुनिश्चित करेगा कि केवल कॉलर अनुबंध विफल हो।

pragma solidity ^0.5.0;

contract Test {
   address public richest;
   uint public mostSent;

   mapping (address => uint) pendingWithdrawals;

   constructor() public payable {
      richest = msg.sender;
      mostSent = msg.value;
   }
   function becomeRichest() public payable returns (bool) {
      if (msg.value > mostSent) {
         pendingWithdrawals[richest] += msg.value;
         richest = msg.sender;
         mostSent = msg.value;
         return true;
      } else {
         return false;
      }
   }
   function withdraw() public {
      uint amount = pendingWithdrawals[msg.sender];
      pendingWithdrawals[msg.sender] = 0;
      msg.sender.transfer(amount);
   }
}

एक अनुबंध पर प्रतिबंधित पहुंच एक आम बात है। डिफ़ॉल्ट रूप से, एक अनुबंध स्थिति केवल तभी तक पढ़ी जाती है जब तक कि इसे सार्वजनिक रूप से निर्दिष्ट नहीं किया जाता है।

हम अनुबंध की स्थिति को संशोधित कर सकते हैं या संशोधक का उपयोग करके अनुबंध के कार्यों को कॉल कर सकते हैं। हम नीचे बताए अनुसार कई संशोधक बनाएंगे और उपयोग करेंगे -

onlyBy - एक बार किसी फंक्शन पर इस्तेमाल होने के बाद केवल उल्लिखित कॉलर ही इस फंक्शन को कॉल कर सकता है।
onlyAfter - एक बार किसी फंक्शन पर इस्तेमाल होने के बाद उस फंक्शन को निश्चित समयावधि के बाद बुलाया जा सकता है।
costs - एक बार किसी फंक्शन पर इस्तेमाल होने के बाद कॉलर इस फ़ंक्शन को केवल तभी कॉल कर सकता है जब कुछ निश्चित मूल्य प्रदान किया जाता है।

उदाहरण

pragma solidity ^0.5.0;

contract Test {
   address public owner = msg.sender;
   uint public creationTime = now;

   modifier onlyBy(address _account) {
      require(
         msg.sender == _account,
         "Sender not authorized."
      );
      _;
   }
   function changeOwner(address _newOwner) public onlyBy(owner) {
      owner = _newOwner;
   }
   modifier onlyAfter(uint _time) {
      require(
         now >= _time,
         "Function called too early."
      );
      _;
   }
   function disown() public onlyBy(owner) onlyAfter(creationTime + 6 weeks) {
      delete owner;
   }
   modifier costs(uint _amount) {
      require(
         msg.value >= _amount,
         "Not enough Ether provided."
      );
      _;
      if (msg.value > _amount)
         msg.sender.transfer(msg.value - _amount);
   }
   function forceOwnerChange(address _newOwner) public payable costs(200 ether) {
      owner = _newOwner;
      if (uint(owner) & 0 == 1) return;        
   }
}

सॉलिडिटी में अनुबंध C ++ में क्लास के समान है। एक अनुबंध में निम्नलिखित गुण हैं।

Constructor - एक विशेष फ़ंक्शन जिसे कंस्ट्रक्टर कीवर्ड के साथ घोषित किया गया है जिसे अनुबंध के अनुसार एक बार निष्पादित किया जाएगा और जब एक अनुबंध बनाया जाता है तो इसे लागू किया जाता है।
State Variables - अनुबंध की स्थिति को संग्रहीत करने के लिए प्रति अनुबंध चर।
Functions - प्रति अनुबंध के कार्य जो एक अनुबंध की स्थिति को बदलने के लिए राज्य चर को संशोधित कर सकते हैं।

दृश्यता क्वांटिफ़ायर

एक अनुबंध के कार्यों / राज्य चर के लिए विभिन्न दृश्यता क्वांटिफायर निम्नलिखित हैं।

external- बाहरी कार्यों को अन्य अनुबंधों द्वारा बुलाया जाता है। उनका उपयोग आंतरिक कॉल के लिए नहीं किया जा सकता है। अनुबंध के भीतर बाहरी फ़ंक्शन को कॉल करने के लिए इस .function_name () कॉल की आवश्यकता है। राज्य चर को बाहरी के रूप में चिह्नित नहीं किया जा सकता है।
public- सार्वजनिक कार्यों / चर को बाहरी और आंतरिक दोनों तरह से उपयोग किया जा सकता है। सार्वजनिक राज्य चर के लिए, सॉलिडिटी स्वचालित रूप से एक गेटटर फ़ंक्शन बनाता है।
internal - आंतरिक कार्य / चर केवल आंतरिक रूप से या व्युत्पन्न अनुबंध द्वारा उपयोग किए जा सकते हैं।
private - निजी कार्य / चर केवल आंतरिक रूप से उपयोग किए जा सकते हैं और व्युत्पन्न अनुबंध द्वारा भी नहीं।

उदाहरण

pragma solidity ^0.5.0;

contract C {
   //private state variable
   uint private data;
   
   //public state variable
   uint public info;

   //constructor
   constructor() public {
      info = 10;
   }
   //private function
   function increment(uint a) private pure returns(uint) { return a + 1; }
   
   //public function
   function updateData(uint a) public { data = a; }
   function getData() public view returns(uint) { return data; }
   function compute(uint a, uint b) internal pure returns (uint) { return a + b; }
}
//External Contract
contract D {
   function readData() public returns(uint) {
      C c = new C();
      c.updateData(7);         
      return c.getData();
   }
}
//Derived Contract
contract E is C {
   uint private result;
   C private c;
   
   constructor() public {
      c = new C();
   }  
   function getComputedResult() public {      
      result = compute(3, 5); 
   }
   function getResult() public view returns(uint) { return result; }
   function getData() public view returns(uint) { return c.info(); }
}

सॉलिडिटी फर्स्ट एप्लीकेशन चैप्टर में दिए गए चरणों का उपयोग करके उपरोक्त प्रोग्राम को चलाएं । संविदा के विभिन्न तरीके चलाएं। E.getComputedResult () के लिए E.getResult () शो के बाद -

उत्पादन

0: uint256: 8

विरासत एक अनुबंध की कार्यक्षमता का विस्तार करने का एक तरीका है। सॉलिडिटी सिंगल और साथ ही मल्टीपल इनहेरिटेंस दोनों को सपोर्ट करती है। निम्नलिखित प्रमुख हाइलाइस्ट हैं।

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

उदाहरण

pragma solidity ^0.5.0;

contract C {
   //private state variable
   uint private data;
   
   //public state variable
   uint public info;

   //constructor
   constructor() public {
      info = 10;
   }
   //private function
   function increment(uint a) private pure returns(uint) { return a + 1; }
   
   //public function
   function updateData(uint a) public { data = a; }
   function getData() public view returns(uint) { return data; }
   function compute(uint a, uint b) internal pure returns (uint) { return a + b; }
}
//Derived Contract
contract E is C {
   uint private result;
   C private c;
   constructor() public {
      c = new C();
   }  
   function getComputedResult() public {      
      result = compute(3, 5); 
   }
   function getResult() public view returns(uint) { return result; }
   function getData() public view returns(uint) { return c.info(); }
}

उत्पादन

0: uint256: 8

कंस्ट्रक्टर एक विशेष फ़ंक्शन का उपयोग करके घोषित किया गया है constructorकीवर्ड। यह एक वैकल्पिक funtion है और एक अनुबंध के राज्य चर को इनिशियलाइज़ करने के लिए उपयोग किया जाता है। एक निर्माणकर्ता की प्रमुख विशेषताएं निम्नलिखित हैं।

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

pragma solidity ^0.5.0;

contract Test {
   constructor() public {}
}

मामले में, बेस कॉन्ट्रैक्ट में तर्कों के साथ कंस्ट्रक्टर होता है, प्रत्येक व्युत्पन्न कॉन्ट्रैक्ट को उन्हें पास करना होता है।
बेस कंस्ट्रक्टर को सीधे निम्नलिखित तरीके से उपयोग करके आरंभ किया जा सकता है -

pragma solidity ^0.5.0;

contract Base {
   uint data;
   constructor(uint _data) public {
      data = _data;   
   }
}
contract Derived is Base (5) {
   constructor() public {}
}

बेस कंस्ट्रक्टर को अप्रत्यक्ष रूप से निम्नलिखित तरीके से उपयोग करके आरंभ किया जा सकता है -

pragma solidity ^0.5.0;

contract Base {
   uint data;
   constructor(uint _data) public {
      data = _data;   
   }
}
contract Derived is Base {
   constructor(uint _info) Base(_info * _info) public {}
}

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

सार अनुबंध वह है जिसमें बिना किसी कार्यान्वयन के कम से कम एक फ़ंक्शन होता है। इस तरह के अनुबंध का उपयोग आधार अनुबंध के रूप में किया जाता है। आम तौर पर एक अमूर्त अनुबंध में दोनों के साथ-साथ अमूर्त कार्य शामिल होते हैं। व्युत्पन्न अनुबंध अमूर्त फ़ंक्शन को लागू करेगा और आवश्यक होने पर मौजूदा कार्यों का उपयोग करेगा।

मामले में, एक व्युत्पन्न अनुबंध सार फ़ंक्शन को लागू नहीं कर रहा है तो इस व्युत्पन्न अनुबंध को सार के रूप में चिह्नित किया जाएगा।

उदाहरण

सोलिडिटी में सार अनुबंध कैसे काम करता है, यह समझने के लिए निम्न कोड का प्रयास करें।

pragma solidity ^0.5.0;

contract Calculator {
   function getResult() public view returns(uint);
}
contract Test is Calculator {
   function getResult() public view returns(uint) {
      uint a = 1;
      uint b = 2;
      uint result = a + b;
      return result;
   }
}

उत्पादन

0: uint256: 3

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

कार्यान्वयन के साथ इंटरफ़ेस का कोई कार्य नहीं हो सकता है।
एक इंटरफ़ेस के कार्य केवल बाहरी प्रकार के हो सकते हैं।
इंटरफ़ेस में कंस्ट्रक्टर नहीं हो सकता है।
इंटरफ़ेस में राज्य चर नहीं हो सकते।
इंटरफ़ेस में एनुम, स्ट्रक्चर्स हो सकते हैं जिन्हें इंटरफ़ेस नाम डॉट नोटेशन का उपयोग करके एक्सेस किया जा सकता है।

उदाहरण

सोलिडिटी में इंटरफ़ेस कैसे काम करता है, यह समझने के लिए निम्न कोड का प्रयास करें।

pragma solidity ^0.5.0;

interface Calculator {
   function getResult() external view returns(uint);
}
contract Test is Calculator {
   constructor() public {}
   function getResult() external view returns(uint){
      uint a = 1; 
      uint b = 2;
      uint result = a + b;
      return result;
   }
}

Note - तैनाती बटन पर क्लिक करने से पहले ड्रॉपडाउन से टेस्ट का चयन करें।

उत्पादन

0: uint256: 3

लाइब्रेरी कॉन्ट्रैक्ट के समान हैं, लेकिन मुख्य रूप से पुन: उपयोग के लिए अभिप्रेत हैं। लाइब्रेरी में ऐसे कार्य होते हैं जिन्हें अन्य अनुबंध कह सकते हैं। लाइब्रेरी के उपयोग पर सॉलिडिटी पर कुछ प्रतिबंध हैं। सॉलिडिटी लाइब्रेरी की प्रमुख विशेषताएं निम्नलिखित हैं।

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

उदाहरण

एक कोड सोलिडिटी में कैसे काम करता है, यह समझने के लिए निम्न कोड का प्रयास करें।

pragma solidity ^0.5.0;

library Search {
   function indexOf(uint[] storage self, uint value) public view returns (uint) {
      for (uint i = 0; i < self.length; i++) if (self[i] == value) return i;
      return uint(-1);
   }
}
contract Test {
   uint[] data;
   constructor() public {
      data.push(1);
      data.push(2);
      data.push(3);
      data.push(4);
      data.push(5);
   }
   function isValuePresent() external view returns(uint){
      uint value = 4;
      
      //search if value is present in the array using Library function
      uint index = Search.indexOf(data, value);
      return index;
   }
}

Note - तैनाती बटन पर क्लिक करने से पहले ड्रॉपडाउन से टेस्ट का चयन करें।

उत्पादन

0: uint256: 3

के लिए उपयोग कर रहा है

निर्देश using A for B; पुस्तकालय ए के पुस्तकालय कार्यों को दिए गए प्रकार बी में संलग्न करने के लिए इस्तेमाल किया जा सकता है। इन कार्यों में कॉलर प्रकार का उपयोग उनके पहले पैरामीटर (स्वयं का उपयोग करके पहचाना गया) के रूप में किया जाएगा।

उदाहरण

pragma solidity ^0.5.0;

library Search {
   function indexOf(uint[] storage self, uint value) public view returns (uint) {
      for (uint i = 0; i < self.length; i++)if (self[i] == value) return i;
      return uint(-1);
   }
}
contract Test {
   using Search for uint[];
   uint[] data;
   constructor() public {
      data.push(1);
      data.push(2);
      data.push(3);
      data.push(4);
      data.push(5);
   }
   function isValuePresent() external view returns(uint){
      uint value = 4;      
      
      //Now data is representing the Library
      uint index = data.indexOf(value);
      return index;
   }
}

Note - तैनाती बटन पर क्लिक करने से पहले ड्रॉपडाउन से टेस्ट का चयन करें।

उत्पादन

0: uint256: 3

सॉलिडिटी एसेंबली सोर्स कोड के भीतर इनलाइन असेंबली लिखने के लिए असेंबली लैंग्वेज का उपयोग करने का विकल्प प्रदान करती है। हम एक स्टैंडअलोन असेंबली कोड भी लिख सकते हैं जिसे तब बायटेकोड में बदल दिया जाता है। स्टैंडअलोन असेंबली एक सॉलिडिटी कंपाइलर के लिए एक मध्यवर्ती भाषा है और यह सॉलिडिटी कोड को स्टैंडअलोन असेंबली में और फिर बाइट कोड में परिवर्तित करता है। हम इनलाइन असेंबली में उसी भाषा का उपयोग एक स्टैंडअलोन असेंबली में कोड लिखने के लिए कर सकते हैं।

इनलाइन असेंबली

इनलाइन असेंबली कोड को सॉलिडिटी कोड बेस के भीतर इंटरलेव किया जा सकता है ताकि ईवीएम पर अधिक बारीक-दाने का नियंत्रण हो और विशेष रूप से लाइब्रेरी के कार्यों को लिखते समय इसका उपयोग किया जाता है।

एक विधानसभा कोड के तहत लिखा है assembly { ... } खंड मैथा।

उदाहरण

pragma solidity ^0.5.0;

library Sum {   
   function sumUsingInlineAssembly(uint[] memory _data) public pure returns (uint o_sum) {
      for (uint i = 0; i < _data.length; ++i) {
         assembly {
            o_sum := add(o_sum, mload(add(add(_data, 0x20), mul(i, 0x20))))
         }
      }
   }
}
contract Test {
   uint[] data;
   
   constructor() public {
      data.push(1);
      data.push(2);
      data.push(3);
      data.push(4);
      data.push(5);
   }
   function sum() external view returns(uint){      
      return Sum.sumUsingInlineAssembly(data);
   }
}

Note - तैनाती बटन पर क्लिक करने से पहले ड्रॉपडाउन से टेस्ट का चयन करें।

उत्पादन

0: uint256: 15

घटना एक अनुबंध का एक अंतर्निहित सदस्य है। एक घटना उत्सर्जित होती है, यह लेनदेन लॉग में पारित तर्कों को संग्रहीत करती है। ये लॉग ब्लॉकचैन पर संग्रहीत हैं और अनुबंध के पते का उपयोग करते हुए सुलभ हैं जब तक कि ब्लॉकचैन पर अनुबंध मौजूद नहीं है। उत्पन्न एक घटना अनुबंधों के भीतर से सुलभ नहीं है, वह भी नहीं जिसने उन्हें बनाया और उत्सर्जित किया है।

ईवेंट कीवर्ड का उपयोग करके एक ईवेंट घोषित किया जा सकता है।

//Declare an Event
event Deposit(address indexed _from, bytes32 indexed _id, uint _value);

//Emit an event
emit Deposit(msg.sender, _id, msg.value);

उदाहरण

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

पहले एक अनुबंध बनाएं और एक घटना का उत्सर्जन करें।

pragma solidity ^0.5.0;

contract Test {
   event Deposit(address indexed _from, bytes32 indexed _id, uint _value);
   function deposit(bytes32 _id) public payable {      
      emit Deposit(msg.sender, _id, msg.value);
   }
}

फिर जावास्क्रिप्ट कोड में अनुबंध की घटना का उपयोग करें।

var abi = /* abi as generated using compiler */;
var ClientReceipt = web3.eth.contract(abi);
var clientReceiptContract = ClientReceipt.at("0x1234...ab67" /* address */);

var event = clientReceiptContract.Deposit(function(error, result) {
   if (!error)console.log(result);
});

इसे निम्नलिखित के समान विवरण प्रिंट करना चाहिए -

उत्पादन

{
   "returnValues": {
      "_from": "0x1111...FFFFCCCC",
      "_id": "0x50...sd5adb20",
      "_value": "0x420042"
   },
   "raw": {
      "data": "0x7f...91385",
      "topics": ["0xfd4...b4ead7", "0x7f...1a91385"]
   }
}

सॉलिडिटी त्रुटि से निपटने के लिए विभिन्न कार्य प्रदान करती है। आमतौर पर जब कोई त्रुटि होती है, तो स्थिति वापस अपनी मूल स्थिति में आ जाती है। अन्य चेक अनधिकृत कोड एक्सेस को रोकने के लिए हैं। त्रुटि से निपटने में उपयोग किए जाने वाले कुछ महत्वपूर्ण तरीके निम्नलिखित हैं -

assert(bool condition)- यदि स्थिति पूरी नहीं होती है, तो यह विधि कॉल अमान्य opcode का कारण बनता है और राज्य में किए गए किसी भी परिवर्तन को वापस लाया गया है। इस विधि का उपयोग आंतरिक त्रुटियों के लिए किया जाना है।
require(bool condition)- यदि स्थिति की पूर्ति नहीं होती है, तो यह विधि मूल स्थिति को प्रभावित करती है। - इस विधि का उपयोग इनपुट या बाहरी घटकों में त्रुटियों के लिए किया जाना है।
require(bool condition, string memory message)- यदि स्थिति की पूर्ति नहीं होती है, तो यह विधि मूल स्थिति को प्रभावित करती है। - इस विधि का उपयोग इनपुट या बाहरी घटकों में त्रुटियों के लिए किया जाना है। यह एक कस्टम संदेश प्रदान करने का विकल्प प्रदान करता है।
revert() - यह विधि निष्पादन को रोकती है और राज्य में किए गए किसी भी परिवर्तन को वापस लाती है।
revert(string memory reason)- यह विधि निष्पादन को रोकती है और राज्य में किए गए किसी भी परिवर्तन को वापस लाती है। यह एक कस्टम संदेश प्रदान करने का विकल्प प्रदान करता है।

उदाहरण

निम्न कोड को समझने की कोशिश करें कि सॉलिडिटी में एरर हैंडलिंग कैसे काम करता है।

pragma solidity ^0.5.0;

contract Vendor {
   address public seller;
   modifier onlySeller() {
      require(
         msg.sender == seller,
         "Only seller can call this."
      );
      _;
   }
   function sell(uint amount) public payable onlySeller { 
      if (amount > msg.value / 2 ether)
         revert("Not enough Ether provided.");
      // Perform the sell operation.
   }
}

जब वापस बुलाया जाता है, तो यह उसके बाद हेक्साडेसिमल डेटा लौटाएगा।

उत्पादन

0x08c379a0                     // Function selector for Error(string)
0x0000000000000000000000000000000000000000000000000000000000000020 // Data offset
0x000000000000000000000000000000000000000000000000000000000000001a // String length
0x4e6f7420656e6f7567682045746865722070726f76696465642e000000000000 // String data