classe << auto idiome en Ruby

Qu’est-ce que la class << self do fait en Ruby?

Tout d’abord, la syntaxe de la class < < foo ouvre la classe singleton de foo (classe propre). Cela vous permet de spécialiser le comportement des méthodes appelées sur cet object spécifique.

 a = 'foo' class < < a def inspect '"bar"' end end a.inspect # => "bar" a = 'foo' # new object, new singleton class a.inspect # => "foo" 

Maintenant, pour répondre à la question: class < < self ouvre la classe singleton de self , de sorte que les méthodes peuvent être redéfinies pour l'object self actuel (qui à l'intérieur d'une classe ou d'un corps de module est la classe ou le module lui-même ). Habituellement, cela est utilisé pour définir les méthodes class / module ("static"):

 class Ssortingng class < < self def value_of obj obj.to_s end end end String.value_of 42 # => "42" 

Cela peut aussi être écrit comme un raccourci:

 class Ssortingng def self.value_of obj obj.to_s end end 

Ou même plus court:

 def Ssortingng.value_of obj obj.to_s end 

Dans une définition de fonction, self fait référence à l'object avec lequel la fonction est appelée. Dans ce cas, class < < self ouvre la classe singleton pour cet object; une utilisation de cela est de mettre en œuvre la machine d'état d'un pauvre homme:

 class StateMachineExample def process obj process_hook obj end private def process_state_1 obj # ... class < < self alias process_hook process_state_2 end end def process_state_2 obj # ... class << self alias process_hook process_state_1 end end # Set up initial state alias process_hook process_state_1 end 

Ainsi, dans l'exemple ci-dessus, chaque instance de StateMachineExample a alias process_hook sur process_state_1 , mais notez que dans cette dernière, elle peut redéfinir process_hook (pour self seul, sans affecter les autres instances StateMachineExample ) en process_state_2 . Ainsi, chaque fois qu'un appelant appelle la méthode process (qui appelle le processus_hook redéfinissable), le comportement change en fonction de l'état dans lequel il se trouve.

J’ai trouvé une explication très simple sur la class < < self , Eigenclass et différents types de methods dans ce blog .

Dans Ruby, il existe trois types de méthodes pouvant être appliquées à une classe:

  1. Méthodes d'instance
  2. Méthodes Singleton
  3. Méthodes de classe

Les méthodes d'instance et les méthodes de classe sont presque similaires à leurs homonymes dans d'autres langages de programmation.

 class Foo def an_instance_method puts "I am an instance method" end def self.a_class_method puts "I am a class method" end end foo = Foo.new def foo.a_singleton_method puts "I am a singletone method" end 

Une autre façon d'accéder à une Eigenclass (qui inclut les méthodes singleton) consiste à utiliser la syntaxe suivante ( class < < ):

 foo = Foo.new class < < foo def a_singleton_method puts "I am a singleton method" end end 

maintenant vous pouvez définir une méthode singleton pour self qui est la classe Foo elle-même dans ce contexte:

 class Foo class < < self def a_singleton_and_class_method puts "I am a singleton method for self and a class method for Foo" end end end 

Quelle classe < < chose fait:

 class Hi self #=> Hi class < < self #same as 'class << Hi' self #=> # self == Hi.singleton_class #=> true end end 

[cela rend self == thing.singleton_class dans le contexte de son bloc] .


Qu’est-ce que thing.singleton_class?

 hi = Ssortingng.new def hi.a end hi.class.instance_methods.include? :a #=> false hi.singleton_class.instance_methods.include? :a #=> true 

hi object hi hérite de ses #methods de ses #singleton_class.instance_methods , puis de ses #class.instance_methods .
Nous avons donné ici la méthode d’instance singleton de hi :a Cela aurait pu être fait avec class < < hi à la place.
hi #singleton_class a toutes les méthodes d ‘instance de #singleton_class hi , et peut – être plus ( :a ici).

