Why Use Ruby'S Attr_Accessor, Attr_Reader and Attr_Writer

<script type="text/ruby">
def puts(s)  # ignore this method, just dumps to the display  Element['#output'].html = Element['#output'].html + s.to_s + "<br/>"end
class OpenKimono  def method_missing(name, *args)    if name =~ /=$/      instance_variable_set("@#{name[0..-2]}".to_sym, args[0])    else      instance_variable_get("@#{name}")    end  endend
class MyClass < OpenKimonoend
foo = MyClass.new
foo.bar = 12
puts "foo.bar just set to 12, it now = #{foo.bar}"
foo.baz = 13
puts "foo.baz just set to 13, it now = #{foo.baz}"
puts "foo.manchu has never been set... what does it equal? #{foo.manchu}"
</script>

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script src="https://rawgit.com/reactive-ruby/inline-reactive-ruby/master/inline-reactive-ruby.js"></script><div id="output" style="font-family: courier"></div>

attr_accessor vs attr_reader & instance variables

attr_accessor defines getter and setter.attr_reader defines only getter.

class Car
  attr_reader :engine
  def initialize(engine)
    @engine = engine
  end
end

Car.instance_methods(false) # => [:engine]

With the above code you defined only def engine; @engine ;end.

class Car
  attr_accessor :engine
  def initialize(engine)
    self.engine = engine
  end
end

Car.instance_methods(false) # => [:engine, :engine=]

With the above code you defined only def engine; @engine ;end and def engine=(engine) ;@engine = engine ;end.

What does it mean that `attr_accessor` / `attr_reader` create an instance variable?

That's a bug/misleading wording in documentation. The attr_reader/attr_accessor themselves don't create any variables. How can they? They work outside of class instance lifecycle. And even read access don't make the instance variables come to life. Only write access creates them.

class Foo
  attr_accessor :bar
end

foo = Foo.new
foo.instance_variables # => []
foo.bar # try read ivar
foo.instance_variables # => [], nope, not yet
foo.bar = 2 # write ivar
foo.instance_variables # => [:@bar], there it is

Why is attr_accessor necessary in Rails?

attr_accessor is a core feature of Ruby and is used to generate instance variables with getter and setter methods. Its use is never required in basic Ruby (it's a convenience).

In the case of ActiveRecord models, getters and setters are already generated by ActiveRecord for your data columns. attr_accessor is not needed or desirable.

If you have additional instance data you don't need to persist (i.e. it's not a database column), you could then use attr_accessor to save yourself a few lines of code.

The similarly-named attr_accessible — which is frequently seen in Rails code and confused with attr_accessor — is a deprecated method of controlling mass assignment within ActiveRecord models. Rails 4 doesn't support it out of the box; it has been replaced by Strong Parameters, which allows more granular control.

Is it better practice to use an attr_accessor here or not?

I think your use of attr_accessor here is fine, though depending on how much functionality you continue to add, it will likely be clearer to restrict functionality of that class to the class itself.

Regarding your question on using a method within QuestionList, this would come down to readability. Something to note first, however: you used QuestionsList.add_question(question) as an example. This would create a class method. What you really want here is an instance method, which would read as list.add_question(question), since you already have an instance of the list created. This blog post has some good information on the difference between class and instance methods.

I personally find instance methods would most clearly communicate your intent. I would write out QuestionList as follows:

class QuestionList

  def initialize
    @questions = []
  end

  def add_question(question)
    @questions << question
  end

  def print_all_questions_in_list
    @questions.each do |question|
      puts "#{question.ask}"
    end
  end

end

This SO post has some excellent information on Ruby's attr methods, if you'd like additional info there.

How using in Ruby's attr_reader and attr_writer for variable @@?

There is no such thing in Ruby. But it is not that hard to write your own:

class Module
  def mattr_writer(*attrs)
    attrs.each do |attr|
      define_singleton_method(:"#{attr}=") do |val|
        class_variable_set(:"@@#{attr}", val)
      end
    end
  end

  def mattr_reader(*attrs)
    attrs.each do |attr|
      define_singleton_method(attr) do
        class_variable_get(:"@@#{attr}")
      end
    end
  end

  def mattr_accessor(*attrs)
    mattr_reader(*attrs)
    mattr_writer(*attrs)
  end
end

class Foo; end
Foo.mattr_accessor(:bar)
Foo.bar = 42

Foo.bar #=> 42

Foo.bar = 23

Foo.bar #=> 23

Or, you could use ActiveSupport, which already provides these methods.

However, since most style guides discourage usage of class hierarchy variables, there is not much point in having accessors for them.

---

Related Topics