Ruby Language
Implizite Empfänger und Selbstverstehen

Es gibt immer einen impliziten Empfänger

In Ruby gibt es immer einen impliziten Empfänger für alle Methodenaufrufe. Die Sprache behält einen Verweis auf den aktuellen impliziten Empfänger, der in der Variablen self gespeichert ist. Bestimmte Sprachschlüsselwörter wie class und module ändern, worauf das self verweist. Das Verständnis dieser Verhaltensweisen ist sehr hilfreich, um die Sprache zu beherrschen.

Zum Beispiel beim ersten Öffnen von irb

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

In diesem Fall ist der main ist Aufgabe der implizite Empfänger (siehe http://stackoverflow.com/a/917842/417872 für mehr über main ).

Sie können Methoden auf dem impliziten Empfänger mit dem Schlüsselwort def . Zum Beispiel:

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"

Dadurch wurde die Methode foo für die Instanz des Hauptobjekts definiert, die in Ihrer Replik ausgeführt wird.

Beachten Sie, dass lokale Variablen vor den Methodennamen gesucht werden. Wenn Sie also eine lokale Variable mit demselben Namen definieren, ersetzt deren Referenz die Methodenreferenz. Fortsetzung vom vorherigen Beispiel:

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>

Die method method kann die Methode foo immer noch finden, da sie nicht auf lokale Variablen prüft, während das normale Referenzobjekt foo tut.

Schlüsselwörter ändern den impliziten Empfänger

Wenn Sie eine Klasse oder ein Modul definieren, wird der implizite Empfänger eine Referenz auf die Klasse selbst. Zum Beispiel:

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

Die Ausführung des obigen Codes wird gedruckt:

"I am main"
"I am Example"

Wann selbst verwenden?

Der meiste Ruby-Code verwendet den impliziten Empfänger, so dass Programmierer, die neu in Ruby sind, oft verwirrt sind, wann sie sich self . Die praktische Antwort ist, dass das self auf zwei Arten verwendet wird:

1. Um den Empfänger zu wechseln.

Normalerweise besteht das Verhalten von def innerhalb einer Klasse oder eines Moduls darin, Instanzmethoden zu erstellen. Self kann stattdessen verwendet werden, um Methoden für die Klasse zu definieren.

class Foo
  def bar
    1
  end

  def self.bar
    2
  end
end

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

2. Um den Empfänger zu disambiguieren

Wenn lokale Variablen den gleichen Namen wie eine Methode haben, muss möglicherweise ein expliziter Empfänger disambiguiert werden.

Beispiele:

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

Der andere übliche Fall, der Disambiguierung erfordert, umfasst Methoden, die auf das Gleichheitszeichen enden. Zum Beispiel:

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