रूबी ऑपरेटरों के बारे में आपको जो कुछ पता होना चाहिए

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

पसंद करें :

• स्पेसशिप ऑपरेटर (<=> )
• मॉड्यूलो असाइनमेंट ऑपरेटर (%= )
• तिहाई बराबर होता है (=== ) ऑपरेटर
• इससे बड़ा (> ) और इससे कम (< )
• बराबर नहीं (!= )

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

इसका मतलब है...

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

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

अब :

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

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

सामग्री

• 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 हैं ऑब्जेक्ट, उन्हें एक साथ जोड़ने से आपको भुगतान की जाने वाली कुल राशि मिलती है, या आपको एक नया ऑर्डर मिलता है जो इन दो ऑर्डर का संयोजन है।

आप बिल्कुल define को परिभाषित कर सकते हैं + . को परिभाषित करके आप इसे कैसे काम करना चाहते हैं विधि।

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

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

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

उदाहरण :

10 % 2
# 0

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

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

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

आपके पास मूल असाइनमेंट ऑपरेटर है:

a = 1

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

a += 5
# 6

a *= 2
# 12

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

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

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

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

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

“अगर a मौजूद नहीं है या अगर यह false है या nil फिर असाइन करें 100 इसके लिए, अन्यथा केवल a . का मान लौटाएं "

मैं एक समान अभिव्यक्ति के सबसे करीब यह प्राप्त कर सकता हूं:

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

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

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

अब तक आपने केवल उन ऑपरेटरों को देखा है जो 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

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

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

उदाहरण :

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

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

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

अगर आपको कॉम्पैक्ट और शॉर्ट कोड पसंद है तो आपको रूबी टर्नरी ऑपरेटर पसंद आएगा।

यह अगर/अन्य कथनों को संक्षिप्त लिखने का एक तरीका है।

ऐसा दिखता है :

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 में पेश किया गया), जो केवल active को कॉल करता है user . पर विधि अगर यह nil नहीं है ।

बहुत उपयोगी!

ऑपरेटर वरीयता तालिका

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

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

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

संशोधक-कुछ के साथ इसका मतलब इन खोजशब्दों का एक-पंक्ति वाला संस्करण है।

उदाहरण :

puts "awesome" if blog_name == "rubyguides"

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

# Returns array with uppercase characters
p ["a", "b", "c"].map { |character| character.upcase }

# Returns Enumerator object
p ["a", "b", "c"].map do |character|
  character.upcase
end

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

सारांश

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

इनमें से कई ऑपरेटर वास्तव में ऐसे तरीके हैं जिन्हें आप अपनी कक्षाओं में लागू कर सकते हैं।

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

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