Ruby Language
Receptores implícitos y comprensión del yo

Siempre hay un receptor implícito.

En Ruby, siempre hay un receptor implícito para todas las llamadas de método. El lenguaje mantiene una referencia al receptor implícito actual almacenado en la variable self . Ciertas palabras clave de lenguaje como class y module cambiarán a lo que apunta self . Comprender estos comportamientos es muy útil para dominar el idioma.

Por ejemplo, cuando abres por primera irb

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

En este caso, el objeto main es el receptor implícito (consulte http://stackoverflow.com/a/917842/417872 para obtener más información acerca de main ).

Puede definir métodos en el receptor implícito usando la palabra clave def . Por ejemplo:

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"

Esto ha definido el método foo en la instancia del objeto principal que se ejecuta en su respuesta.

Tenga en cuenta que las variables locales se buscan antes que los nombres de los métodos, de modo que si define una variable local con el mismo nombre, su referencia reemplazará a la referencia del método. Continuando del ejemplo anterior:

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>

El method método todavía puede encontrar el método foo porque no comprueba las variables locales, mientras que la referencia normal foo sí lo hace.

Las palabras clave cambian el receptor implícito.

Cuando define una clase o módulo, el receptor implícito se convierte en una referencia a la clase en sí. Por ejemplo:

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

Ejecutando el código anterior se imprimirá:

"I am main"
"I am Example"

¿Cuándo usar uno mismo?

La mayoría del código de Ruby utiliza el receptor implícito, por lo que los programadores que son nuevos en Ruby a menudo se confunden acerca de cuándo usar self . La respuesta práctica es que el self se usa de dos maneras principales:

1. Para cambiar el receptor.

Normalmente, el comportamiento de def dentro de una clase o módulo es crear métodos de instancia. Self se puede usar para definir métodos en la clase.

class Foo
  def bar
    1
  end

  def self.bar
    2
  end
end

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

2. Desambiguar el receptor.

Cuando las variables locales pueden tener el mismo nombre que un método, es posible que se requiera un receptor explícito para desambiguar.

Ejemplos:

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

El otro caso común que requiere desambiguación involucra métodos que terminan en el signo igual. Por ejemplo:

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