रूबी ऑपरेटर्स में महारत: डेवलपर्स के लिए एक पूर्ण गाइड

रूबी में बहुत सारे दिलचस्प ऑपरेटर्स हैं।

जैसे:

• स्पेसशिप ऑपरेटर (<=>)
• मॉड्यूलो असाइनमेंट ऑपरेटर (%=)
• ट्रिपल इक्वल्स (===) ऑपरेटर
• ग्रेटर दैन (>) और लेस दैन (<)
• नॉट इक्वल्स (!=)

आपको यह एहसास नहीं हो सकता है कि इनमें से कई ऑपरेटर्स वास्तव में रूबी मेथड्स हैं।

इसका मतलब है…

आप उन्हें ओवरराइट कर सकते हैं कि वे क्या करते हैं और उनका उपयोग अपने स्वयं के वर्गों में कस्टम व्यवहार को परिभाषित करने के लिए कर सकते हैं।

उदाहरण के लिए, == को परिभाषित करके आप रूबी को बता सकते हैं कि एक ही वर्ग की दो वस्तुओं की तुलना कैसे करें।

अब:

आइए कुछ उदाहरणों पर चलते हैं ताकि आप इस बात का ठोस अवलोकन प्राप्त कर सकें कि ये रूबी ऑपरेटर्स कैसे काम करते हैं और अपने कोड में उनका उपयोग कैसे करें।

यह एक महत्वपूर्ण विषय है यदि आप वास्तव में रूबी को समझना चाहते हैं।

सामग्री

• 1 रूबी लॉजिकल ऑपरेटर्स
• 2 रूबी अंकगणितीय ऑपरेटर्स
• 3 असाइनमेंट ऑपरेटर्स (==, +=, ||=)
• 4 यूनरी ऑपरेटर्स क्या हैं?
• 5 रूबी स्प्लैट ऑपरेटर (उदाहरण के साथ)
• 6 मिलान ऑपरेटर (=~)
• 7 रूबी टर्नरी ऑपरेटर (प्रश्न चिह्न ऑपरेटर)
• 8 शॉवेल / पुश ऑपरेटर (<<)
• 9 ट्रिपल इक्वल्स ऑपरेटर (समानता से अधिक)
• 10 सेफ नेविगेटर ऑपरेटर (&.)
• 11 ऑपरेटर प्रिसिडेंस टेबल
• 12 सारांश
  • 12.1 संबंधित

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

सबसे पहले, हम लॉजिकल ऑपरेटर्स को देखने जा रहे हैं।

आप इन ऑपरेटर्स का उपयोग दो वस्तुओं की तुलना करने और परिणाम के आधार पर निर्णय लेने में मदद के लिए कर सकते हैं।

यहां एक तालिका है:

ये सभी ऑपरेटर्स मेथड्स हैं, और वे एक बूलियन मान लौटाते हैं, स्पेसशिप ऑपरेटर के अपवाद के साथ। स्पेसशिप ऑपरेटर या तो 1 (अधिक), 0 (बराबर) या -1 (कम) लौटाता है।

यहां > ऑपरेटर का उपयोग करने का एक उदाहरण है:

 if orange.stock > 20 # ... end 

यदि आप अपने स्वयं के वर्गों के साथ डबल इक्वल्स (==) ऑपरेटर का उपयोग करना चाहते हैं तो आप पा सकते हैं कि यह पहले काम नहीं करता…

उदाहरण:

 class Fruit def initialize(name) @name = name end end orange1 = Fruit.new("orange") orange2 = Fruit.new("orange") orange1 == orange2 # false 

इसका कारण यह है कि == का डिफ़ॉल्ट कार्यान्वयन BasicObject#== है, जो यह पता लगाने के लिए object_id मेथड का उपयोग करता है कि दो वस्तुएं समान हैं या नहीं।

आप इसे इस तरह ठीक कर सकते हैं:

 class Fruit attr_reader :name def initialize(name) @name = name end def ==(other) name == other.name end end 

यहां हम कह रहे हैं कि दो फलों के समान होने का क्या मतलब है:

उनका नाम समान होना चाहिए।

रूबी अंकगणितीय ऑपरेटर्स

अगला सेट अंकगणितीय ऑपरेटर्स का है।

यहां कुछ नया नहीं है…

 5 + 5 # 10 10 * 2 # 20 10 ** 2 # 100 

लेकिन == ऑपरेटर की तरह, ये मेथड्स हैं।

यह उपयोगी है क्योंकि आप परिभाषित कर सकते हैं कि दो वस्तुओं को एक साथ जोड़ने का क्या मतलब है।

इसलिए यदि आपके पास दो Order वस्तुएं हैं, तो उन्हें एक साथ जोड़ने से आपको भुगतान की जाने वाली कुल राशि मिलती है, या आपको एक नया ऑर्डर मिलता है जो इन दो ऑर्डर्स का संयोजन है।

आप + मेथड को परिभाषित करके सटीक रूप से परिभाषित कर सकते हैं कि आप इसे कैसे काम करना चाहते हैं।

एक और ऑपरेटर जिससे आप परिचित नहीं हो सकते हैं वह है मॉड्यूलो ऑपरेटर।

