Ruby टाइप रूपांतरण में महारत: to_s, to_a, to_str का उपयोग करके निर्बाध डेटा मैनिपुलेशन

आप एक इंटीजर के साथ काम कर रहे हैं लेकिन आप इसके बजाय स्ट्रिंग मेथड्स (जैसे gsub) का उपयोग करना चाहेंगे।

आप क्या कर सकते हैं?

इसे स्ट्रिंग में बदलें ( to_s के साथ) फिर वापस इंटीजर में बदलें ( to_i के साथ)।

उदाहरण के लिए:

आप Integer 1 को String "1" में बदल सकते हैं।

फिर आप नई क्लास के मेथड्स का उपयोग कर सकते हैं, जो आपको कुछ ऐसा करने में मदद करता है जो पहले संभव नहीं था।

याद रखें कि Ruby में...

हर ऑब्जेक्ट एक क्लास से जुड़ा होता है, और हर क्लास के पास मेथड्स का एक विशिष्ट सेट होता है।

इस लेख में, आप सीखेंगे:

• Ruby में कौन से रूपांतरण मेथड्स उपलब्ध हैं
• उनके बीच क्या अंतर हैं!
• विभिन्न स्थितियों में सही मेथड कैसे चुनें

चलिए शुरू करते हैं!

शॉर्ट रूपांतरण मेथड्स (to_s, to_i)

आप शायद रूपांतरण मेथड्स के इस पहले समूह से परिचित हैं।

मेथड्स जैसे:

• to_i
• to_s
• to_a

ये मेथड्स वर्तमान ऑब्जेक्ट का प्रतिनिधित्व करने वाली एक विशिष्ट क्लास का एक नया ऑब्जेक्ट लौटाते हैं।

उदाहरण के लिए:

 (1..10).to_a # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

यह कहता है:

"मैं Range 1..10 को एक Array में बदलना चाहता हूं जो उस रेंज का प्रतिनिधित्व करता है।"

ऐसे तरीके हैं जिनमें Ruby इन रूपांतरण मेथड्स को आपके लिए निहित रूप से कॉल करता है।

स्ट्रिंग इंटरपोलेशन की तरह:

 "#{1}" 

यह आपके लिए 1.to_s कॉल करता है, भले ही आप इसे न देखें।

आप इस कोड से स्वयं जांच सकते हैं:

 module Log def to_s puts "to_s called" super end end class Integer prepend Log end puts "#{1}" # "to_s called" 

नोट: यदि आप Ruby 2.3 या पुराने पर हैं तो आपको Integer के बजाय Fixnum का उपयोग करना होगा। या बेहतर yet, अपना Ruby संस्करण अपडेट करें 🙂

ये मेथड्स काफी permissive हैं और अपवाद उठाने के लिए नहीं बने हैं।

उदाहरण के लिए:

 "aaaaaa".to_i # 0 

यह 0 आपको आश्चर्यचकित कर सकता है।

लेकिन जब आप बिना इंटीजर्स वाली स्ट्रिंग पर to_i कॉल करते हैं तो आपको यही मिलता है।

जैसा कि आप इस लेख में बाद में देखेंगे इस मेथड का एक अधिक सख्त संस्करण है।

लॉन्ग रूपांतरण मेथड्स (to_str, to_int)

अब:

यदि हमारे पास वे शॉर्ट रूपांतरण मेथड्स हैं, तो हमें to_str, या to_int जैसे मेथड्स की आवश्यकता क्यों है?

अंतर क्या है?

अंतर उनके इरादे में है।

हर Ruby क्लास (BasicObject के अपवाद के साथ) to_s मेथड को स्वयं को किसी प्रकार के स्ट्रिंग प्रतिनिधित्व के रूप में लौटाने के लिए लागू करती है।

लेकिन सिर्फ इसलिए कि एक क्लास स्ट्रिंग लौटाती है इसका मतलब यह नहीं है कि यह एक स्ट्रिंग की तरह व्यवहार करती है!

आइए एक उदाहरण देखते हैं:

 "" + 1 # TypeError: no implicit conversion of Fixnum into String 

इसके बारे में सोचें:

खाली स्ट्रिंग प्लस इंटीजर को क्या लौटाना चाहिए?

मुझे नहीं पता।

आप "1" (नंबर वन वाली स्ट्रिंग) कह सकते हैं।

लेकिन क्यों?

इस मामले में अधिकांश लोग इसकी उम्मीद नहीं करते।

उन्हें जोड़ना समझ में नहीं आता... इसीलिए हमें यह TypeError मिलता है।

और यहां तक कि अगर इसकी अनुमति दी गई होती।

इसके बारे में क्या:

 "" + {} 

यह एक खाली स्ट्रिंग प्लस एक खाली हैश है।

यह भी समझ में नहीं आता!

इसलिए Ruby यह जांचने के बजाय कि दूसरा ऑब्जेक्ट एक स्ट्रिंग है, जो पॉलीमॉर्फिज्म के लिए अच्छा नहीं होगा, यह जांचता है कि क्या यह एक स्ट्रिंग की तरह व्यवहार करता है।

