रूबी - ऑपरेटर्स

रूबी ऑपरेटरों के एक समृद्ध सेट का समर्थन करती है, जैसा कि आप एक आधुनिक भाषा से उम्मीद करेंगे। अधिकांश ऑपरेटर वास्तव में मेथड कॉल होते हैं। उदाहरण के लिए, ए + बी एक के रूप में व्याख्या की है। + (ख), जहां किसी चीज़ में + विधि चर से जाना जाता एक साथ कहा जाता है ख अपने तर्क के रूप में।

प्रत्येक ऑपरेटर (+ - * /% ** | ^ << >> && ||) के लिए, संक्षिप्त रूप असाइनमेंट ऑपरेटर (+ = - = आदि) का एक संगत रूप है।

रूबी अंकगणित संचालक

चर को 10 मानिए और चर b को 20 मानिए, तब -

ऑपरेटर	विवरण	उदाहरण
+	परिवर्धन - ऑपरेटर के दोनों ओर मान जोड़ता है।	a + b 30 देगा
-	घटाव - बाएं हाथ के ऑपरेंड से दाहिने हाथ के ऑपरेंड को घटाते हैं।	a - b देगा -10
*	गुणन - ऑपरेटर के दोनों ओर मूल्यों को गुणा करता है।	a * b 200 देगा
/	डिवीजन - दाएं हाथ के ऑपरेंड द्वारा बाएं हाथ के ऑपरेशन को विभाजित किया जाता है।	b / a 2 देगा
%	मापांक - दाएं हाथ से बाएं हाथ के ऑपरेंड को बांटा जाता है और शेष को लौटाता है।	ब% ए वल 0 ट
**	घातांक - ऑपरेटरों पर घातांक (शक्ति) गणना करता है।	एक ** बी 10 को 20 शक्ति देगा

रूबी तुलना ऑपरेटर

चर को 10 मानिए और चर b को 20 मानिए, तब -

ऑपरेटर	विवरण	उदाहरण
==	जाँच करता है कि दो ऑपरेंड का मूल्य बराबर है या नहीं, यदि हाँ तो स्थिति सच हो जाती है।	(a == b) सत्य नहीं है।
! =	जाँच करता है कि दो ऑपरेंड का मान बराबर है या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है।	(a! = b) सत्य है।
>	जाँच करता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से अधिक है, यदि हाँ, तो स्थिति सत्य हो जाती है।	(a> b) सत्य नहीं है।
<	यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम है, यदि हाँ तो स्थिति सही है।	(a <b) सत्य है।
> =	जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या बराबर है, यदि हाँ तो स्थिति सच हो जाती है।	(a> = b) सत्य नहीं है।
<=	जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से कम या बराबर है, यदि हाँ तो स्थिति सच हो जाती है।	(अ <= ख) सत्य है।
<=>	संयुक्त तुलना ऑपरेटर। रिटर्न 0 अगर पहला ऑपरेंड दूसरे के बराबर है, तो पहला ऑपरेंड दूसरे से ज्यादा और -1 अगर पहला ऑपरेंड दूसरे से कम है।	(ए <=> बी) रिटर्न -1।
===	केस स्टेटमेंट के क्लॉज के समय समानता का परीक्षण करने के लिए उपयोग किया जाता है ।	(1 ... 10) === 5 रिटर्न सही।
.eql?	यदि रिसीवर और तर्क में समान प्रकार और समान मान हैं, तो यह सही है।	1 == 1.0 रिटर्न सही है, लेकिन 1.eql? (1.0) गलत है।
बराबरी का?	सही है अगर रिसीवर और तर्क में एक ही ऑब्जेक्ट आईडी है।	aObj bObj का डुप्लिकेट है तो aObj == bObj सत्य है, a.equal? ​​bObj असत्य है, लेकिन a। असमान? aObj सत्य है।

रूबी असाइनमेंट ऑपरेटर्स

चर को 10 मानिए और चर b को 20 मानिए, तब -

