Utilisation du mot-clé Ruby Self?

Dans la plupart des cas, self.foo est effectivement redondant car vous pouvez simplement écrire foo pour le même effet, mais dans ce cas, ce n’est pas le cas et le self est requirejs.

var_one = method(args) créera une variable locale appelée var_one , elle n’appellera aucune méthode ni ne fera rien d’autre pour se self .

self.var_one = method(args) appellera la méthode var_one= on self avec la method(args) argument method(args) .

Un autre cas où l’utilisation de self n’est pas facultatif serait si vous voulez le passer en argument à une méthode, c’est-à-dire some_method(self) – vous ne pouvez pas le faire sans le mot-clé self .

Il existe plusieurs utilisations importantes, dont la plupart consistent essentiellement à désambiguïser les méthodes d’instance, les méthodes de classe et les variables.

Tout d’abord, c’est le meilleur moyen de définir des méthodes de classe. C’EST À DIRE:

 class Foo def self.bar "class method bar" end def bar "instance method bar" end end Foo.bar #returns "class method bar" foo = Foo.new foo.bar #returns "instance method bar" 

De même, dans les méthodes d’instance, self se réfère à l’instance, dans les méthodes de classe auxquelles il fait référence dans la classe, et peut toujours être utilisé pour distinguer les variables locales.

 class Bar def self.foo "foo!" end def baz "baz!" end def self.success foo #looks for variable foo, doesn't find one, looks for class method foo, finds it, returns "foo!" end def self.fail baz #looks for variable baz, doesn't find one, looks for class method baz, doesn't find one, raises exception end def instance_success baz #looks for variable baz, doesn't find one, looks for instance method baz, finds it, returns "baz!" end def instance_fail foo #looks for variable foo, doesn't find one, looks for instance method foo, doesn't find one, raises exception end def local_variable baz = "is my favorite method" baz #looks for variable baz, finds it, returns "is my favorite method" end def disambiguate baz = " is my favorite method" self.baz + baz #looks for instance method baz, finds it, looks for local variable baz, finds it, returns "baz! is my favorite method" end end 

Ainsi, au bout du compte, vous pouvez éviter de vous utiliser vous- self dans de nombreux cas, mais il est souvent utile de l’utiliser pour vous assurer de ne pas créer par inadvertance des conflits d’appellation. Parfois, ceux-ci peuvent créer des bogues très difficiles à trouver. Au final, c’est souvent une question de style personnel.

Mise à jour: Comme noté dans les commentaires, une autre chose vraiment importante:

Dans une classe, si vous avez une méthode comme celle-ci:

 def bar=(ssortingng) ... end 

Et dans une autre méthode, vous appelez:

 def other_method bar = "abcd" end 

Il ne va pas appeler votre méthode bar =, cela va créer une barre de variables locale. Donc, dans ce cas, vous utilisez self pour dire à Ruby de ne pas créer de variable locale, comme ceci:

 def other_method self.bar = "abcd" end 

La même chose s’applique si vous voulez prendre un argument avec le nom d’une méthode, comme ceci:

 def example ... end def other_thing(example) self.example(example) end 

Si vous vous perdiez, cela supposerait que vous vouliez dire la variable locale du même nom.

Donc, en général, les noms de méthode self in sont utilisés pour distinguer les variables de classe et d’instance, et partout où vous l’utilisez lorsque Ruby a besoin d’aide pour distinguer les appels de méthode et les variables locales ou les affectations de variables locales.

J’espère que cela à du sens!

voici un exemple d’utilisation:

 def run miles self.miles = miles end 

Dans ce cas, le moi aidera. dans la plupart des cas, l’autonomie est redondante.

Une autre utilisation de self est de déclarer des méthodes de classe (similaires aux méthodes statiques en Java).

 class foo def self.bar #do class related stuff here end end 

Cela étant dit, vous pourriez aussi avoir utilisé def foo.bar place de la signature de la méthode.