Ruby Language
ऑपरेटर्स

टिप्पणियों

# A class that lets you operate on numbers by name.
class NamedInteger
  name_to_value = { 'one' => 1, 'two' => 2, ... }

  # define the plus method
  def + (left_addend, right_addend)
    name_to_value(left_addend) + name_to_value(right_addend)
  end

  ...
end

raise 'an error' and return

def deliver_email
  # If the first fails, try the backup, and if that works, all good
  deliver_by_primary or deliver_by_backup and return
  # error handling code
end

ऑपरेटर की प्रक्रिया और तरीके

उच्चतम से निम्नतम तक, यह रूबी के लिए पूर्वता तालिका है। उच्च पूर्वता संचालन कम पूर्ववर्ती संचालन से पहले होता है।

╔═══════════════════════╦════════════════════════════════════════╦═════════╗
║ Operators             ║                 Operations             ║ Method? ║
╠═══════════════════════╬════════════════════════════════════════╬═════════╣
║ .                     ║ Method call (e.g. foo.bar)             ║         ║
║ []  []=               ║ Bracket Lookup, Bracket Set            ║    ✓¹   ║
║ ! ~ +                 ║ Boolean NOT, complement, unary plus    ║    ✓²   ║
║ **                    ║ Exponentiation                         ║    ✓    ║
║ -                     ║ Unary minus                            ║    ✓²   ║
║ * / %                 ║ Multiplication, division, modulo       ║    ✓    ║
║ + -                   ║ Addition, subtraction                  ║    ✓    ║
║ << >>                 ║ Bitwise shift                          ║    ✓    ║
║ &                     ║ Bitwise AND                            ║    ✓    ║
║ | ^                   ║ Bitwise OR, Bitwise XOR                ║    ✓    ║
║ < <= >= >             ║ Comparison                             ║    ✓    ║
║ <=> == != === =~ !~   ║ Equality, pattern matching, comparison ║    ✓³   ║
║ &&                    ║ Boolean AND                            ║         ║
║ ||                    ║ Boolean OR                             ║         ║
║ .. ...                ║ Inclusive range, Exclusive range       ║         ║
║ ? :                   ║ Ternary operator                       ║         ║
║ rescue                ║ Modifier rescue                        ║         ║
║ = += -=               ║ Assignments                            ║         ║
║ defined?              ║ Defined operator                       ║         ║
║ not                   ║ Boolean NOT                            ║         ║
║ or and                ║ Boolean OR, Boolean AND                ║         ║
║ if unless while until ║ Modifier if, unless, while, until      ║         ║
║ { }                   ║ Block with braces                      ║         ║
║ do end                ║ Block with do end                      ║         ║
╚═══════════════════════╩════════════════════════════════════════╩═════════╝

Unary + और unary - for +obj , -obj या -(some_expression) ।

संशोधक-अगर, संशोधक-जब तक, आदि उन खोजशब्दों के संशोधक संस्करणों के लिए हैं। उदाहरण के लिए, यह एक संशोधक-जब तक कि अभिव्यक्ति नहीं है:

a += 1 unless a.zero?

Ators वाले ऑपरेटर्स को विधियों के रूप में परिभाषित किया जा सकता है। अधिकांश तरीकों का नाम ठीक वैसे ही रखा जाता है जैसे ऑपरेटर का नाम, उदाहरण के लिए:

class Foo
  def **(x)
    puts "Raising to the power of #{x}"
  end
  def <<(y)
    puts "Shifting left by #{y}"
  end
  def !
    puts "Boolean negation"
  end
end

Foo.new ** 2     #=> "Raising to the power of 2"
Foo.new << 3     #=> "Shifting left by 3"
!Foo.new         #=> "Boolean negation"

Methods ब्रैकेट लुकअप और ब्रैकेट सेट विधियाँ ( [] और []= ) उनके नाम के बाद परिभाषित तर्क हैं, उदाहरण के लिए:

class Foo
  def [](x)
    puts "Looking up item #{x}"
  end
  def []=(x,y)
    puts "Setting item #{x} to #{y}"
  end
end

f = Foo.new
f[:cats] = 42    #=> "Setting item cats to 42"
f[17]            #=> "Looking up item 17"

Ary "यूनीरी प्लस" और "यूनरी माइनस" ऑपरेटरों को उदाहरण के लिए +@ और -@ नाम के तरीकों के रूप में परिभाषित किया गया है

class Foo
  def -@
    puts "unary minus"
  end
  def +@
    puts "unary plus"
  end
end

f = Foo.new
+f               #=> "unary plus"
-f               #=> "unary minus"

रूबी असमानता ऑपरेटर के शुरुआती संस्करणों में != और गैर-मिलान ऑपरेटर !~ को विधियों के रूप में परिभाषित नहीं किया जा सकता है। इसके बजाय, इसी समानता ऑपरेटर के लिए विधि == या मिलान ऑपरेटर =~ को लागू किया गया था, और उस विधि का परिणाम रूबी द्वारा उलटा था।

