Ruby Language
Impliciete ontvangers en zelfbegrip

Er is altijd een impliciete ontvanger

In Ruby is er altijd een impliciete ontvanger voor alle methodeaanroepen. De taal houdt een verwijzing naar de huidige impliciete ontvanger opgeslagen in de variabele self . Bepaalde taalzoekwoorden zoals class en module veranderen waar self verwijst. Inzicht in dit gedrag is zeer nuttig bij het beheersen van de taal.

Wanneer u bijvoorbeeld irb eerst opent

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

In dit geval is het main doel is de impliciete ontvanger (zie http://stackoverflow.com/a/917842/417872 meer over main ).

U kunt methoden op de impliciete ontvanger definiëren met behulp van het trefwoord def . Bijvoorbeeld:

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"

Dit heeft de methode foo gedefinieerd voor het exemplaar van het hoofdobject dat in je repl wordt uitgevoerd.

Merk op dat lokale variabelen worden opgezocht vóór de namen van de methoden, zodat als u een lokale variabele met dezelfde naam definieert, de verwijzing ervan de methode-verwijzing vervangt. Vervolg van het vorige voorbeeld:

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>

De method methode kan nog steeds de foo methode vinden omdat deze niet controleert op lokale variabelen, terwijl de normale referentie foo doet.

Sleutelwoorden veranderen de impliciete ontvanger

Wanneer u een klasse of module definieert, wordt de impliciete ontvanger een verwijzing naar de klasse zelf. Bijvoorbeeld:

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

Als u de bovenstaande code uitvoert, wordt afgedrukt:

"I am main"
"I am Example"

Wanneer zelf gebruiken?

De meeste Ruby-code maakt gebruik van de impliciete ontvanger, dus programmeurs die nieuw zijn bij Ruby zijn vaak in de war over wanneer ze self moeten gebruiken. Het praktische antwoord is dat self op twee belangrijke manieren wordt gebruikt:

1. Om de ontvanger te veranderen.

Gewoonlijk is het gedrag van def binnen een klasse of module het creëren van instantiemethoden. Zelf kan in plaats daarvan worden gebruikt om methoden voor de klasse te definiëren.

class Foo
  def bar
    1
  end

  def self.bar
    2
  end
end

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

2. Om de ontvanger ondubbelzinnig te maken

Wanneer lokale variabelen dezelfde naam kunnen hebben als een methode, kan een expliciete ontvanger nodig zijn om het ondubbelzinnig te maken.

Voorbeelden:

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

Het andere veel voorkomende geval dat ondubbelzinnigheid vereist, omvat methoden die eindigen op het isgelijkteken. Bijvoorbeeld:

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