Безумие метакласса Ruby

Определить одноэлементный метод динамически просто, если вы используете instance_eval :

Example.instance_eval{ def square(n); n*n; end }
Example.square(2) #=> 4
# you can pass instance_eval a string as well.
Example.instance_eval "def multiply(x,y); x*y; end" 
Example.multiply(3,9) #=> 27

Что касается разницы выше, вы путаете две вещи :

Определенный вами мета-класс - это то, что в сообществе Ruby называется классом сингелтона или собственным классом . Этот одноэлементный класс - это класс, к которому вы можете добавлять методы класса (одноэлементного).

Что касается экземпляра класса, который вы пытаетесь определить с помощью метода class_instance , это не что иное, как сам класс, чтобы доказать это, просто попробуйте добавить метод экземпляра к классу Пример и проверьте, возвращает ли определенный вами метод class_instance сам класс Example , проверив существование этого метода:

class Example
  def self.meta; (class << self; self; end); end
  def self.class_instance; self; end
  def hey; puts hey; end
end

Example.class_instance.instance_methods(false) #=> ['hey']

В любом случае, чтобы суммировать его для вас, когда вы хотите добавить методы класса, просто добавьте их в этот мета-класс. Поскольку метод class_instance бесполезен, просто удалите его.

В любом случае, я предлагаю вам прочитать этот пост , чтобы понять некоторые концепции системы отражения Ruby.

ОБНОВЛЕНИЕ

Предлагаю вам прочитать этот хороший пост: Развлечение с Ruby instance_eval и class_eval , К сожалению, class_eval и instance_eval являются сбивает с толку, потому что они каким-то образом работают против их именования!

Use ClassName.instance_eval to define class methods.

Use ClassName.class_eval to define instance methods.

Теперь отвечу на ваши предположения:

Если у меня есть метод экземпляра, который вызывает self.instance_eval и определяет метод , это повлияет только на конкретный экземпляр этот класс.

да:

class Foo
  def assumption1()
    self.instance_eval("def test_assumption_1; puts 'works'; end")
  end
end

f1 = Foo.new
f1.assumption1
f1.methods(false) #=> ["test_assumption_1"]
f2 = Foo.new.methods(false) #=> []

Если у меня есть метод экземпляра, который вызывает self.class.instance_eval (который будет таким же, как вызов class_eval) и определяет метод он повлияет на все экземпляры этого конкретного класса, в результате чего будет создан новый метод экземпляра .

no instance_eval в этом контексте будет определять одноэлементные методы (не экземпляры) для самого класса:

class Foo
  def assumption2()
    self.class.instance_eval("def test_assumption_2; puts 'works'; end")
  end
end

f3 = Foo.new
f3.assumption2
f3.methods(false) #=> []
Foo.singleton_methods(false) #=> ["test_assumption_2"]

Чтобы это работало, замените instance_eval на class_eval ] выше.

Если у меня есть метод класса, который вызывает instance_eval и определяет метод, он приведет к созданию нового метода экземпляра для всех экземпляров.

Нет:

class Foo
  instance_eval do
    def assumption3()
      puts 'works'
    end
  end
end

Foo.instance_methods(false) #=> []

Foo.singleton_methods(false) #=> ["assumption_3"]

Это будет делать одноэлементные методы, а не методы экземпляра. Чтобы это работало, замените instance_eval на class_eval выше.

Если у меня есть метод класса, который вызывает instance_eval в мета / собственном классе и определяет метод, это приведет к методу класса.

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