Frage Klasse << Selbstsprache in Ruby


Was macht class << self in Ruby machen?


739
2018-03-24 03:02


Ursprung


Antworten:


Zuerst die class << foo Syntax öffnet sich fooSingleton-Klasse (Eigenklasse). Dadurch können Sie das Verhalten von Methoden spezialisieren, die für dieses spezifische Objekt aufgerufen werden.

a = 'foo'
class << a
  def inspect
    '"bar"'
  end
end
a.inspect   # => "bar"

a = 'foo'   # new object, new singleton class
a.inspect   # => "foo"

Nun, um die Frage zu beantworten: class << self eröffnet selfSingleton-Klasse, so dass Methoden für die aktuelle neu definiert werden können self Objekt (das innerhalb einer Klasse oder eines Modulkörpers die Klasse oder das Modul ist) selbst). Normalerweise wird dies verwendet, um Klassen / Module ("statische") Methoden zu definieren:

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

String.value_of 42   # => "42"

Dies kann auch als Kurzschrift geschrieben werden:

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

Oder noch kürzer:

def String.value_of obj
  obj.to_s
end

Innerhalb einer Funktionsdefinition self bezieht sich auf das Objekt, mit dem die Funktion aufgerufen wird. In diesem Fall, class << self öffnet die Singleton-Klasse für dieses Objekt; Ein Nutzen davon ist, die Zustandsmaschine eines armen Mannes zu implementieren:

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

Im obigen Beispiel wird jede Instanz von StateMachineExample hat process_hook Aliasing zu process_state_1, aber beachte, wie in letzterem es neu definiert werden kann process_hook (zum self nur, nicht beeinflussen andere StateMachineExample Instanzen) zu process_state_2. Also, jedes Mal, wenn ein Anrufer anruft process Methode (die das redefinierbare aufruft process_hook), das Verhalten ändert sich je nachdem, in welchem ​​Zustand es ist.


789
2018-03-24 03:05



Ich habe eine super einfache Erklärung gefunden class << self , Eigenclass und andere Art von methods in diesem Blog.

In Ruby gibt es drei Arten von Methoden, die auf eine Klasse angewendet werden können:

  1. Instanzmethoden
  2. Singleton-Methoden
  3. Klassenmethoden

Instanzmethoden und Klassenmethoden sind ihren in anderen Programmiersprachen homonymen ähnlich.

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

Eine andere Möglichkeit, auf ein Eigenclass(die Singleton-Methoden enthält) ist mit der folgenden Syntax (class <<):

foo = Foo.new

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

Jetzt können Sie eine Singleton-Methode für definieren self Das ist die Klasse Foo selbst in diesem Zusammenhang:

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

24
2018-01-29 11:37



Was Klasse << Sache tut:

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

[es macht  self == thing.singleton_class  im Zusammenhang mit seinem Block].


Was ist 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

hi Objekt erbt sein #methods von seinem #singleton_class.instance_methods und dann von seinem #class.instance_methods.
Hier haben wir gegeben hiist es Singleton Klasse Instanzmethode :a. Es hätte damit gemacht werden können Klasse << Hallo stattdessen.
hiist es #singleton_class hat alle Instanzmethoden hiist es #class hat, und möglicherweise einige mehr (:a Hier).

[Instanz Methoden der Sache  #class  und  #singleton_class  kann direkt auf etwas angewendet werden. wenn ruby ​​ding.a sieht, sucht es zuerst nach einer Methodendefinition in ding.singleton_class.instance_methods und dann in thing.class.instance_methods]


Übrigens - sie nennen das Objekt Singleton Klasse == Metaklasse == Eigenklasse.


12
2017-11-12 14:03



Normalerweise sind Instanzmethoden globale Methoden. Das bedeutet, dass sie in allen Instanzen der Klasse verfügbar sind, für die sie definiert wurden. Im Gegensatz dazu wird eine Singleton-Methode für ein einzelnes Objekt implementiert.

Ruby speichert Methoden in Klassen und alle Methoden müssen einer Klasse zugeordnet sein. Das Objekt, für das eine Singleton-Methode definiert ist, ist keine Klasse (es ist eine Instanz einer Klasse). Wenn nur Klassen Methoden speichern können, wie kann ein Objekt eine Singleton-Methode speichern? Wenn eine Singleton-Methode erstellt wird, erstellt Ruby automatisch eine anonyme Klasse zum Speichern dieser Methode. Diese anonymen Klassen heißen Metaklassen, auch Singleton-Klassen oder Eigenklassen genannt. Die Singleton-Methode ist der Metaklasse zugeordnet, die wiederum dem Objekt zugeordnet ist, für das die Singleton-Methode definiert wurde.

Wenn mehrere Singleton-Methoden innerhalb eines einzelnen Objekts definiert sind, werden sie alle in derselben Metaklasse gespeichert.

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'…

Im obigen Beispiel ändert die Klasse << z1 das aktuelle self, um auf die Metaklasse des z1-Objekts zu zeigen. dann definiert es die say_hello-Methode innerhalb der Metaklasse.

Klassen sind auch Objekte (Instanzen der eingebauten Klasse Class). Klassenmethoden sind nichts anderes als Singleton-Methoden, die einem Klassenobjekt zugeordnet sind.

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

Alle Objekte können Metaklassen haben. Das heißt, Klassen können auch Metaklassen haben. Im obigen Beispiel ändert die Klasse << self das Selbst, so dass es auf die Metaklasse der Zabuton-Klasse zeigt. Wenn eine Methode ohne einen expliziten Empfänger (die Klasse / das Objekt, für das die Methode definiert wird) definiert wird, wird sie implizit im aktuellen Bereich definiert, dh dem aktuellen Wert von self. Daher ist die Stuff-Methode in der Metaklasse der Zabuton-Klasse definiert. Das obige Beispiel ist nur eine weitere Möglichkeit, eine Klassenmethode zu definieren. Meiner Meinung nach ist es besser, die def self.my_new_clas_method-Syntax zu verwenden, um Klassenmethoden zu definieren, da dies den Code leichter verständlich macht. Das obige Beispiel wurde aufgenommen, damit wir verstehen, was passiert, wenn wir auf die Selbstsyntax der Klasse stoßen.

Zusätzliche Informationen finden Sie unter dieser Beitrag über Ruby-Klassen.


11
2018-06-26 18:17



А Singleton-Methode ist eine Methode, die nur für ein einzelnes Objekt definiert ist.

Beispiel:

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

Singletons Methoden von SomeClass

Prüfung


Singletons Methoden von test_obj

test_2

test_3


3
2017-09-15 18:50



Wenn Sie C-Erweiterungen für Ihre Ruby-Projekte schreiben, gibt es tatsächlich nur eine Möglichkeit, eine Modul-Methode zu definieren.

rb_define_singleton_method

Ich weiß, dass dieses Selbstgeschäft nur viele andere Fragen aufwirft, so dass Sie es besser machen können, indem Sie jeden Teil durchsuchen.

Objekte zuerst.

foo = Object.new

Kann ich eine Methode für foo machen?

Sicher

def foo.hello
 'hello'
end

Was mache ich damit?

foo.hello
 ==>"hello"

Nur ein anderes Objekt.

foo.methods

Sie erhalten alle Object-Methoden und Ihre neue Methode.

def foo.self
 self
end

foo.self

Nur das foo Objekt.

Versuchen Sie zu sehen, was passiert, wenn Sie foo von anderen Objekten wie Klasse und Modul machen. Die Beispiele aus allen Antworten sind nett zu spielen, aber Sie müssen mit verschiedenen Ideen oder Konzepten arbeiten, um wirklich zu verstehen, was mit der Art und Weise geschieht, wie der Code geschrieben wird. So, jetzt haben Sie viele Begriffe zu sehen.

Singleton, Klasse, Modul, selbst, Objekt, und Eigenklasse wurde erzogen, aber Ruby nennt Objektmodelle nicht auf diese Weise. Es ist mehr wie Metaklasse. Richard oder __why zeigt dir die Idee hier. http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html Und wenn dich das umhauen sollte, dann suche nach dem Ruby Object Model. Zwei Videos, die ich auf YouTube kenne, sind Dave Thomas und Peter Cooper. Sie versuchen, dieses Konzept auch zu erklären. Dave brauchte lange, um es zu bekommen, also mach dir keine Sorgen. Ich arbeite immer noch daran. Warum sollte ich sonst hier sein? Danke für deine Frage. Sehen Sie sich auch die Standardbibliothek an. Es hat ein Singleton-Modul nur als ein FYI.

Das ist ziemlich gut. https://www.youtube.com/watch?v=i4uiyWA8eFk


1
2018-05-08 13:29