具有类名称的动态类定义

如何在Ruby中使用名称动态定义类？

我知道如何动态地创建一个类，而不使用类似的名称：

dynamic_class = Class.new do
  def method1
  end
end

但是您不能指定类名。我想用名称动态创建一个类。

这是我要执行的操作的示例，但是它实际上并不起作用。
（请注意，我不是在创建类的实例，而是在创建类定义）

class TestEval
  def method1
    puts "name: #{self.name}"
  end
end

class_name = "TestEval"
dummy = eval("#{class_name}")

puts "dummy: #{dummy}"

dynamic_name = "TestEval2"
class_string = """
class #{dynamic_name}
  def method1
  end
end
"""
dummy2 = eval(class_string)
puts "dummy2: #{dummy2}" # doesn't work

实际输出：

dummy: TestEval
dummy2: 

所需的输出：

dummy: TestEval
dummy2: TestEval2

================================================== ====

答：使用sepp2k方法的完全动态解决方案

dynamic_name = "TestEval2"

Object.const_set(dynamic_name, Class.new) # If inheriting, use Class.new( superclass )
dummy2 = eval("#{dynamic_name}")
puts "dummy2: #{dummy2}"

类的名称只是引用它的第一个常量的名称。

即如果我这样做myclass = Class.new，MyClass = myclass班级的名字就会变成MyClass。但是，MyClass =如果直到运行时我都不知道类的名称，我就无法这样做。

因此，您可以使用Module#const_set来动态设置const的值。例：

dynamic_name = "ClassName"
Object.const_set(dynamic_name, Class.new { def method1() 42 end })
ClassName.new.method1 #=> 42

我也一直在搞这个。就我而言，我试图测试对ActiveRecord :: Base的扩展。我需要能够动态创建一个类，并且由于活动记录基于一个类名查找一个表，所以该类不能是匿名的。

我不确定这是否对您有帮助，但这是我想到的：

test_model_class = Class.new(ActiveRecord::Base) do
  def self.name
    'TestModel'
  end

  attr_accessor :foo, :bar
end

就ActiveRecord而言，定义self.name就足够了。我猜想这在类不能匿名的所有情况下都会有效。

（我刚刚阅读了sepp2k的答案，我认为他会更好。无论如何，我将其留在这里。）

我知道这是一个非常老的问题，其他一些Ruby专家可能会因此而避开我，但是我正在创建一个非常薄的包装gem，用ruby类包装一个流行的java项目。基于@ sepp2k的答案，我创建了一些辅助方法，因为我必须在一个项目中执行多次。请注意，我为这些方法命名空间，以便它们不会污染某些顶级名称空间，例如Object或Kernel。

module Redbeam
  # helper method to create thin class wrappers easily within the given namespace
  # 
  # @param  parent_klass [Class] parent class of the klasses
  # @param  klasses [Array[String, Class]] 2D array of [class, superclass]
  #   where each class is a String name of the class to create and superclass
  #   is the class the new class will inherit from
  def self.create_klasses(parent_klass, klasses)
    parent_klass.instance_eval do
      klasses.each do |klass, superklass|
        parent_klass.const_set klass, Class.new(superklass)
      end
    end
  end

  # helper method to create thin module wrappers easily within the given namespace
  # 
  # @param parent_klass [Class] parent class of the modules
  # @param modules [Array[String, Module]] 2D array of [module, supermodule]
  #   where each module is a String name of the module to create and supermodule
  #   is the module the new module will extend
  def self.create_modules(parent_klass, modules)
    parent_klass.instance_eval do
      modules.each do |new_module, supermodule|
        parent_klass.const_set new_module, Module.new { extend supermodule }
      end
    end
  end
end

要使用这些方法（请注意，这是JRuby）：

module Redbeam::Options
  Redbeam.create_klasses(self, [
    ['PipelineOptionsFactory', org.apache.beam.sdk.options.PipelineOptionsFactory]
  ])
  Redbeam.create_modules(self, [
    ['PipelineOptions', org.apache.beam.sdk.options.PipelineOptions]
  ])
end

为什么？？

这使我可以创建一个使用Java项目的JRuby gem，并允许开源社区和将来在必要时修饰这些类。它还创建了一个更友好的名称空间以使用这些类。由于我的gem是一个非常非常薄的包装器，因此我不得不创建很多子类和模块来扩展其他模块。

正如我们在JD Power所说的那样，“这是由道歉驱动的开发：很抱歉”。

下面的代码怎么样：

dynamic_name = "TestEval2"
class_string = """
class #{dynamic_name}
  def method1
  end
end
"""
eval(class_string)
dummy2 = Object.const_get(dynamic_name)
puts "dummy2: #{dummy2}"

Eval不会重新调整运行时Class对象，至少在我的PC上不会。使用Object.const_get获取Class对象。