ruby - 在 Ruby 中为类添加实例变量

Question

如何在运行时将实例变量添加到定义的类，然后从类外部获取和设置其值？

我正在寻找一种元编程解决方案，它允许我在运行时修改类实例，而不是修改最初定义类的源代码。一些解决方案解释了如何在类定义中声明实例变量，但这不是我要问的。

Answer 1

Ruby 为此提供了方法，instance_variable_get并且instance_variable_set. （文档）

您可以像这样创建和分配新的实例变量：

>> foo = Object.new
=> #<Object:0x2aaaaaacc400>

>> foo.instance_variable_set(:@bar, "baz")
=> "baz"

>> foo.inspect
=> #<Object:0x2aaaaaacc400 @bar=\"baz\">

Answer 2

您可以使用属性访问器：

class Array
  attr_accessor :var
end

现在您可以通过以下方式访问它：

array = []
array.var = 123
puts array.var

---

请注意，您也可以使用attr_reader或attr_writer仅定义 getter 或 setter，或者您可以手动定义它们：

class Array
  attr_reader :getter_only_method
  attr_writer :setter_only_method

  # Manual definitions equivalent to using attr_reader/writer/accessor
  def var
    @var
  end

  def var=(value)
    @var = value
  end
end

---

如果您只想在单个实例上定义它，也可以使用单例方法：

array = []

def array.var
  @var
end

def array.var=(value)
  @var = value
end

array.var = 123
puts array.var

---

仅供参考，针对对此答案的评论，单例方法工作正常，以下是证明：

irb(main):001:0> class A
irb(main):002:1>   attr_accessor :b
irb(main):003:1> end
=> nil
irb(main):004:0> a = A.new
=> #<A:0x7fbb4b0efe58>
irb(main):005:0> a.b = 1
=> 1
irb(main):006:0> a.b
=> 1
irb(main):007:0> def a.setit=(value)
irb(main):008:1>   @b = value
irb(main):009:1> end
=> nil
irb(main):010:0> a.setit = 2
=> 2
irb(main):011:0> a.b
=> 2
irb(main):012:0> 

如您所见，单例方法setit将设置与@b使用 attr_accessor... 定义的字段相同的字段，因此单例方法是解决此问题的一种完全有效的方法。

Answer 3

@只读

如果您对“class MyObject”的使用是对开放类的使用，那么请注意您正在重新定义初始化方法。

在 Ruby 中，没有重载之类的东西......只有覆盖或重新定义......换句话说，任何给定方法只能有 1 个实例，所以如果你重新定义它，它就会被重新定义......并且初始化方法没有什么不同（即使它是 Class 对象的新方法使用的）。

因此，永远不要重新定义现有方法而不首先对其进行别名......至少如果您想访问原始定义。并且重新定义未知类的初始化方法可能是相当冒险的。

无论如何，我想我有一个更简单的解决方案，它使用实际的元类来定义单例方法：

m = MyObject.new
metaclass = class << m; self; end
metaclass.send :attr_accessor, :first, :second
m.first = "first"
m.second = "second"
puts m.first, m.second

您可以同时使用元类和开放类来变得更加棘手，并执行以下操作：

class MyObject
  def metaclass
    class << self
      self
    end
  end

  def define_attributes(hash)
    hash.each_pair { |key, value|
      metaclass.send :attr_accessor, key
      send "#{key}=".to_sym, value
    }
  end
end

m = MyObject.new
m.define_attributes({ :first => "first", :second => "second" })

以上基本上是通过“元类”方法暴露元类，然后在define_attributes中使用它来动态定义一堆属性与attr_accessor，然后用哈希中的关联值调用属性设置器。

使用 Ruby，您可以发挥创造力并以多种不同方式做同样的事情 ;-)

---

仅供参考，如果您不知道，像我所做的那样使用元类意味着您只对给定的对象实例进行操作。因此，调用 define_attributes 只会为该特定实例定义那些属性。

例子：

m1 = MyObject.new
m2 = MyObject.new
m1.define_attributes({:a => 123, :b => 321})
m2.define_attributes({:c => "abc", :d => "zxy"})
puts m1.a, m1.b, m2.c, m2.d # this will work
m1.c = 5 # this will fail because c= is not defined on m1!
m2.a = 5 # this will fail because a= is not defined on m2!

