classe << idiome de soi en Ruby

Qu'est - ce que class << selffaire dans Ruby ?

Premièrement, la class << foosyntaxe ouvre foola classe singleton de (classe propre). Cela vous permet de spécialiser le comportement des méthodes appelées sur cet objet 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 << selfouvre selfla classe singleton de sorte que les méthodes puissent être redéfinies pour l' selfobjet courant (qui à l'intérieur d'un corps de classe ou de module est la classe ou le module lui-même ). Habituellement, ceci est utilisé pour définir des méthodes de classe / module ("statiques"):

class String
  class << self
    def value_of obj
      obj.to_s
    end
  end
end

String.value_of 42   # => "42"

Cela peut également être écrit comme un raccourci:

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

Ou encore plus court:

def String.value_of obj
  obj.to_s
end

Dans une définition de fonction, selffait référence à l'objet avec lequel la fonction est appelée. Dans ce cas, class << selfouvre la classe singleton pour cet objet; une utilisation de cela est d'implémenter la machine d'état d'un pauvre:

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 StateMachineExamplea un process_hookalias pour process_state_1, mais notez comment dans ce dernier, elle peut redéfinir process_hook(pour selfseulement, sans affecter les autres StateMachineExampleinstances) process_state_2. Ainsi, chaque fois qu'un appelant appelle la processméthode (qui appelle la redéfinissable process_hook), le comportement change en fonction de son état.

J'ai trouvé une super explication simple à propos class << self, Eigenclasset différents types de méthodes.

Dans Ruby, il existe trois types de méthodes qui peuvent ê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 à un Eigenclass(qui inclut des méthodes singleton) est avec la syntaxe suivante ( class <<):

foo = Foo.new

class << foo
  def a_singleton_method
    puts "I am a singleton method"
  end
end

vous pouvez maintenant définir une méthode singleton pour selflaquelle est la classe Fooelle - 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

Habituellement, les méthodes d'instance sont 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 objet.

Ruby stocke les méthodes dans les classes et toutes les méthodes doivent être associées à une classe. L'objet 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 objet 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 qui, à son tour, est associée à l'objet sur lequel la méthode singleton a été définie.

Si plusieurs méthodes singleton sont définies dans un même objet, 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 vers la métaclasse de l'objet z1; ensuite, il définit la méthode say_hello dans la métaclasse.

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

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

Tous les objets peuvent avoir des métaclasses. Cela signifie que les classes peuvent également avoir des métaclasses. Dans l'exemple ci-dessus, la classe << self modifie self 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 est juste une autre façon 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 elle rend le code plus facile à comprendre. L'exemple ci-dessus a été inclus afin que nous comprenions ce qui se passe lorsque nous rencontrons la classe << self syntax.

Des informations supplémentaires peuvent être trouvées à ce poste sur les classes Ruby .

Quelle classe << chose fait:

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

[il fait self == thing.singleton_class dans le cadre de son bloc] .

Qu'est-ce que thing.singleton_class?

hi = String.new
def hi.a
end

hi.class.instance_methods.include? :a #=> false
hi.singleton_class.instance_methods.include? :a #=> true

hil'objet hérite de son #methodsde #singleton_class.instance_methodspuis de son #class.instance_methods.
Ici, nous avons donné hila méthode d'instance de classe singleton:a . Cela aurait pu être fait avec la classe << hi à la place.
hi's #singleton_classa toutes les méthodes d'instance hiest #classa, et peut - être un peu plus (:a ici).

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

Soit dit en passant - ils appellent de l' objet classe singleton == métaclasse == eigenclass .

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

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

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'y a vraiment qu'une seule façon de définir une méthode Module.

rb_define_singleton_method

Je sais que cette auto-entreprise ouvre simplement toutes sortes d'autres questions afin que vous puissiez faire mieux en recherchant chaque partie.

Objets d'abord.

foo = Object.new

Puis-je faire une méthode pour foo?

Sûr

def foo.hello
 'hello'
end

Que dois-je en faire?

foo.hello
 ==>"hello"

Juste un autre objet.

foo.methods

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

def foo.self
 self
end

foo.self

Juste l'objet foo.

Essayez de voir ce qui se passe si vous créez des objets à partir d'autres objets comme la classe et le module. Les exemples de toutes les réponses sont agréables à jouer, mais vous devez travailler avec différentes idées ou concepts pour vraiment comprendre ce qui se passe avec la façon dont le code est écrit. Alors maintenant, vous avez beaucoup de termes à examiner.

Singleton, Class, Module, self, Object et Eigenclass ont été évoqués mais Ruby ne nomme pas les modèles d'objet de cette façon. Cela ressemble plus à Metaclass. Richard ou __pourquoi vous montre l'idée ici. http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html Et si le vous épate, essayez de rechercher Ruby Object Model dans la recherche. Dave Thomas et Peter Cooper sont deux vidéos que je connais sur YouTube. Ils essaient aussi d'expliquer ce concept. Dave a mis du temps à l'obtenir, alors ne vous inquiétez pas. J'y travaille toujours aussi. Sinon, pourquoi serais-je ici? Merci pour ta question. Jetez également un œil à la bibliothèque standard. Il a un module Singleton tout comme un FYI.

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