Ruby Language
निहितार्थ और स्वयं को समझना

हमेशा एक अंतर्निहित रिसीवर होता है

रूबी में, सभी विधि कॉल के लिए हमेशा एक अंतर्निहित रिसीवर होता है। भाषा चर self में संग्रहीत वर्तमान अंतर्निहित रिसीवर के लिए एक संदर्भ रखती है। class और module जैसे कुछ विशेष भाषा कीवर्ड, जो self इंगित करते हैं, को बदल देंगे। इन व्यवहारों को समझना भाषा में महारत हासिल करने में बहुत सहायक है।

उदाहरण के लिए, जब आप पहली बार irb खोलें

irb(main):001:0> self
=> main

इस मामले में main वस्तु निहित रिसीवर है (देखें http://stackoverflow.com/a/917842/417872 main बारे में अधिक जानकारी के लिए)।

आप def कीवर्ड का उपयोग करके निहित रिसीवर पर तरीकों को परिभाषित कर सकते हैं। उदाहरण के लिए:

irb(main):001:0> def foo(arg)
irb(main):002:1> arg.to_s
irb(main):003:1> end
=> :foo
irb(main):004:0> foo 1
=> "1"

यह आपके उत्तर में चल रहे मुख्य ऑब्जेक्ट के उदाहरण पर विधि फू को परिभाषित करता है।

ध्यान दें कि स्थानीय चर को विधि नामों से पहले देखा जाता है, ताकि यदि आप उसी नाम के साथ स्थानीय चर को परिभाषित करते हैं, तो इसका संदर्भ विधि संदर्भ को उलट देगा। पिछले उदाहरण से जारी है:

irb(main):005:0> defined? foo
=> "method"
irb(main):006:0> foo = 1
=> 1
irb(main):007:0> defined? foo
=> "local-variable"
irb(main):008:0> foo
=> 1
irb(main):009:0> method :foo
=> #<Method: Object#foo>

method विधि अभी भी foo विधि पा सकती है क्योंकि यह स्थानीय चर के लिए जाँच नहीं करता है, जबकि सामान्य संदर्भ foo करता है।

कीवर्ड निहित रिसीवर को बदलते हैं

जब आप किसी वर्ग या मॉड्यूल को परिभाषित करते हैं, तो निहित रिसीवर कक्षा के लिए एक संदर्भ बन जाता है। उदाहरण के लिए:

puts "I am #{self}"
class Example
  puts "I am #{self}"
end

उपरोक्त कोड प्रिंट करने पर:

"I am main"
"I am Example"

स्वयं का उपयोग कब करें?

अधिकांश रूबी कोड निहित रिसीवर का उपयोग करता है, इसलिए प्रोग्रामर जो रूबी के लिए नए हैं, अक्सर self का उपयोग करने के बारे में भ्रमित होते हैं। व्यावहारिक उत्तर यह है कि self का उपयोग दो प्रमुख तरीकों से किया जाता है:

1. रिसीवर को बदलने के लिए।

आमतौर पर के व्यवहार def कक्षा या मॉड्यूल के अंदर उदाहरण तरीकों तैयार करना है। स्व का उपयोग इसके बजाय कक्षा पर विधियों को परिभाषित करने के लिए किया जा सकता है।

class Foo
  def bar
    1
  end

  def self.bar
    2
  end
end

Foo.new.bar #=> 1
Foo.bar #=> 2

2. रिसीवर की अवहेलना करना

जब स्थानीय चर का एक ही नाम हो सकता है, तो विधि के रूप में एक स्पष्ट रिसीवर की आवश्यकता हो सकती है।

उदाहरण:

class Example
  def foo
    1
  end

  def bar
    foo + 1
  end

  def baz(foo)
    self.foo + foo # self.foo is the method, foo is the local variable
  end

  def qux
    bar = 2
    self.bar + bar # self.bar is the method, bar is the local variable
  end 
end

Example.new.foo    #=> 1
Example.new.bar    #=> 2
Example.new.baz(2) #=> 3
Example.new.qux    #=> 4

अन्य सामान्य मामले में छूट की आवश्यकता होती है, जिसमें वे विधियाँ शामिल होती हैं जो बराबरी के चिन्ह में समाप्त होती हैं। उदाहरण के लिए:

class Example
  def foo=(input)
    @foo = input
  end

  def get_foo
    @foo
  end

  def bar(input)
    foo = input # will create a local variable
  end

  def baz(input)
    self.foo = input # will call the method
  end
end

e = Example.new
e.get_foo #=> nil
e.foo = 1
e.get_foo #=> 1
e.bar(2)
e.get_foo #=> 1
e.baz(2)
e.get_foo #=> 2