यदि आप अपने स्वयं को परिभाषित नहीं करते हैं != !~ ऑपरेटर उपरोक्त व्यवहार अभी भी सच है। हालांकि, रूबी 1.9.1 के रूप में, उन दो ऑपरेटरों को भी तरीकों के रूप में परिभाषित किया जा सकता है:

class Foo
  def ==(x)
    puts "checking for EQUALITY with #{x}, returning false"
    false
  end
end

f = Foo.new
x = (f == 42)    #=> "checking for EQUALITY with 42, returning false"
puts x           #=> "false"
x = (f != 42)    #=> "checking for EQUALITY with 42, returning false"
puts x           #=> "true"

class Foo
  def !=(x)
    puts "Checking for INequality with #{x}"
  end
end

f != 42          #=> "checking for INequality with 42"

मामला समानता ऑपरेटर (===)

जिसे ट्रिपल बराबर के नाम से भी जाना जाता है ।

यह ऑपरेटर समानता का परीक्षण नहीं करता है, बल्कि परीक्षण करता है कि क्या सही ऑपरेंड का IS के बाएं ऑपेरांड के साथ संबंध है । जैसे, लोकप्रिय नाम केस समानता ऑपरेटर भ्रामक है।

यह SO उत्तर इस प्रकार वर्णन करता है: a === b का वर्णन करने का सबसे अच्छा तरीका है "अगर मेरे पास एक दराज लेबल a , तो क्या इसमें b लगाने का कोई मतलब है?" दूसरे शब्दों में, सेट करता है a सदस्य शामिल b ?

उदाहरण ( स्रोत )

(1..5) === 3            # => true
(1..5) === 6            # => false

Integer === 42          # => true
Integer === 'fourtytwo' # => false

/ell/ === 'Hello'       # => true
/ell/ === 'Foobar'      # => false

कक्षाएं जो ओवरराइड करती हैं ===

कई वर्गों को ओवरराइड === मामले बयान में सार्थक अर्थ विज्ञान प्रदान करने के लिए। उनमें से कुछ हैं:

╔═════════════════╦════════════════════╗
║      Class      ║     Synonym for    ║
╠═════════════════╬════════════════════╣
║ Array           ║ ==                 ║
║                 ║                    ║
║ Date            ║ ==                 ║
║                 ║                    ║
║ Module          ║ is_a?              ║
║                 ║                    ║
║ Object          ║ ==                 ║
║                 ║                    ║
║ Range           ║ include?           ║
║                 ║                    ║
║ Regexp          ║ =~                 ║
║                 ║                    ║
║ String          ║ ==                 ║
╚═════════════════╩════════════════════╝

अनुशंसित अभ्यास

मामला समानता ऑपरेटर === स्पष्ट उपयोग से बचा जाना चाहिए। यह समानता का परीक्षण नहीं करता, बल्कि निर्वाह करता है , और इसका उपयोग भ्रामक हो सकता है। कोड को स्पष्ट और समझने में आसान है जब इसके बजाय पर्यायवाची विधि का उपयोग किया जाता है।

# Bad
Integer === 42
(1..5) === 3
/ell/ === 'Hello'

# Good, uses synonym method
42.is_a?(Integer)
(1..5).include?(3)
/ell/ =~ 'Hello'

सुरक्षित नेविगेशन ऑपरेटर

रूबी 2.3.0 ने सुरक्षित नेविगेशन ऑपरेटर को जोड़ा, &. । यह संचालक सशर्त बयानों में object && object.property && object.property.method के प्रतिमान को छोटा करने का इरादा रखता है।

उदाहरण के लिए, आपके पास address संपत्ति के साथ एक House ऑब्जेक्ट है, और आप address से street_name ढूंढना चाहते हैं। पुराने रूबी संस्करणों में शून्य त्रुटियों से बचने के लिए इसे सुरक्षित रूप से प्रोग्राम करने के लिए, आप कोड का उपयोग इस तरह से करेंगे:

if house && house.address && house.address.street_name
  house.address.street_name
end

सुरक्षित नेविगेशन ऑपरेटर इस स्थिति को छोटा करता है। इसके बजाय, आप लिख सकते हैं:

if house&.address&.street_name
  house.address.street_name
end

सावधान:
सुरक्षित नेविगेशन ऑपरेटर श्रृंखलित सशर्त के रूप में बिल्कुल वैसा ही व्यवहार नहीं है। जंजीर सशर्त (पहले उदाहरण) का उपयोग करते हुए, if ब्लॉक को निष्पादित नहीं किया जाएगा, तो कहें कि address false था। सुरक्षित नेविगेशन ऑपरेटर केवल nil मानों को पहचानता है, लेकिन false जैसे मूल्यों की अनुमति देता है। यदि address false , तो SNO का उपयोग करने से त्रुटि होगी:

house&.address&.street_name
# => undefined method `address' for false:FalseClass