[Les méthodes d’instance de #class et #singleton_class peuvent être appliquées directement à la chose. quand ruby ​​voit thing.a, il cherche d’abord: une définition de méthode dans thing.singleton_class.instance_methods et ensuite dans thing.class.instance_methods]


Au fait, ils appellent la classe singleton de l’object == métaclasse == classe propre .

Les méthodes d’instance sont généralement des méthodes globales. Cela signifie qu’ils sont disponibles dans toutes les instances de la classe sur laquelle ils ont été définis. En revanche, une méthode singleton est implémentée sur un seul object.

Ruby stocke les méthodes dans les classes et toutes les méthodes doivent être associées à une classe. L’object sur lequel une méthode singleton est définie n’est pas une classe (c’est une instance d’une classe). Si seules les classes peuvent stocker des méthodes, comment un object peut-il stocker une méthode singleton? Lorsqu’une méthode singleton est créée, Ruby crée automatiquement une classe anonyme pour stocker cette méthode. Ces classes anonymes sont appelées métaclasses, également appelées classes singleton ou classes propres. La méthode singleton est associée à la métaclasse, elle-même associée à l’object sur lequel la méthode singleton a été définie.

Si plusieurs méthodes singleton sont définies dans un seul object, elles sont toutes stockées dans la même métaclasse.

 class Zen end z1 = Zen.new z2 = Zen.new class < < z1 def say_hello puts "Hello!" end end z1.say_hello # Output: Hello! z2.say_hello # Output: NoMethodError: undefined method `say_hello'… 

Dans l'exemple ci-dessus, la classe < < z1 modifie le self actuel pour pointer sur la métaclasse de l'objet z1; alors, il définit la méthode say_hello dans la métaclasse.

Les classes sont également des objects (instances de la classe intégrée appelée Class). Les méthodes de classe ne sont rien de plus que des méthodes singleton associées à un object de classe.

 class Zabuton class < < self def stuff puts "Stuffing zabuton…" end end end 

Tous les objects peuvent avoir des métaclasses. Cela signifie que les classes peuvent aussi avoir des métaclasses. Dans l'exemple ci-dessus, la classe < < self modifie soi-même afin qu'elle pointe vers la métaclasse de la classe Zabuton. Lorsqu'une méthode est définie sans récepteur explicite (la classe / l'objet sur lequel la méthode sera définie), elle est implicitement définie dans la portée actuelle, c'est-à-dire la valeur actuelle de self. Par conséquent, la méthode stuff est définie dans la métaclasse de la classe Zabuton. L'exemple ci-dessus n'est qu'un autre moyen de définir une méthode de classe. À mon humble avis, il est préférable d'utiliser la syntaxe def self.my_new_clas_method pour définir les méthodes de classe, car cela facilite la compréhension du code. L'exemple ci-dessus a été inclus afin que nous comprenions ce qui se passe lorsque nous rencontrons la classe << auto-syntaxe.

Des informations supplémentaires peuvent être trouvées à cet article sur Ruby Classes .

Une méthode singleton est une méthode qui n’est définie que pour un seul object.

Exemple:

 class SomeClass class < < self def test end end end test_obj = SomeClass.new def test_obj.test_2 end class << test_obj def test_3 end end puts "Singleton's methods of SomeClass" puts SomeClass.singleton_methods puts '------------------------------------------' puts "Singleton's methods of test_obj" puts test_obj.singleton_methods 

Méthodes Singleton de SomeClass

tester


Les méthodes de singleton de test_obj

test_2

test_3

En fait, si vous écrivez des extensions C pour vos projets Ruby, il n’ya qu’une seule façon de définir une méthode de module.

 rb_define_singleton_method 

Je sais que cette activité personnelle ouvre toutes sortes d’autres questions afin que vous puissiez faire mieux en recherchant chaque partie.

Objets en premier

 foo = Object.new 

Puis-je créer une méthode pour foo?

Sûr

 def foo.hello 'hello' end 

Qu’est-ce que je fais avec ça?

 foo.hello ==>"hello" 

Juste un autre object.

 foo.methods 

Vous obtenez toutes les méthodes Object plus votre nouvelle.

 def foo.self self end foo.self 

Juste l’object foo.

Essayez de voir ce qui se passe si vous créez un foo à partir d’autres objects tels que Class et Module. Les exemples de toutes les réponses sont agréables, mais vous devez travailler avec des idées ou des concepts différents pour vraiment comprendre ce qui se passe dans la façon dont le code est écrit. Alors maintenant, vous avez beaucoup de termes à regarder.

Singleton, Class, Module, self, Object et Eigenclass ont été ajoutés, mais Ruby ne nomme pas Object Models de cette manière. C’est plus comme Metaclass. Richard ou __why vous montre l’idée ici. http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html Et si vous vous perdez, essayez de rechercher le modèle d’object Ruby dans la recherche. Deux vidéos que je connais sur YouTube sont Dave Thomas et Peter Cooper. Ils essaient aussi d’expliquer ce concept. Il a fallu beaucoup de temps à Dave pour l’obtenir, alors ne vous inquiétez pas. J’y travaille toujours aussi. Pourquoi d’autre serais-je ici? Merci pour votre question. Consultez également la bibliothèque standard. Il a un module Singleton comme un FYI.

C’est plutôt bien. https://www.youtube.com/watch?v=i4uiyWA8eFk