यहीं to_str मेथड आता है।

Ruby 2.5 में to_str को लागू करने वाली एकमात्र क्लासेज:

• String
• NameError::message
• Warning::buffer

अपने स्वयं के रूपांतरण मेथड्स कैसे लागू करें

आप किसी भी क्लास पर to_str लागू कर सकते हैं।

फिर आप इसे स्ट्रिंग की तरह उपयोग कर पाएंगे।

यहां एक उदाहरण है:

 class Cat def to_str "meow" end end "" + Cat.new # "meow" 

लेकिन जब तक आपकी क्लास एक स्ट्रिंग के बराबर नहीं है तब तक आपको ऐसा नहीं करना चाहिए।

to_s का उपयोग करें।

बता दें, यह केवल + मेथड के लिए नहीं है।

यह उन अन्य स्थानों पर भी उपयोग किया जाता है जहां केवल स्ट्रिंग-जैसा ऑब्जेक्ट समझ में आता है।

जैसे:

 [1,2,3].join(",") 

अन्य लॉन्ग रूपांतरण मेथड्स जैसे to_int और to_hash उसी तर्क का पालन करते हैं।

यही कारण है कि हमारे पास ये अलग-अलग मेथड्स हैं।

रूपांतरण रैपर्स का उपयोग कैसे करें

यदि आपके पास अभी तक पर्याप्त रूपांतरण मेथड्स नहीं थे... चिंता न करें क्योंकि मेरे पास आपके लिए कुछ और हैं!

मैं इन्हें "रूपांतरण रैपर्स" कहना पसंद करता हूं।

वे हैं:

• Array()
• Integer()
• Hash[]

वहां कुछ असामान्य दिखने वाले मेथड्स हैं!

पैरेंथेसिस और स्क्वायर ब्रैकेट्स पर ध्यान दें...

...यह केवल एक चीज है जो इन मेथड्स को उनके क्लास नामों से अलग करती है।

इनका उद्देश्य क्या है?

Array() किसी भी चीज को सरणी में बदल देगा।

यहां आपके लिए कुछ उदाहरण हैं:

 Array(nil) # [] Array([]) # [] Array(1) # [1] Array("") # [""] 

यह किस तरह का तर्क है???

खैर, यह मेथड नियमों के एक बहुत विशिष्ट सेट का पालन करता है:

• यदि ऑब्जेक्ट to_ary, या to_a का जवाब देता है तो यह उसे कॉल करेगा और मान लौटाएगा
• अन्यथा, यह ऑब्जेक्ट को एक खाली सरणी के अंदर रखेगा और उसे लौटाएगा

यह ऊपर दिखाए गए व्यवहार की व्याख्या करता है।

यह उपयोगी है यदि आप एक मेथड लिख रहे हैं जो सरणी की अपेक्षा करता है लेकिन उसे कुछ और मिल सकता है और आपके मेथड को क्रैश कर सकता है। आप इसे पहले Array() में पास करके सुनिश्चित कर सकते हैं कि यह सरणी है ताकि इससे बचा जा सके।

अब Integer()।

इसके कुछ विशेष नियम हैं:

• यदि ऑब्जेक्ट एक स्ट्रिंग है और स्ट्रिंग की सामग्री Ruby में एक वैध न्यूमेरिक प्रतिनिधित्व के अनुरूप है तो यह मेथड एक Integer लौटाएगा। अमान्य फॉर्मेट पर ArgumentError उठाता है।
• यदि ऑब्जेक्ट स्ट्रिंग नहीं है तो यह to_int कॉल करने की कोशिश करेगा, फिर to_i।
• यदि ऑब्जेक्ट को रूपांतरण मेथड का उपयोग करके वैध Integer में बदला नहीं जा सकता तो यह TypeError उठाएगा।

उदाहरण:

 Integer(1) # 1 Integer("25") # 25 Integer("abc123") # ArgumentError (invalid value for Integer(): "abc123") Integer([]) # TypeError (can't convert Array into Integer) 

यह Integer() मेथड उपयोगी है यदि आप 100% सुनिश्चित होना चाहते हैं कि आप एक वैध Integer के साथ काम कर रहे हैं।

अब Hash[]।

आप एक नया हैश प्राप्त करने के लिए सम तत्वों की एक सरणी पास कर सकते हैं:

 Hash[[["a", 1], ["b", 2], ["c", 3]]] # {"a"=>1, "b"=>2, "c"=>3} 

उपयोगी यदि आप दो सरणियों के तत्वों को मर्ज करके अपना हैश बना रहे हैं, या map जैसे मेथड का उपयोग कर रहे हैं।

सारांश

आपने Ruby में विभिन्न रूपांतरण मेथड्स के बारे में सीखा, वे क्यों मौजूद हैं और उनका उपयोग कैसे करें!

मुझे उम्मीद है कि आपको यह मददगार लगा 🙂

यदि आपको यह लेख पसंद आया तो आपको मेरी किताब, Ruby Deep Dive, भी पसंद आएगी, इसे देखें।