views:

4492

answers:

7

How can I add an instance variable to a defined class at runtime, and later get and set its value from outside of the class?

Edit: It looks like I need to clarify that I'm looking for a metaprogramming solution that allows me to modify the class instance at runtime instead of modifying the source code that originally defined the class. A few of the solutions explain how to declare instance variables in the class definitions, but that is not what I am asking about. Sorry for the confusion.

+15  A: 

Ruby provides methods for this, instance_variable_get and instance_variable_set. (docs)

You can create and assign a new instance variables like this:

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

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

>> foo.inspect
=> #<Object:0x2aaaaaacc400 @bar=\"baz\">
Gordon Wilson
This works if you just want it for a particular instance of the class... but I would tend to prefer to define singleton methods on the instance rather than use those methods
Mike Stone
Mike, I think that is the actual goal of this question. He is asking how to add a variable "at runtime", hence the use of instance_variable_set instead of defining it in the code. More than likely "baz" would be another variable as well.
Sixty4Bit
singleton method will still achieve the same thing, see my IRB output at the bottom of my answer.
Mike Stone
+10  A: 

You can use attribute accessors:

class Array
  attr_accessor :var
end

Now you can access it via:

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


Update:

Note that you can also use attr_reader or attr_writer to define just getters or setters... or you can define them manually as such:

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


Further Update:

You can also use singleton methods if you just want it defined on a single instance:

array = []

def array.var
  @var
end

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

array.var = 123
puts array.var


FYI, in response to the comment on this answer, the singleton method works fine, and the following is proof:

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>

As you can see, the singleton method setit will set the same field, @b, as the one defined using the attr_accessor... so a singleton method is a perfectly valid approach to this question.

Mike Stone
If you are going to use singleton methods then you should be acting on class variables instead of instance variables. This will not give you the outcome you are looking for.
Sixty4Bit
Check out _why's explaination here: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
Sixty4Bit
It WILL give you the outcome you are looking for... I just tested it.....
Mike Stone
see my response to your comment in my answer... it works as I advertised.
Mike Stone
It will work.. you can add instance and class members by modifying the singleton/metaclass class for the object.
Gishu
Thanks Gishu :-) I don't know why Sixty4Bit doesn't think it will work. I use singleton methods all the time if I don't want to make the change to the class itself. Plus they are a really cool concept, so I love to use them in general.
Mike Stone
The Why article is great for defining singleton methods via a closure so you have access to the surrounding scope, but if you don't need access to the scope, I think an explicit singleton method is better.
Mike Stone
Big answer. Why not just recommend a book? :)
Ian Terrell
Lol, well most of it is code examples... but also Ruby often has many ways to do the same thing, so I was presenting a couple alternatives, and responding to Sixty4Bit who mistakenly thought my answer was incorrect.
Mike Stone
+2  A: 

Mike Stone's answer is already quite comprehensive, but I'd like to add a little detail.

You can modify your class at any moment, even after some instance have been created, and get the results you desire. You can try it out in your console:

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
webmat
A: 

Readonly, in response to your edit:

Edit: It looks like I need to clarify that I'm looking for a metaprogramming solution that allows me to modify the class instance at runtime instead of modifying the source code that originally defined the class. A few of the solutions explain how to declare instance variables in the class definitions, but that is not what I am asking about. Sorry for the confusion.

I think you don't quite understand the concept of "open classes", which means you can open up a class at any time. For example:

class A
  def hello
    print "hello "
  end
end

class A
  def world
    puts "world!"
  end
end

a = A.new
a.hello
a.world

The above is perfectly valid Ruby code, and the 2 class definitions can be spread across multiple Ruby files. You could use the "define_method" method in the Module object to define a new method on a class instance, but it is equivalent to using open classes.

"Open classes" in Ruby means you can redefine ANY class at ANY point in time... which means add new methods, redefine existing methods, or whatever you want really. It sounds like the "open class" solution really is what you are looking for...

Mike Stone
A: 

The other solutions will work perfectly too, but here is an example using define_method, if you are hell bent on not using open classes... it will define the "var" variable for the array class... but note that it is EQUIVALENT to using an open class... the benefit is you can do it for an unknown class (so any object's class, rather than opening a specific class)... also define_method will work inside a method, whereas you cannot open a class within a method.

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

And here is an example of it's use... note that array2, a DIFFERENT array also has the methods, so if this is not what you want, you probably want singleton methods which I explained in another post.

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
Mike Stone
A: 

Wow. After reading all your responses, I found out how clueless I really am and how unintentionally vague my question was. So first of all, I wanted to say thanks for the responses...especially Mike and webmat who took the extra time to clarify "open classes" to make sure that I understood his response.

@Mike Open classes are cool and I see how you can add attributes, methods, etc after the original definition of the class. However, I'm trying to create a class that will allow a bunch of attributes and values to be specified at initialization.

Please correct me if I'm wrong, but since I don't know the exact list of attributes, I won't be able to iterate through that list and use open classes to attach those attributes, correct? I tried to do this something along those lines and wasn't successful:

fields = { :first_attr => "first", :second_attr => "second" }
def add_attributes(fields)
    fields.each do |k, v|
     class Object
   attr_accessor k     # I get an "undefined local variable or method 'k'" error
  end
 end
end

I found that using define_method allowed me to achieve the behavior that I wanted even when inheritance and different instances are involved:

class MyObject
    @fields = [:first, :second] # Allowable attributes -> can be re-defined by subclasses

 # values = hash of attribute_name -> attribute_value
 def initialize(values)
  @values = values
  @fields = self.fields
  @fields.each do |name|
   self.class.send(:define_method, k) { @values[k] }
  end
 end

 def fields
  return self.class.fields
 end

 def self.fields
  return @fields
 end
end

m = MyObject.new( :first => "first", :second => "second" }
puts m.second  # prints "second"

Having to define the fields method to return the class instance attribute of "fields" seems strange to me, but the approach seems reasonable. Comments?

Readonly
Please note that when you define a method on self.class, it is defining that method for EVERY instance of that class... if you only want it on the given instance, you may want to look at my new answer which creates them as singleton methods.
Mike Stone
+3  A: 

@Readonly

If your usage of "class MyObject" is a usage of an open class, then please note you are redefining the initialize method.

In Ruby, there is no such thing as overloading... only overriding, or redefinition... in other words there can only be 1 instance of any given method, so if you redefine it, it is redefined... and the initialize method is no different (even though it is what the new method of Class objects use).

Thus, never redefine an existing method without aliasing it first... at least if you want access to the original definition. And redefining the initialize method of an unknown class may be quite risky.

At any rate, I think I have a much simpler solution for you, which uses the actual metaclass to define singleton methods:

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

You can use both the metaclass and open classes to get even trickier and do something like:

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" })

The above is basically exposing the metaclass via the "metaclass" method, then using it in define_attributes to dynamically define a bunch of attributes with attr_accessor, and then invoking the attribute setter afterwards with the associated value in the hash.

With Ruby you can get creative and do the same thing many different ways ;-)


FYI, in case you didn't know, using the metaclass as I have done means you are only acting on the given instance of the object. Thus, invoking define_attributes will only define those attributes for that particular instance.

Example:

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!
Mike Stone
Won't this define these methods a MyObject object and not the class itself? So this would be defining a m1.a, m1.b where a and b are singleton methods for only that object.
vrish88