ऑपरेटर	विवरण	उदाहरण
=	साधारण असाइनमेंट ऑपरेटर, राइट साइड ऑपरेंड्स से लेफ्ट साइड ऑपरेंड तक वैल्यूज असाइन करता है।	c = a + b a + b को c में मान देगा
+ =	जोड़ें और असाइनमेंट ऑपरेटर, बाएं ऑपरेटर के लिए सही ऑपरेंड जोड़ता है और बाएं ऑपरेंड को परिणाम असाइन करता है।	c + = a, c = c + a के बराबर है
- =	घटाना और असाइनमेंट ऑपरेटर, बाएं ऑपरेंड से दाएं ऑपरेंड को घटाता है और बाएं ऑपरेंड को परिणाम असाइन करता है।	c - = a, c = c - a के बराबर है
* =	गुणा और असाइनमेंट ऑपरेटर, बाएं ऑपरेंड के साथ दाएं ऑपरेंड को गुणा करता है और बाएं ऑपरेंड को परिणाम असाइन करता है।	c * = a a c = c * a के बराबर है
/ =	डिवाइड और असाइनमेंट ऑपरेटर, बाएं ऑपरेंड को दाएं ऑपरेंड के साथ विभाजित करता है और परिणाम को बाएं ऑपरेंड को असाइन करता है।	c / = a, c = c / a के बराबर है
% =	मापांक और असाइनमेंट ऑपरेटर, दो ऑपरेंड का उपयोग करके मापांक लेता है और परिणाम को बाएं ऑपरेंड में असाइन करता है।	c% = a, c = c% a के बराबर है
** =	घातांक और असाइनमेंट ऑपरेटर, ऑपरेटरों पर घातांक (शक्ति) गणना करता है और बाएं ऑपरेंड को मान प्रदान करता है।	c ** = a, c = c ** a के बराबर है

रूबी समानांतर समीकरण

रूबी भी चर के समानांतर असाइनमेंट का समर्थन करती है। यह कई चर को रूबी कोड की एक पंक्ति के साथ आरंभ करने में सक्षम बनाता है। उदाहरण के लिए -

a = 10
b = 20
c = 30

यह समानांतर असाइनमेंट का उपयोग करके अधिक तेज़ी से घोषित किया जा सकता है -

a, b, c = 10, 20, 30

दो चर में रखे गए मानों की अदला-बदली के लिए समानांतर असाइनमेंट भी उपयोगी है -

a, b = b, c

रूबी बिटवाइज ऑपरेटर्स

बिटवाइज़ ऑपरेटर बिट पर काम करता है और बिट ऑपरेशन द्वारा बिट करता है।

मान लें कि अगर a = 60; और बी = 13; अब द्विआधारी प्रारूप में वे निम्नानुसार होंगे -

a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

निम्न Bitwise ऑपरेटरों रूबी भाषा द्वारा समर्थित हैं।

ऑपरेटर	विवरण	उदाहरण
और	बाइनरी और ऑपरेटर परिणाम के लिए थोड़ा सा कॉपी करता है यदि यह दोनों ऑपरेंड में मौजूद है।	(a & b) 12 देगा, जो 0000 1100 है
|	बाइनरी या ऑपरेटर थोड़ा सा कॉपी करता है अगर यह किसी भी ऑपरेंड में मौजूद है।	(a | b) 61 देगा, जो 0011 1101 है
^	बाइनरी एक्सओआर ऑपरेटर बिट को कॉपी करता है यदि यह एक ऑपरेंड में सेट होता है लेकिन दोनों नहीं।	(ए ^ बी) 49 देगा, जो 0011 0001 है
~	बाइनरी ओन्स कंप्लीट ऑपरेटर, एकात्मक है और इसमें 'फ्लिपिंग' बिट्स का प्रभाव है।	(~ ए) -61 देगा, जो कि हस्ताक्षरित बाइनरी नंबर के कारण २ के पूरक रूप में ११०० ००११ है।
<<	बाइनरी लेफ्ट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से छोड़ दिया जाता है।	एक << 2 240 देगा, जो कि 1111 0000 है
>>	बाइनरी राइट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाएं स्थानांतरित किया जाता है।	>> >> 2 15 देगा, जो 0000 1111 है

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

रूबी भाषा द्वारा निम्नलिखित तार्किक ऑपरेटरों का समर्थन किया जाता है

मान लें चर एक 10 रखती है और चर ख 20 रखती है, तो -

ऑपरेटर	विवरण	उदाहरण
तथा	जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। यदि दोनों ऑपरेंड सच हैं, तो स्थिति सच हो जाती है।	(a और b) सत्य है।
या	जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दो संचालकों में से कोई भी गैर शून्य है, तो स्थिति सच हो जाती है।	(a या b) सत्य है।
&&	जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। यदि दोनों ऑपरेंड नॉन जीरो हैं, तो स्थिति सच हो जाती है।	(a && b) सत्य है।
||	जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दो संचालकों में से कोई भी गैर शून्य है, तो स्थिति सच हो जाती है।	(ए || बी) सच है
!	जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है। उपयोग अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सही है, तो तार्किक संचालक गलत नहीं करेगा।	! (a && b) गलत है।
नहीं	जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है। उपयोग अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सही है, तो तार्किक संचालक गलत नहीं करेगा।	नहीं (a && b) गलत है।

रूबी टर्नेरी संचालक

एक और ऑपरेटर है जिसे टर्नेरी ऑपरेटर कहा जाता है। यह पहले एक सच्चे या गलत मूल्य के लिए एक अभिव्यक्ति का मूल्यांकन करता है और फिर मूल्यांकन के परिणाम के आधार पर दो दिए गए कथनों में से एक को निष्पादित करता है। सशर्त ऑपरेटर का यह सिंटैक्स है -

