Ruby Language
Récepteurs implicites et compréhension de soi

Il y a toujours un récepteur implicite

Dans Ruby, il y a toujours un récepteur implicite pour tous les appels de méthode. Le langage garde une référence au récepteur implicite actuel stocké dans la variable self . Certains mots-clés de langage tels que class et module changeront ce que le self indique. Comprendre ces comportements est très utile pour maîtriser la langue.

Par exemple, lorsque vous ouvrez irb première fois

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

Dans ce cas, l'objet main est le récepteur implicite (voir http://stackoverflow.com/a/917842/417872 pour plus d'informations sur main ).

Vous pouvez définir des méthodes sur le récepteur implicite en utilisant le mot-clé def . Par exemple:

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"

Cela a défini la méthode foo sur l'instance de l'objet principal s'exécutant dans votre repl.

Notez que les variables locales sont recherchées avant les noms de méthode, de sorte que si vous définissez une variable locale avec le même nom, sa référence remplacera la référence de méthode. Suite de l'exemple précédent:

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>

La method méthode peut toujours trouver la méthode foo car elle ne vérifie pas les variables locales, alors que la référence normale foo fait.

Les mots clés changent le récepteur implicite

Lorsque vous définissez une classe ou un module, le récepteur implicite devient une référence à la classe elle-même. Par exemple:

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

L'exécution du code ci-dessus imprimera:

"I am main"
"I am Example"

Quand utiliser soi-même?

La plupart du code Ruby utilise le récepteur implicite, donc les programmeurs qui sont nouveaux à Ruby sont souvent confus au sujet de quand utiliser self - self . La réponse pratique est que le self est utilisé de deux manières principales:

1. Pour changer le récepteur.

Habituellement, le comportement de def dans une classe ou un module consiste à créer des méthodes d'instance. Self peut être utilisé pour définir des méthodes sur la classe à la place.

class Foo
  def bar
    1
  end

  def self.bar
    2
  end
end

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

2. Désambiguïser le récepteur

Lorsque les variables locales peuvent avoir le même nom qu'une méthode, un récepteur explicite peut être amené à désambiguïser.

Exemples:

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

L'autre cas courant nécessitant la désambiguïsation implique des méthodes qui aboutissent au signe égal. Par exemple:

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