यह प्रतिशत चिह्न (%) जैसा दिखता है।

और यह आपको एक विभाजन का शेष देता है।

उदाहरण:

 10 % 2 # 0 

मॉड्यूलो ऑपरेटर के कई व्यावहारिक उपयोग हैं, जैसे यह पता लगाना कि कोई संख्या सम या विषम है, यदि कोई संख्या किसी अन्य से विभाज्य है, किसी संख्या पर सीमा लगाने के लिए, आदि।

असाइनमेंट ऑपरेटर्स (==, +=, ||=)

अगला असाइनमेंट ऑपरेटर्स हैं, और अब तक देखे गए सभी ऑपरेटर्स के विपरीत, ये मेथड्स नहीं हैं।

आपके पास बुनियादी असाइनमेंट ऑपरेटर है:

 a = 1 

लेकिन आपके पास संयुक्त असाइनमेंट ऑपरेटर्स भी हैं:

 a += 5 # 6 a *= 2 # 12 

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

लेकिन दो असाइनमेंट ऑपरेटर्स हैं जो अलग तरह से व्यवहार करते हैं!

ये ||= और &&= हैं।

वे अलग हैं क्योंकि वे अंकगणितीय संस्करणों के बराबर नहीं हैं।

a ||= 100 यह करता है:

"यदि a मौजूद नहीं है या यदि यह false या nil है तो 100 असाइन करें, अन्यथा बस a का मान लौटाएं"

मैं जिस निकटतम समकक्ष अभिव्यक्ति तक पहुंच सकता हूं वह है:

 (defined?(a) && a) ? a : a = 100 

यह उपयोगी है यदि आप किसी धीमी गणना या API अनुरोध का परिणाम सहेजना चाहते हैं, एक प्रक्रिया जिसे "मेमोइज़ेशन" के रूप में जाना जाता है।

यूनरी ऑपरेटर्स क्या हैं?

अब तक आपने केवल उन ऑपरेटर्स को देखा है जो 2 मानों के साथ काम करते हैं, लेकिन ऑपरेटर्स भी हैं जो केवल एक मान के साथ काम करते हैं, हम इन्हें "यूनरी ऑपरेटर्स" कहते हैं।

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

 +"abc" 

यह एक फ्रोजन स्ट्रिंग की एक परिवर्तनीय प्रति बनाता है।

आप अपने स्वयं के यूनरी ऑपरेटर्स (+ / -) को परिभाषित कर सकते हैं, लेकिन आपको कुछ विशेष सिंटैक्स की आवश्यकता होगी।

उदाहरण:

 class String def +@ frozen? ? self.dup : self end end str = "abc".freeze p (+str).frozen? # false 

मुझे यहां पैरेंथेसिस का उपयोग करना होगा क्योंकि यूनरी ऑपरेटर्स की ऑपरेटर प्रिसिडेंस के कारण।

आपके पास !! भी है, जो एक मेथड नहीं है:

 !!123 # true !!nil # false 

यह उपयोगी है क्योंकि यह किसी भी मान को बूलियन में बदल देगा।

फिर आपके पास ! है, जो वही है लेकिन यह विपरीत बूलियन मान देता है।

उदाहरण:

 !true # false !!true # true !false # true 

रूबी स्प्लैट ऑपरेटर (उदाहरण के साथ)

स्प्लैट ऑपरेटर (*) दिलचस्प है क्योंकि यह कुछ ऐसा करता है जो आप इसके बिना नहीं कर सकते।

मान लीजिए आपके पास इस तरह की एक सरणी है:

 attributes = [:title, :author, :category] 

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

तब आप यह कर सकते हैं:

 attr_reader *attributes 

स्प्लैट ऑपरेटर सरणी को उसके तत्वों की सूची में परिवर्तित करता है। तो यह सरणी को हटाने और उसके अंदर की हर चीज़ से बदलने जैसा होगा।

दूसरे शब्दों में, अंतिम उदाहरण इसका अनुवाद करता है:

 attr_reader :title, :author, :category 

यही स्प्लैट ऑपरेटर की शक्ति है 🙂

मिलान ऑपरेटर (=~)

टिल्ड के साथ यह अजीब दिखने वाला रूबी ऑपरेटर (=~) क्या है?

यह मिलान ऑपरेटर है!

यह आपको एक नियमित अभिव्यक्ति का उपयोग करके एक त्वरित इंडेक्स खोज करने की अनुमति देता है।

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

 "3oranges" =~ /[0-9]/ # 0 

यह संख्याओं को खोजता है और स्ट्रिंग के अंदर उस इंडेक्स को लौटाता है जहां पहला मिलान पाया जाता है, अन्यथा यह nil लौटाता है।

इसके अलावा, आपके पास !~ ऑपरेटर है, जो "NOT मैच" ऑपरेटर है।

उदाहरण:

 "abc" !~ /[0-9]/ # false 

इसके साथ आपको इंडेक्स नहीं, true या false मिलेगा, इसलिए इसे ध्यान में रखें।

रूबी टर्नरी ऑपरेटर (प्रश्न चिह्न ऑपरेटर)

