Класс << Собственная идиома в Ruby

Question

Что делает class << self в Ruby?

Answer 1

Во-первых, синтаксис class << foo открывает одноэлементный класс foo (собственный класс). Это позволяет вам специализировать поведение методов, вызываемых для этого конкретного объекта.

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

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

---

Теперь, чтобы ответить на вопрос: class << self открывает одноэлементный класс self, так что методы могут быть переопределены для текущего self объекта (который внутри тела класса или модуля является классом или модулем *). 1010 * сама ). Обычно это используется для определения методов класса / модуля («статических»):

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

String.value_of 42   # => "42"

Это также можно записать как сокращение:

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

Или еще короче:

def String.value_of obj
  obj.to_s
end

---

Когда внутри определения функции, self относится к объекту, с которым вызывается функция. В этом случае class << self открывает одноэлементный класс для этого объекта; Одно из применений этого - реализовать конечный автомат бедного человека:

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

Итак, в приведенном выше примере каждый экземпляр StateMachineExample имеет process_hook с псевдонимом process_state_1, но обратите внимание, что в последнем он может переопределить process_hook (только для self, не затрагивая другие * От 1032 * экземпляров) до process_state_2. Таким образом, каждый раз, когда вызывающий абонент вызывает метод process (который вызывает переопределяемый process_hook), поведение меняется в зависимости от того, в каком состоянии он находится.

Answer 2

В этом блоге .

я нашел супер простое объяснение class << self, Eigenclass и другого типа methods.

В Ruby есть три типа методов, которые можно применять к классу:

1. Методы экземпляра
2. Одиночные методы
3. Методы класса

Методы экземпляра и методы класса почти аналогичны их одноименным в других языках программирования.

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

Другой способ доступа к Eigenclass (который включает в себя одноэлементные методы) заключается в следующем синтаксисе (class <<):

foo = Foo.new

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

теперь вы можете определить одноэлементный метод для self, который сам является классом Foo в этом контексте:

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

Answer 3

Обычно методы экземпляра являются глобальными методами. Это означает, что они доступны во всех экземплярах класса, в котором они были определены. Напротив, одноэлементный метод реализован на одном объекте.

Ruby хранит методы в классах, и все методы должны быть связаны с классом. Объект, для которого определен одноэлементный метод, не является классом (это экземпляр класса). Если только классы могут хранить методы, как объект может хранить одноэлементный метод? При создании одноэлементного метода Ruby автоматически создает анонимный класс для хранения этого метода. Эти анонимные классы называются метаклассами, также известными как одноэлементные классы или собственные классы. Метод singleton связан с метаклассом, который, в свою очередь, связан с объектом, для которого был определен метод singleton.

Если в одном объекте определены несколько одноэлементных методов, все они хранятся в одном метаклассе.

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

В вышеприведенном примере класс << z1 изменяет текущее «я» так, чтобы оно указывало на метакласс объекта z1; затем он определяет метод say_hello в метаклассе. </p>

Классы также являются объектами (экземплярами встроенного класса под названием Class). Методы класса - это не более чем одноэлементные методы, связанные с объектом класса.

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

Все объекты могут иметь метаклассы. Это означает, что у классов также могут быть метаклассы. В приведенном выше примере class << self изменяет self, поэтому оно указывает на метакласс класса Zabuton. Когда метод определен без явного получателя (класс / объект, для которого будет определен метод), он неявно определяется в текущей области, то есть в текущем значении себя. Следовательно, метод stuff определен в метаклассе класса Zabuton. Приведенный выше пример является еще одним способом определения метода класса. ИМХО, лучше использовать синтаксис def self.my_new_clas_method для определения методов класса, поскольку это облегчает понимание кода. Приведенный выше пример был включен, чтобы мы понимали, что происходит, когда сталкиваемся с классом << self синтаксис. </p>

Дополнительную информацию можно найти на этом посте о Ruby Classes .

Answer 4

Что делает класс << вещь: </h3> class Hi self #=> Hi class << self #same as 'class << Hi' self #=> #<Class:Hi> self == Hi.singleton_class #=> true end end [делает self == thing.singleton_class в контексте своего блока] . Что такое 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 объект наследует свой #methods от своего #singleton_class.instance_methods, а затем от #class.instance_methods.
Здесь мы дали hi синглтон-класс метод экземпляра :a. Это можно было сделать с помощью class << hi </strong>.
У hi #singleton_class есть все методы экземпляра, которые есть у hi #class, и, возможно, еще несколько (:a здесь).

[экземпляры методов вещей #class и #singleton_class могут быть применены непосредственно к вещи. когда ruby ​​видит thing.a, он сначала ищет: определение метода в thing.singleton_class.instance_methods, а затем в thing.class.instance_methods]

---

Кстати, они называют синглтон-класс объекта == метакласс == собственный класс .

Answer 5

А одноэлементный метод - это метод, который определен только для одного объекта.

Пример:

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

Синглтон-методы SomeClass

тест

---

Методы одиночного теста test_obj

test_2

test_3

Answer 6

На самом деле, если вы пишете какие-либо расширения C для своих проектов Ruby, на самом деле есть только один способ определить метод Module.

rb_define_singleton_method

Я знаю, что этот собственный бизнес просто открывает всевозможные другие вопросы, чтобы вы могли добиться большего успеха, просматривая каждую часть.

Сначала объекты.

foo = Object.new

Могу ли я создать метод для foo?

Sure

def foo.hello
 'hello'
end

Что мне с этим делать?

foo.hello
 ==>"hello"

Просто еще один объект.

foo.methods

Вы получаете все методы Object плюс ваш новый.

def foo.self
 self
end

foo.self

Только объект foo.

Попробуйте посмотреть, что произойдет, если вы создадите foo из других объектов, таких как класс и модуль. С примерами из всех ответов приятно играть, но вам нужно работать с разными идеями или концепциями, чтобы действительно понять, что происходит с тем, как написан код. Так что теперь у вас есть много терминов, чтобы посмотреть.

Singleton, Учебный класс, Модуль, самостоятельно, Объект, и Eigenclass был воспитан, но Ruby не называет объектные модели таким образом. Это больше похоже на метакласс. Ричард или __ почему показывает вам идею здесь. http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html И если вас унесет, попробуйте поискать Ruby Object Model в поиске. Два видео, которые я знаю на YouTube, это Дейв Томас и Питер Купер. Они тоже пытаются объяснить эту концепцию. Дэйву понадобилось много времени, чтобы получить его, так что не волнуйтесь. Я все еще работаю над этим тоже. Зачем еще я буду здесь? Спасибо за ваш вопрос. Также взгляните на стандартную библиотеку. Он имеет одноэлементный модуль, точно так же, как FYI.

Это довольно хорошо. https://www.youtube.com/watch?v=i4uiyWA8eFk