सॉलिडिटी - रूपांतरण

सॉलिडिटी निहित और साथ ही स्पष्ट रूपांतरण की अनुमति देती है। सॉलिडिटी कंपाइलर दो डेटा प्रकारों के बीच निहित रूपांतरण की अनुमति देता है, बशर्ते कोई भी रूपांतरण संभव नहीं है और जानकारी का कोई नुकसान नहीं है। उदाहरण के लिए 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