यदि आप कॉम्पैक्ट और छोटे कोड पसंद करते हैं तो आप रूबी टर्नरी ऑपरेटर को पसंद करने जा रहे हैं।

यह कॉम्पैक्ट if/else स्टेटमेंट लिखने का एक तरीका है।

यह ऐसा दिखता है:

 condition ? true : false 

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

 "".size == 0 ? "Empty string" : "Non-empty string" 

यह इस तरह काम करता है:

टर्नरी ऑपरेटर का पहला भाग शर्त को परिभाषित करता है ("".size == 0)।

फिर आपके पास एक प्रश्न चिह्न प्रतीक (?) होता है।

उसके बाद, आपके पास जब यह शर्त सत्य हो के लिए रिटर्न मान होता है।

फिर एक कोलन (:)।

और अंतिम भाग जब यह शर्त असत्य हो के लिए रिटर्न मान है, यह पूर्ण सशर्त अभिव्यक्ति में else होगा।

शॉवेल / पुश ऑपरेटर (<<)

यह ऑपरेटर (<<) भी एक मेथड है, इसलिए यह इस बात पर निर्भर करता है कि आप किस वस्तु के साथ काम कर रहे हैं।

उदाहरण के लिए, सरणियों के साथ यह केवल push मेथड का एक उपनाम है।

 animals = [] animals << "cat" 

स्ट्रिंग्स के साथ यह अंत में जोड़ देगा:

 "" << "cat" 

और Integers के साथ, यह "बाएं शिफ्ट" करेगा, जो सभी बिट्स को बाएं घुमा रहा है।

 2 << 1 # 4 2 << 2 # 8 2 << 3 # 16 

ट्रिपल इक्वल्स ऑपरेटर (समानता से अधिक)

आज हमारा अंतिम ऑपरेटर ट्रिपल इक्वल्स ऑपरेटर (===) के बारे में होने जा रहा है।

यह भी एक मेथड है, और यह उन स्थानों पर भी दिखाई देता है जहां आप इसकी उम्मीद नहीं करेंगे।

उदाहरण के लिए, एक केस स्टेटमेंट में:

 case "bacon" when String puts "It's a string!" when Integer puts "It's an integer" end 

रूबी यहां क्लास पर === मेथड को कॉल कर रहा है।

इस तरह:

 String === "bacon" 

यह वर्तमान क्लास की तुलना दूसरी वस्तु के क्लास से करता है।

तो इस ऑपरेटर का उद्देश्य केस स्टेटमेंट के संदर्भ में समानता को परिभाषित करना है।

सेफ नेविगेटर ऑपरेटर (&.)

आप किसी वस्तु पर एक मेथड कॉल करना चाह सकते हैं, लेकिन यह वस्तु nil हो सकती है, जो अच्छा नहीं है क्योंकि nil पर मेथड कॉल करने से अक्सर त्रुटि होती है।

एक समाधान:

 if user && user.active # ... end 

इसे करने का एक बेहतर तरीका:

 if user&.active # ... end 

यह &. सेफ नेविगेटर ऑपरेटर है (रूबी 2.3 में पेश किया गया), जो user पर active मेथड को केवल तभी कॉल करता है जब यह nil न हो।

बहुत उपयोगी!

ऑपरेटर प्रिसिडेंस टेबल

रूबी आपके स्रोत कोड का मूल्यांकन प्राथमिकताओं की एक सूची का पालन करके करता है, जैसे गणित में गुणा और पैरेंथेसिस के साथ होता है।

यदि आप नहीं समझते कि यह कैसे काम करता है तो यह सभी प्रकार की त्रुटियों का स्रोत बन सकता है।

यहां एक तालिका है, उच्च से निम्न प्रिसिडेंस तक:

modifier-something के साथ इसका मतलब इन कीवर्ड्स का वन-लाइनर संस्करण है।

उदाहरण:

 puts "awesome" if blog_name == "rubyguides" 

यहां एक उदाहरण है जहां ब्लॉक प्रिसिडेंस आपको आश्चर्यचकित कर सकता है:

 # अपरकेस वर्णों के साथ सरणी लौटाता है p ["a", "b", "c"].map { |character| character.upcase } # Enumerator वस्तु लौटाता है p ["a", "b", "c"].map do |character| character.upcase end 

पहले मामले में यह अपेक्षा के अनुरूप काम करता है, दूसरे मामले में ब्लॉक की प्रिसिडेंस कम होती है इसलिए map को लगता है कि कोई ब्लॉक नहीं है और एक एन्यूमरेटर लौटाता है।

सारांश

आपने रूबी के कई ऑपरेटर्स के बारे में सीखा, अंकगणितीय ऑपरेटर्स से, लॉजिक तक और यहां तक कि अधिक अस्पष्ट यूनरी ऑपरेटर्स तक।

इनमें से कई ऑपरेटर्स वास्तव में मेथड्स हैं जिन्हें आप अपने स्वयं के वर्गों में लागू कर सकते हैं।

आशा है कि आपने इसे उपयोगी और दिलचस्प पाया!

पढ़ने के लिए धन्यवाद 🙂