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

Translate

मैं गुजर रहा हूंप्रोग्रामिंग रूबी - एक व्यावहारिक प्रोग्रामर गाइडऔर कोड के इस टुकड़े पर ठोकर खाई है:

class SongList
  def [](key)
    if key.kind_of?(Integer)
      return @songs[key]
    else
      for i in [email protected]
        return @songs[i] if key == @songs[i].name
      end
    end
    return nil
  end
end

मुझे समझ में नहीं आ रहा है कि [] विधि कैसे परिभाषित करती है?

[] के बाहर कुंजी क्यों है, लेकिन जब विधि को बुलाया जाता है, तो यह अंदर होता है []?

क्या कोष्ठक के बिना कुंजी हो सकती है?

मुझे लगता है कि इसे लिखने के लिए और भी बेहतर तरीके हैं, और जानिए कि कैसे काम करने वाली मेरी खुद की विधि लिखना है, लेकिन यह [] विधि सिर्फ मुझे चकित करती है ... कोई भी मदद बहुत सराहना की जाती है, धन्यवाद

This question and all comments follow the "Attribution Required."

सभी उत्तर

Translate

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

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

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" 
स्रोत
Translate

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

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)
स्रोत
Translate

वर्ग कोष्ठक विधि नाम जैसे हैं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

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

स्रोत
Translate

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

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

प्रयत्न

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
स्रोत
Leave a Reply
You must be logged in to post a answer.
लेखक के बारे में