Answer 4

Mike Stone 的回答已经很全面了，但我想补充一点细节。

您可以随时修改您的类，即使在创建了某个实例之后，也可以得到您想要的结果。您可以在控制台中尝试一下：

s1 = 'string 1'
s2 = 'string 2'

class String
  attr_accessor :my_var
end

s1.my_var = 'comment #1'
s2.my_var = 'comment 2'

puts s1.my_var, s2.my_var

Answer 5

其他解决方案也可以完美运行，但这里有一个使用 define_method 的示例，如果你一心不使用开放类......它将为数组类定义“var”变量......但请注意它是 EQUIVALENT使用开放类...好处是您可以为未知类执行此操作（因此任何对象的类，而不是打开特定类）... define_method 也将在方法内工作，而您不能在其中打开类一个方法。

array = []
array.class.send(:define_method, :var) { @var }
array.class.send(:define_method, :var=) { |value| @var = value }

这是它的使用示例...请注意，array2，一个不同的数组也有方法，所以如果这不是你想要的，你可能想要我在另一篇文章中解释的单例方法。

irb(main):001:0> array = []
=> []
irb(main):002:0> array.class.send(:define_method, :var) { @var }
=> #<Proc:0x00007f289ccb62b0@(irb):2>
irb(main):003:0> array.class.send(:define_method, :var=) { |value| @var = value }
=> #<Proc:0x00007f289cc9fa88@(irb):3>
irb(main):004:0> array.var = 123
=> 123
irb(main):005:0> array.var
=> 123
irb(main):006:0> array2 = []
=> []
irb(main):007:0> array2.var = 321
=> 321
irb(main):008:0> array2.var
=> 321
irb(main):009:0> array.var
=> 123

Answer 6

只读，以响应您的编辑：

编辑：看起来我需要澄清我正在寻找一种元编程解决方案，它允许我在运行时修改类实例，而不是修改最初定义类的源代码。一些解决方案解释了如何在类定义中声明实例变量，但这不是我要问的。对困惑感到抱歉。

我想你不是很理解“公开课”的概念，也就是说你可以随时开课。例如：

class A
  def hello
    print "hello "
  end
end

class A
  def world
    puts "world!"
  end
end

a = A.new
a.hello
a.world

以上是完全有效的 Ruby 代码，两个类定义可以分布在多个 Ruby 文件中。您可以使用 Module 对象中的“define_method”方法在类实例上定义新方法，但这相当于使用开放类。

Ruby 中的“开放类”意味着您可以在任何时间点重新定义任何类……这意味着添加新方法、重新定义现有方法或任何您真正想要的方法。听起来“公开课”解决方案确实是您正在寻找的......

Answer 7

我前段时间为此写了一个宝石。它被称为“灵活”，不能通过 ruby​​gems 获得，但直到昨天才可以通过 github 获得。我删除了它，因为它对我没用。

你可以做

class Foo
    include Flexible
end
f = Foo.new
f.bar = 1

没有任何错误。因此，您可以即时从对象中设置和获取实例变量。如果您有兴趣...我可以再次将源代码上传到 github。它需要一些修改才能启用

f.bar?
#=> true

作为询问对象是否定义了实例变量“bar”的方法，但其他任何东西都在运行。

亲切的问候，musicmatze

Answer 8

看起来所有先前的答案都假设您在编写代码时知道要调整的类的名称是什么。好吧，这并不总是正确的（至少，对我来说不是）。我可能正在迭代一堆我想赋予一些变量的类（例如，保存一些元数据或其他东西）。在这种情况下，这样的事情就可以完成，

# example classes that we want to tweak
class Foo;end
class Bar;end
klasses = [Foo, Bar]

# iterating over a collection of klasses
klasses.each do |klass|
  # #class_eval gets it done
  klass.class_eval do
    attr_accessor :baz
  end
end

# it works
f = Foo.new
f.baz # => nil
f.baz = 'it works' # => "it works"
b = Bar.new
b.baz # => nil
b.baz = 'it still works' # => "it still works"