खोज…


टिप्पणियों

संचालक विधियां हैं

अधिकांश ऑपरेटर वास्तव में सिर्फ विधियां हैं, इसलिए x + y तर्क y साथ x का + तरीका कह रहा है, जिसे x.+(y) लिखा जाएगा x.+(y) । यदि आप किसी दिए गए ऑपरेटर के अपने स्वयं के अर्थ अर्थ की एक विधि लिखते हैं, तो आप अपने संस्करण को कक्षा में लागू कर सकते हैं।

एक मूर्खतापूर्ण उदाहरण के रूप में:

# 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

कब और उपयोग करना है && बनाम and , || बनाम or

ध्यान दें कि बूलियन को व्यक्त करने के दो तरीके हैं, या तो && या and , और || या or - वे अक्सर परस्पर विनिमय कर रहे, लेकिन हमेशा नहीं। हम इन्हें "वर्ण" और "शब्द" वेरिएंट के रूप में संदर्भित करेंगे।

वर्ण वैरिएंट की उच्च प्राथमिकता है, इसलिए अधिक जटिल बयानों में कोष्ठक की आवश्यकता को कम करने से अप्रत्याशित त्रुटियों से बचने में मदद मिलती है।

शब्द वेरिएंट मूल रूप से बूलियन ऑपरेटरों के बजाय नियंत्रण प्रवाह ऑपरेटरों के रूप में अभिप्रेत था। यही है, वे जंजीर विधि कथनों में इस्तेमाल किए जाने के लिए डिज़ाइन किए गए थे:

raise 'an error' and return

जबकि उनका उपयोग बूलियन ऑपरेटरों के रूप में किया जा सकता है, उनकी निम्न मिसाल उन्हें अप्रत्याशित बनाती है।

दूसरे, कई रूबिस्ट्स बूलियन एक्सप्रेशन (जो true या false मूल्यांकन करता true ) जैसे x.nil? || x.empty? बनाते समय वर्ण संस्करण को पसंद करते हैं x.nil? || x.empty? । दूसरी ओर, वेरिएंट शब्द उन मामलों में पसंद किया जाता है, जहां तरीकों की एक श्रृंखला का मूल्यांकन किया जाता है, और एक विफल हो सकता है। उदाहरण के लिए एक सामान्य मुहावरे का उपयोग ऐसे शब्दों के लिए किया गया है जो विफलता पर nil लौटाते हैं।

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


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow