रूबी काम में [वर्ग ब्रैकेट] पद्धति को कैसे परिभाषित करता है?

माणिक में कई भाषाओं के विपरीत तरीके कुछ विशेष वर्ण हो सकते हैं। जिनमें से एक सरणी लुकअप सिंटैक्स है।

यदि आप अपने स्वयं के हैश वर्ग को लागू करते हैं, जहां आपके हैश में एक आइटम प्राप्त करते समय, आप इसे उल्टा करना चाहते थे, तो आप इसे नीचे रख सकते हैं:

class SillyHash < Hash

  def [](key)
    super.reverse
  end

end

आप इसे निम्नलिखित के साथ हैश कहकर साबित कर सकते हैं:

a = {:foo => "bar"}
 => {:foo=>"bar"} 
a.[](:foo)
 => "bar" 
a.send(:[], :foo)
 => "bar" 

तो डीईएफ़ [] ने उस विधि को परिभाषित किया जिसका उपयोग आप करते हैंmy_array["key"]अन्य तरीके जो आपको अजीब लग सकते हैं:

class SillyHash < Hash

  def [](key)
    super.reverse
  end

  def []=(key, value)
    #do something
  end

  def some_value=(value)
    #do something
  end

  def is_valid?(value)
    #some boolean expression
  end

end

बस स्पष्ट करने के लिए, एक की परिभाषा[]विधि arrays या hashes के लिए असंबंधित है। निम्नलिखित (विपरीत) उदाहरण लें:

class B
  def []
    "foo"
  end
end

 B.new[]
 => "foo" 

यह सिंटैक्टिक शुगर है। कुछ सिंटैक्स पैटर्न हैं जो संदेश भेजने में अनुवादित होते हैं। विशेष रूप से

a + b

के समान है

a.+(b)

और यही बात लागू होती है==, !=, <, >, <=, >=, <=>, ===, &, |, *, /, -, %, **, >>, <<, !==, =~तथा!~भी।

इसके अलावा,

!a

के समान है

a.!

और यही बात लागू होती है~.

फिर,

+a

के समान है

[email protected]

और यही बात लागू होती है-.

प्लस,

a.(b)

के समान है

a.call(b)

बसने वालों के लिए विशेष वाक्यविन्यास भी है:

a.foo = b

के समान है

a.foo=(b)

और अंतिम लेकिन कम से कम, अनुक्रमण के लिए विशेष वाक्यविन्यास है:

a[b]

के समान है

a.[](b)

तथा

a[b] = c

के समान है

a.[]=(b, c)

वर्ग कोष्ठक विधि नाम जैसे हैंArray#sizeआपके पासArray#[]एक विधि के रूप में और आप इसे किसी अन्य विधि की तरह भी उपयोग कर सकते हैं:

array = [ 'a', 'b', 'c']
array.[](0) #=> 'a'
array.[] 1  #=> 'b'
array[2]    #=> 'c'

अंतिम वाक्य चीनी की तरह कुछ है और पहले वाले के समान ही करता है।Array#+समान काम:

array1 = [ 'a', 'b' ]
array2 = [ 'c', 'd' ]
array1.+(array2) #=> [ 'a', 'b', 'c', 'd' ]
array1.+ array2  #=> [ 'a', 'b', 'c', 'd' ]
array1 + array2  #=> [ 'a', 'b', 'c', 'd' ]

आप इस तरह से संख्याएँ जोड़ सकते हैं:

1.+(1) #=> 2
1.+ 1  #=> 2
1 + 1  #=> 2

उसी के साथ काम करता है/, *, -और बहुत सारे।

यह एक ऑपरेटर अधिभार है, यह आपके द्वारा परिभाषित की गई कक्षा के अंदर एक विधि के व्यवहार को ओवरराइड या पूरक करता है, या एक वर्ग जिसके व्यवहार को आप संशोधित कर रहे हैं। आप इसे [] से अलग अन्य ऑपरेटरों के लिए कर सकते हैं। इस मामले में आप []] के व्यवहार को संशोधित कर रहे हैं, जब इसे क्लास सॉन्गलिस्ट के किसी भी उदाहरण पर बुलाया जाता है।

यदि आपके पास गीतसूची = सोंग लिस्ट.न्यू है और फिर आप गीत सूची ["फोब्बर"] करते हैं, तो आपका कस्टम डिफ ऑपरेशन में आ जाएगा और यह मान लेगा कि "फोबार" को पैरामीटर (कुंजी) के रूप में पारित किया जाना है और यह "फोबार" को करेगा "जो भी विधि कहती है उसे कुंजी के लिए किया जाना चाहिए।

प्रयत्न

class Overruler
    def [] (input)
          if input.instance_of?(String)
            puts "string"
          else
            puts "not string"
          end
     end
end
foo = Overruler.new
foo["bar"].inspect
foo[1].inspect