चतुर हैक जो `items.map(&:name)` को काम करता है

सरणियों पर पुनरावृति करते समय, आशुलिपि का एक टुकड़ा होता है जिसे मैं बार-बार उपयोग करते हुए पाता हूं। यह &:चाल है, उर्फ ​​"एम्परसेंड कोलन" या "प्रेट्ज़ेल कोलन"। यदि आप इससे परिचित नहीं हैं, तो यह कैसे काम करता है:

words = ["would", "you", "like", "to", "play", "a", "game?"]

# this...
words.map &:length

# ..is equivalent to this:
words.map { |w| w.length }

कुछ समय पहले तक, मैंने माना था कि &:सिंटैक्स एक ऑपरेटर था। लेकिन ऐसा नहीं है। यह एक चतुर हैक है जो ActiveSupport में शुरू हुआ और रूबी 1.8.7 में एक आधिकारिक विशेषता बन गया।

द और ऑपरेटर

और तर्क संचालन के लिए उपयोग किए जाने के अलावा, रूबी में "&" वर्ण का एक और उपयोग होता है। जब एक विधि तर्क की शुरुआत में जोड़ा जाता है, तो यह अपने ऑपरेंड पर to_proc को कॉल करता है और इसे एक ब्लॉक के रूप में पास करता है। यह एक कौर है। उदाहरण देखना बहुत आसान है:

def my_method(&block)
  block.call
end

class Greeter
  def self.to_proc
    Proc.new { "hello" }
  end
end

my_method(&Greeter) # returns "hello"

प्रतीक#to_proc

आप एक to_proc जोड़ सकते हैं प्रतीक सहित किसी भी वस्तु के लिए विधि। ठीक यही रूबी &: . की अनुमति देने के लिए करता है छोटा रास्ता। यह कुछ इस तरह दिखता है:

class Symbol
  def to_proc
    Proc.new do |item|
      item.send self
    end
  end
end

कीचड़ की तरह साफ़? महत्वपूर्ण हिस्सा है item.send(self) . स्वयं, इस मामले में प्रतीक को संदर्भित करता है।

सब को एक साथ रखना

संख्यात्मक तरीके जैसे each और map एक ब्लॉक स्वीकार करें। प्रत्येक आइटम के लिए वे ब्लॉक को कॉल करते हैं और इसे आइटम का संदर्भ देते हैं। इस मामले में ब्लॉक प्रतीक पर to_proc को कॉल करके उत्पन्न होता है।

# &:name evaluates to a Proc, which does item.send(:name)
items.map(&:name)

इसके बारे में दिलचस्प बात यह है कि map पता नहीं इसमें से कुछ भी हो रहा है! अधिकांश काम :name . द्वारा किया जा रहा है चिन्ह, प्रतीक। यह निश्चित रूप से चतुर है ... मेरे स्वाद के लिए लगभग बहुत चालाक है। लेकिन यह इस बिंदु पर वर्षों से रूबी की मानक पुस्तकालय का हिस्सा रहा है, और यह इतना आसान है कि मुझे संदेह है कि मैं इसे अभी उपयोग करना बंद कर दूंगा। :)