रूबी में सिंटेक्टिक चीनी विधियां

रूबी मैजिक के एक नए लेख में आपका स्वागत है! इस कड़ी में, हम देखेंगे कि रूबी कैसे सिंटैक्टिक शुगर का उपयोग करती है इसके कुछ वाक्य रचना को अधिक अभिव्यंजक, या पढ़ने में आसान बनाने के लिए। अंत में, हम जानेंगे कि रूबी की कुछ तरकीबें हुड के नीचे कैसे काम करती हैं और अपनी खुद की विधियों को कैसे लिखना है जो इस चीनी का थोड़ा सा उपयोग करते हैं।

रूबी ऐप्स लिखते समय वर्ग विशेषताओं, सरणी और हैश के साथ बातचीत करना आम बात है जो गैर-मानक महसूस कर सकता है। हम ऐरे या हैश से एट्रिब्यूट असाइन करने और मान लाने के तरीकों को कैसे परिभाषित करेंगे?

रूबी इन विधियों को कॉल करते समय काम करने के लिए थोड़ी सी वाक्यात्मक चीनी प्रदान करती है। इस पोस्ट में हम जानेंगे कि यह कैसे काम करता है।

person1 = Person.new
person1.name = "John"
 
array = [:foo, :bar]
array[1]  # => :bar
 
hash = { :key => :foo }
hash[:key] # => :foo
hash[:key] = :value

सिंटेक्टिक शुगर?

सिंटेक्टिक शुगर थोड़ा सा मैजिक रूबी आपको लिखित रूप में पढ़ने में आसान और अधिक संक्षिप्त कोड प्रदान करता है। रूबी में इसका अर्थ है कुछ प्रतीकों, रिक्त स्थान को छोड़ना या किसी प्रकार के सहायक के साथ कुछ अभिव्यक्ति लिखना।

विधि नाम

आइए विधि नामों से शुरू करें। रूबी में, हम विधि नामों के लिए सभी प्रकार के वर्णों और विशेष प्रतीकों का उपयोग कर सकते हैं जो आमतौर पर अन्य भाषाओं में समर्थित नहीं होते हैं। यदि आपने कभी रेल ऐप लिखा है तो आपने शायद save! . का सामना किया हो तरीका। यह रेल के लिए कुछ विशिष्ट नहीं है, लेकिन यह ! . के लिए समर्थन प्रदर्शित करता है रूबी विधि नामों में वर्ण।

वही अन्य प्रतीकों पर लागू होता है जैसे = , [ , ] , ? , % , & , | , < , > , * , - , + और / ।

इन वर्णों के समर्थन का मतलब है कि हम उन्हें अपने तरीके के नामों में शामिल कर सकते हैं ताकि वे इस बारे में अधिक स्पष्ट हो सकें कि वे किस लिए हैं:

• एट्रिब्यूट असाइन करना:person.name = "foo"
• प्रश्न पूछें:person.alive?
• खतरनाक तरीकों को कॉल करें:car.destroy!
• वस्तुओं को कुछ ऐसा बनाना जो वे नहीं हैं:car[:wheels]

विशेषता विधियों को परिभाषित करना

attr_accessor . के साथ एक वर्ग पर एक विशेषता को परिभाषित करते समय , रूबी कक्षा में एक आवृत्ति चर के लिए एक पाठक और एक लेखक विधि बनाता है।

class Person
  attr_accessor :name
end
 
person = Person.new
person.name = "John"
person.name # => "John"

हुड के तहत, रूबी दो तरीके बनाती है:

• Person#name attr_reader . का उपयोग करके कक्षा में विशेषता/आवृत्ति चर पढ़ने के लिए , और;
• Person#name= attr_writer . का उपयोग करके क्लास पर एट्रिब्यूट/इंस्टेंस वेरिएबल लिखने के लिए ।

अब मान लें कि हम इस व्यवहार को अनुकूलित करना चाहते हैं। हम attr_accessor . का उपयोग नहीं करेंगे सहायक और विधियों को स्वयं परिभाषित करें।

class AwesomePerson
  def name
    "Person name: #{@name}"
  end
 
  def name=(value)
    @name = "Awesome #{value}"
  end
end
 
person = AwesomePerson.new
person.name = "Jane"
person.name # => "Person name: Awesome Jane"

name= . के लिए विधि परिभाषा person.name = "Jane" . विधि को कॉल करते समय आप इसे लगभग उसी तरह लिखेंगे जैसे आप इसे लिखेंगे . हम बराबर चिह्न = . के आस-पास के रिक्त स्थान को परिभाषित नहीं करते हैं और विधि को कॉल करते समय कोष्ठक का प्रयोग न करें।

वैकल्पिक कोष्ठक और रिक्त स्थान

आपने देखा होगा कि रूबी कोष्ठक में बहुत बार वैकल्पिक होते हैं। किसी विधि के लिए तर्क पारित करते समय, हमें तर्क को कोष्ठकों में लपेटने की आवश्यकता नहीं होती है () , लेकिन अगर इसे पढ़ना आसान हो तो हम कर सकते हैं।

if-statement एक अच्छा उदाहरण है। कई भाषाओं में आप अभिव्यक्ति को लपेटते हैं if-statement कोष्ठक के साथ मूल्यांकन करता है। रूबी में, उन्हें छोड़ा जा सकता है।

puts "Hello!" if (true) # With optional parentheses
puts "Hello!" if true   # Without parentheses

वही विधि परिभाषाओं और अन्य अभिव्यक्तियों पर लागू होता है।

def greeting name # Parentheses omitted
  "Hello #{name}!"
