रूबी में स्पष्ट कास्टिंग बनाम अंतर्निहित जबरदस्ती:#to_s बनाम #to_str समझाया गया
<पी> टाइप ज़बरदस्ती किसी वस्तु के प्रकार को उसके मूल्य के साथ दूसरे प्रकार में बदलना है। उदाहरण के लिए, एक पूर्णांक को #to_s के साथ एक स्ट्रिंग में बदलना या #to_i के साथ एक पूर्णांक में फ़्लोट करें . संभवतः कम ज्ञात #to_str और #to_int कुछ वस्तुओं द्वारा लागू की जाने वाली विधियाँ पहली नज़र में समान होती हैं, लेकिन कुछ अंतर होते हैं। <पी> ऐपसिग्नल अकादमी के इस संस्करण में, हम रूबी में स्पष्ट रूप से कास्टिंग और अंतर्निहित रूप से ज़बरदस्ती के प्रकारों पर चर्चा करेंगे, जबकि टाइपकास्टिंग अभिनेताओं पर संक्षेप में बात करेंगे। हम दोनों विधियों के बीच के अंतरों को कवर करेंगे, और चर्चा करेंगे कि उनका उपयोग कैसे किया जाता है। <पी> आइए पहले देखें कि कैसे हम आम तौर पर स्पष्ट कास्टिंग सहायकों के साथ रूबी में विभिन्न प्रकारों के लिए मूल्यों को मजबूर करते हैं। स्पष्ट कास्टिंग सहायक
<पी> सबसे आम कास्टिंग सहायक #to_s हैं , #to_i , #to_a और #to_h . ये स्पष्ट कास्टिंग विधियाँ हैं। वे किसी मान को एक प्रकार से दूसरे प्रकार में आसानी से बदलने में हमारी सहायता करते हैं। <पी> स्पष्ट मददगार स्पष्ट वादे के साथ आते हैं। जब भी #to_s किसी ऑब्जेक्ट पर कॉल किया जाता है, यह हमेशा होगा एक स्ट्रिंग लौटाएँ, भले ही ऑब्जेक्ट वास्तव में अच्छी तरह से स्ट्रिंग में परिवर्तित न हो। यह माइकल कीटन को बैटमैन के रूप में कास्ट करने जैसा है। आपको एक बैटमैन मिल जाएगा, भले ही कोई कॉमेडी अभिनेता इस भूमिका के लिए विशेष रूप से उपयुक्त न हो। <पी> रूबी मानक लाइब्रेरी में लगभग किसी भी बुनियादी वस्तु पर रूबी इन सहायक तरीकों की पेशकश करती है। <पी> ये विधियाँ, विशेषकर #to_s , रूबी में अधिकांश बुनियादी प्रकारों पर कार्यान्वित किए जाते हैं। हालाँकि कास्टिंग लगभग हमेशा एक मान लौटाती है, परिणाम वह नहीं हो सकता है जिसकी हम अपेक्षा करते हैं। <पी> #to_s पर कॉल करना , #to_i , #to_a और #to_h हेल्पर्स किसी भी मान को चयनित प्रकार पर बाध्य करते हैं। वे उस प्रकार का प्रतिनिधित्व लौटाते हैं जिसके लिए उसे मजबूर किया जाता है, भले ही मूल्य का कुछ भी हो। अंतर्निहित जबरदस्ती के तरीके
<पी> उन मानों पर टाइप कास्टिंग विधियों को कॉल करना जो उस प्रकार की तरह काम नहीं करते जिस प्रकार हम कास्टिंग कर रहे हैं, त्रुटियों या डेटा की हानि का कारण बन सकता है। रूबी अंतर्निहित जबरदस्ती के तरीके भी प्रदान करती है जो केवल तभी मूल्य लौटाती है जब वस्तुएं प्रकार की तरह कार्य करती हैं। इस तरह हम यह सुनिश्चित कर सकते हैं कि मान उस प्रकार का कार्य करता है जैसा हम चाहते हैं। ये अंतर्निहित ज़बरदस्ती विधियाँ #to_str हैं , #to_int , #to_ary और #to_hash . <पी> अंतर्निहित ज़बरदस्ती लियोनार्ड निमोय को स्पॉक के अलावा किसी अन्य भूमिका में लेने जैसा है। यदि पात्र स्पॉक के काफी करीब है तो वे काम करेंगे, लेकिन यदि ऐसा नहीं है तो असफल हो जायेंगे। #to_str सहायक प्रयास करता है एक स्ट्रिंग में कनवर्ट करने के लिए, लेकिन एक NoMethodError बढ़ा देगा यदि वस्तु विधि को लागू नहीं करती है और उसे अंतर्निहित रूप से बाध्य नहीं किया जा सकता है। <पी> हम देख सकते हैं कि रूबी अब अपने काम में थोड़ी अधिक सख्त है और अनुरोधित प्रकारों के लिए जबरदस्ती नहीं करती है। यदि जबरदस्ती संभव नहीं है, तो #to_* ऑब्जेक्ट पर विधि लागू नहीं की गई है और इसे कॉल करने से NoMethodError उत्पन्न होता है . <पी> अंतर्निहित जबरदस्ती का उपयोग करते समय, उदा. #to_str , हम फ़ंक्शन को स्ट्रिंग ऑब्जेक्ट वापस करने के लिए कहते हैं, केवल तभी जब मूल प्रकार भी स्ट्रिंग की तरह कार्य करता है। इस कारण से, #to_str केवल रूबी स्टैंडर्ड लाइब्रेरी में स्ट्रिंग पर लागू किया गया है। रूबी कैसे अंतर्निहित जबरदस्ती का उपयोग करती है
<पी> जबरदस्ती के दौरान हम जो मांग रहे हैं उसमें अधिक सटीक होने के अलावा, अंतर्निहित जबरदस्ती और किस लिए उपयोगी है? पता चला कि रूबी कई परिदृश्यों में स्वयं अंतर्निहित दबाव का उपयोग करती है। उदाहरण के लिए, वस्तुओं को + के साथ जोड़ते समय . <पी> यहां, हम रूबी को TypeError बढ़ाते हुए देखते हैं चूँकि यह Name से कोई अंतर्निहित रूपांतरण नहीं कर सकता String टाइप करें . <पी> यदि हम #to_str लागू करते हैं कक्षा में, रूबी जानती है कि Name को कैसे ज़बरदस्ती करना है टाइप करें. <पी> यही बात Arrays और #to_ary के लिए भी काम करती है . <पी> लेकिन #to_ary अधिक परिदृश्यों में उपयोग किया जाता है. हम इसका उपयोग किसी ऐरे को अलग-अलग वेरिएबल्स में विभाजित करने के लिए कर सकते हैं। <पी> यह ऑब्जेक्ट का ब्लॉक पैरामीटर में रूपांतरण भी करता है। <पी> ऐसे और भी परिदृश्य हैं जहां अंतर्निहित जबरदस्ती के तरीकों का उपयोग किया जाता है, जैसे #to_hash ** के साथ . यह मान को #to_hash वाले हैश में ले जाता है इसे parse_options पर भेजने से पहले विधि. प्रवर्तन प्रकार
<पी> जब प्रकार अज्ञात प्रकार का होता है तो रूबी अधिक लचीली जबरदस्ती के तरीके भी प्रदान करती है और हम यह सुनिश्चित करना चाहते हैं कि हमें सही प्रकार मिले। प्रत्येक मूल प्रकार (String(...)) के लिए एक है , Integer(...) , Float(...) , Array(...) , Hash(...) , आदि). <पी> String(...) विधि पहले #to_str पर कॉल करने का प्रयास करती है मान पर, और जब वह विफल हो जाता है, तो यह अपने #to_s पर कॉल करता है विधि. सभी ऑब्जेक्ट #to_str को परिभाषित नहीं करते हैं विधि, इसलिए दोनों अंतर्निहित जबरदस्ती (#to_str) के साथ जाँच की जा रही है ) और स्पष्ट (#to_s ) कास्टिंग विधियों से संभावना बढ़ जाती है कि स्ट्रिंग रूपांतरण काम करेगा और आपको वह मूल्य मिलेगा जो आप चाहते हैं। पहले अंतर्निहित जबरदस्ती के लिए कॉल करने से हमें ऐसा परिणाम मिलने की अधिक संभावना है जिसका मूल्य समान है लेकिन वह जबरदस्ती प्रकार का है, और "#<Object:0x00007f8e6d053a90>" जैसा कुछ नहीं है। . <पी> आपको केवल उन वस्तुओं के लिए अंतर्निहित कास्टिंग विधियों को लागू करना चाहिए जो जबरदस्ती किए जाने वाले प्रकार की तरह कार्य करती हैं, उदाहरण के लिए। #to_str आपकी अपनी स्ट्रिंग कक्षा के लिए। <पी> पहले अंतर्निहित ज़बरदस्ती की कोशिश के अलावा, String(...) सहायक लौटाए गए प्रकार की भी जाँच करता है। #to_str यह केवल एक विधि है जो किसी भी प्रकार का मान लौटा सकती है, यहां तक कि गैर-स्ट्रिंग्स भी। यह सुनिश्चित करने के लिए कि हमें अनुरोधित प्रकार String(...) का मान मिले एक TypeError बढ़ाता है यदि प्रकार मेल नहीं खाते। <पी> यहां, हम देख सकते हैं कि रूबी #to_str के परिणाम को नजरअंदाज कर देती है क्योंकि यह nil लौटाया , जो स्ट्रिंग-प्रकार का नहीं है। इसके बजाय, यह वापस #to_s पर आ जाता है नतीजा. <पी> यदि #to_s nil भी लौटाता है और इसलिए यह सही प्रकार का नहीं है, String(...) एक TypeError जुटाएगा . <पी> हालाँकि वे प्रकार की जबरदस्ती लागू करने में अधिक विश्वसनीय हो सकते हैं, ध्यान दें कि कास्टिंग सहायक विधियाँ (String(...) , Integer(...) , आदि) आमतौर पर थोड़े धीमे होते हैं क्योंकि उन्हें दिए गए मान पर अधिक जांच करने की आवश्यकता होती है। निष्कर्ष में
<पी> जब आप यह सुनिश्चित करना चाहते हैं कि आप किसी ऑब्जेक्ट के लिए सही प्रकार के डेटा के साथ काम कर रहे हैं, तो टाइप ज़बरदस्ती एक उपयोगी प्रक्रिया है। इस पोस्ट में, हमने #to_s जैसे स्पष्ट कास्टिंग सहायकों के बारे में अपने ज्ञान को ताज़ा किया , #to_i , #to_a और #to_h . हमने ऐसे उदाहरणों को भी देखा जब #to_str जैसे अंतर्निहित सहायक थे , #to_int , #to_ary और #to_hash उपयोगी हैं और रूबी द्वारा ही उनका उपयोग कैसे किया जाता है। <पी> हम आशा करते हैं कि आपको इस प्रकार की ज़बरदस्ती का अवलोकन उपयोगी लगा होगा और आपने अभिनेता टाइपकास्टिंग सादृश्य को कैसे पाया। हमेशा की तरह, अगर कोई ऐसा विषय है जिसे आप चाहते हैं कि हम कवर करें तो हमें बताएं। यदि आपका कोई प्रश्न या टिप्पणी है, तो हमें @AppSignal पर एक लाइन लिखने में संकोच न करें। 
टॉम डी ब्रुइज़न
