रूबी में सिंटैक्टिक शुगर में महारत: पठनीयता और दक्षता बढ़ाएं

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

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

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

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

puts "Hello!" if (true) # वैकल्पिक पैरेंथेसिस के साथ
puts "Hello!" if true # पैरेंथेसिस के बिना

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

def greeting name # पैरेंथेसिस छोड़े गए
  "Hello #{name}!"
end
greeting("Robin") # पैरेंथेसिस के साथ
greeting "Robin" # पैरेंथेसिस के बिना
greeting"Robin" # पैरेंथेसिस और स्पेस के बिना

आखिरी लाइन पढ़ने में कठिन है, लेकिन यह काम करती है। मेथड कॉल करते समय भी पैरेंथेसिस और स्पेस वैकल्पिक हैं।

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

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

# पिछली मेथड परिभाषा:
# def name=(value)
#   @name = "Awesome #{value}"
# end
person.name = "Jane"
person.name="Jane"
person.name=("Jane") # यह मेथड परिभाषा की तरह दिखता है!

अब हमने 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)
# या यहां तक कि:
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"। ऐपसिग्नल जेम में हम इसे स्वयं Config क्लास पर कॉन्फ़िगरेशन लाने के लिए शॉर्टहैंड के रूप में उपयोग करते हैं।

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