end
 
greeting("Robin") # With parentheses
greeting "Robin"  # Without parentheses
greeting"Robin"   # Without parentheses and spaces

अंतिम पंक्ति को पढ़ना मुश्किल है, लेकिन यह काम करती है। कॉल करने के तरीकों में भी कोष्ठक और रिक्त स्थान वैकल्पिक हैं।

बस सावधान रहें कि हर कोष्ठक और स्थान को न छोड़ें, इनमें से कुछ रूबी को यह समझने में मदद करते हैं कि आपका क्या मतलब है! जब संदेह हो, तो अपने तर्कों को कोष्ठकों में लपेटें ताकि आप और रूबी जान सकें कि कौन से तर्क किस विधि कॉल से संबंधित हैं।

विधि को कॉल करने के निम्नलिखित सभी तरीके समर्थित हैं, लेकिन हम आमतौर पर कोष्ठकों को छोड़ देते हैं और कोड को थोड़ा अधिक पठनीय बनाने के लिए रिक्त स्थान जोड़ते हैं।

# Previous method definition:
# def name=(value)
#   @name = "Awesome #{value}"
# end
 
person.name = "Jane"
person.name="Jane"
person.name=("Jane") # That looks a lot like the method definition!

अब हमने name . के लिए कस्टम एट्रिब्यूट रीडर और राइटर विधियों को परिभाषित किया है विशेषता। हम आवश्यकतानुसार व्यवहार को अनुकूलित कर सकते हैं और कॉलबैक का उपयोग करने के बजाय विशेषता निर्दिष्ट करते समय सीधे मूल्य पर परिवर्तन कर सकते हैं।

[ ] को परिभाषित करना तरीके

अगली चीज़ जो हम देखेंगे वो हैं वर्गाकार कोष्ठक विधियाँ [ ] रूबी में। ये आमतौर पर ऐरे इंडेक्स और हैश कुंजियों को मान लाने और असाइन करने के लिए उपयोग किए जाते हैं।

hash = { :foo => :bar, :abc => :def }
hash[:foo]        # => :bar
hash[:foo] = :baz # => :baz
 
array = [:foo, :bar]
array[1] # => :bar

आइए देखें कि इन विधियों को कैसे परिभाषित किया जाता है। कॉल करते समय hash[:foo] हम उस काम को करने के लिए कुछ रूबी सिंटैक्टिक चीनी का उपयोग कर रहे हैं। इसे लिखने का दूसरा तरीका है:

hash = { :foo => :bar }
hash.[](:foo)
hash.[]=(:foo, :baz)
# or even:
hash.send(:[], :foo)
hash.send(:[]=, :foo, :baz)

जिस तरह से हम इसे सामान्य रूप से लिखते हैं उसकी तुलना में (hash[:foo] और hash[:foo] = :baz ) हम पहले से ही कुछ अंतर देख सकते हैं। पहले उदाहरण में (hash.[](:foo) ) रूबी वर्ग कोष्ठक (hash[:foo] . के बीच पहले तर्क को स्थानांतरित करती है ) कॉल करते समय hash.[]=(:foo, :baz) दूसरा तर्क विधि को मान hash[:foo] = :baz के रूप में पास किया जाता है ।

यह जानने के बाद, अब हम अपने [ ] . को परिभाषित कर सकते हैं और [ ]= जिस तरह से रूबी इसे समझ पाएगी।

class MyHash
  def initialize
    @internal_hash = {}
  end
 
  def [](key)
    @internal_hash[key]
  end
 
  def []=(key, value)
    @internal_hash[key] = value
  end
end

अब जब हम जानते हैं कि ये विधियाँ सामान्य रूबी विधियाँ हैं, तो हम उन पर किसी अन्य विधि की तरह ही तर्क लागू कर सकते हैं। हम इसे अजीब चीजें भी कर सकते हैं जैसे [ ] . में एकाधिक कुंजियों को अनुमति दें विधि।

class MyHash
  def initialize
    @internal_hash = { :foo => :bar, :abc => :def }
  end
 
  def [](*keys)
    @internal_hash.values_at(*keys)
  end
end
 
hash = MyHash.new
hash[:foo, :abc] # => [:bar, :def]

अपना खुद का बनाएं

अब जब हम रूबी की वाक्यात्मक चीनी के बारे में कुछ जानते हैं, तो हम इस ज्ञान को कस्टम लेखकों, हैश-जैसी कक्षाओं और अधिक जैसे अपने तरीके बनाने के लिए लागू कर सकते हैं।

आपको आश्चर्य हो सकता है कि कितने रत्न वर्ग कोष्ठक विधियों जैसे तरीकों को परिभाषित करते हैं ताकि कुछ ऐसा महसूस किया जा सके जैसे कि ऐरे या हैश वास्तव में नहीं है। एक उदाहरण रेल एप्लिकेशन में फ्लैश संदेश सेट कर रहा है:
flash[:alert] = "An error occurred" . AppSignal रत्न में हम इसका उपयोग स्वयं Config . पर करते हैं वर्ग विन्यास लाने के लिए एक आशुलिपि के रूप में।

यह रूबी में विधि परिभाषा और कॉलिंग के लिए वाक्यात्मक चीनी पर हमारे संक्षिप्त रूप को समाप्त करता है। हमें यह जानना अच्छा लगेगा कि आपको यह लेख कैसा लगा, यदि इसके बारे में आपके कोई प्रश्न हैं, और आप आगे क्या पढ़ना चाहते हैं, तो हमें @AppSignal पर बताना सुनिश्चित करें।