ऑपरेटर	विवरण	उदाहरण
? :	सशर्त अभिव्यक्ति	अगर हालत सच है? तब X मान: अन्यथा Y मान

रूबी रेंज ऑपरेटर्स

रूबी में अनुक्रम श्रेणियों का उपयोग क्रमिक मानों की एक श्रृंखला बनाने के लिए किया जाता है - जिसमें एक प्रारंभ मूल्य, एक अंतिम मूल्य और बीच में मूल्यों की एक श्रृंखला शामिल है।

रूबी में, ये अनुक्रम ".." और "..." रेंज ऑपरेटरों का उपयोग करके बनाए गए हैं। दो-डॉट फ़ॉर्म एक समावेशी श्रेणी बनाता है, जबकि तीन-डॉट फ़ॉर्म एक सीमा बनाता है जो निर्दिष्ट उच्च मान को बाहर करता है।

ऑपरेटर	विवरण	उदाहरण
..	समावेशी बिंदु से अंत तक समावेशी की एक सीमा बनाता है।	1..10 1 से 10 समावेशी की सीमा बनाता है।
...	प्रारंभ बिंदु से अंत बिंदु अनन्य तक की सीमा बनाता है।	1 ... 10 1 से 9 तक की सीमा बनाता है।

रूबी परिभाषित? ऑपरेटर्स

परिभाषित? एक विशेष ऑपरेटर है जो यह निर्धारित करने के लिए एक विधि कॉल का रूप लेता है कि क्या पारित अभिव्यक्ति परिभाषित है या नहीं। यदि यह अभिव्यक्ति परिभाषित नहीं है , तो यह अभिव्यक्ति का विवरण स्ट्रिंग या शून्य देता है।

परिभाषित के विभिन्न उपयोग हैं? ऑपरेटर

उपयोग 1

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

उपयोग २

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

उपयोग ३

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

उपयोग ४

defined? yield   # True if a code block has been passed

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

रूबी डॉट "।" और डबल कोलोन "::" ऑपरेटर्स

आप मॉड्यूल के नाम और एक अवधि के साथ इसके नाम से पहले एक मॉड्यूल विधि कहते हैं, और आप मॉड्यूल नाम और दो कॉलोन का उपयोग करके एक निरंतर का संदर्भ देते हैं।

:: एक संयुक्त संचालक है जो अनुमति देता है: वर्ग या मॉड्यूल के बाहर कहीं से भी एक्सेस किए जाने के लिए एक वर्ग या मॉड्यूल के भीतर परिभाषित स्थिरांक, आवृत्ति विधियाँ और वर्ग विधियाँ।

Remember रूबी में, वर्गों और विधियों को स्थिरांक भी माना जा सकता है।

आपको बस उपसर्ग करने की आवश्यकता है :: एक अभिव्यक्ति के साथ Const_name जो उपयुक्त वर्ग या मॉड्यूल ऑब्जेक्ट लौटाता है।

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

यहाँ दो उदाहरण हैं -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

रूबी संचालक पूर्ववर्ती

निम्न तालिका सभी ऑपरेटरों को उच्चतम वरीयता से सबसे कम तक सूचीबद्ध करती है।

तरीका	ऑपरेटर	विवरण
हाँ	::	लगातार संकल्प ऑपरेटर
हाँ	[] [] =	तत्व संदर्भ, तत्व सेट
हाँ	**	घातांक (शक्ति तक बढ़ाएं)
हाँ	! ~ + -	नहीं, पूरक, एकरी प्लस और माइनस (अंतिम दो के लिए विधि नाम + @ और - @) हैं
हाँ	* *%	गुणा, भाग और मोडुलो
हाँ	+ -	जोड़ और घटाव
हाँ	>> <<	दाएं और बाएं बिटवाइड शिफ्ट
हाँ	और	बिटवाइज़ 'और'
हाँ	^ |	बिटवाइज़ एक्सक्लूसिव `OR’ और रेगुलर `OR’
हाँ	<= <>> =	तुलना ऑपरेटरों
हाँ	<=> == ===! = = ~ ~! ~	समानता और पैटर्न मैच ऑपरेटरों (! =! ~ तरीकों के रूप में परिभाषित नहीं किया जा सकता है)
	&&	तार्किक 'और'
	||	तार्किक 'या'
	.. ...	रेंज (समावेशी और अनन्य)
	? :	टर्नरी अगर-तब-तब
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** = = |	असाइनमेंट
	परिभाषित?	निर्दिष्ट प्रतीक की जाँच करें
	नहीं	तार्किक नकार
	या और	तार्किक रचना

NOTE- विधि कॉलम में हां के साथ ऑपरेटर वास्तव में विधियां हैं, और जैसे कि ओवरराइड हो सकता है।