Ruby how does attr accessor work

You can use the p method to easily get debugging output from programs. These two lines are equivalent: p anObject print anObject.

First we ask for an automatically generated reader and writer, and then we incorporate the new information into inspect :. What happens if we try to create a third piece of fruit now? Remember that instance variables don't exist until values are assigned to them. We have asked it to report on the kind and condition of a piece of fruit, but as yet f3 has not been assigned either attribute.

As you grow your list of methods, and especially if you need both the getter and the setter, something funny starts happening. You end up with two lines of code that look very much alike. It makes your code look ugly and it introduces maintenance overhead i. But, as you can expect, Ruby has a solution to that problem too. It squashes down those two lines into one. Like so. That is the idiomatic way of doing it. Hash vs. June 27, Learn. Share on facebook Facebook. Share on twitter Twitter.

There are some great answers on this already, but anyone looking for more clarification, I hope my answer can help. Initialize allows you to set data to an instance of an object upon creation of the instance rather than having to set them on a separate line in your code each time you create a new instance of the class. If we wanted to set the name without the initialize method we could do so like this:. This is the only job of initialize. You cannot call on initialize as a method.

See below for more detail on those. Visit the sample code below for a breakdown on this. See the code below;. This syntax works exactly the same way, only it saves us six lines of code. Imagine if you had 5 more state attributable to the Item class? The code would get long quickly. Below I explain the difference based on my understanding;. As stated before, the initialize method allows you to set the values for an instance of an object upon object creation.

But what if you wanted to set the values later, after the instance was created, or change them after they have been initialized? This would be a scenario where you would use a setter method. We haven't defined Person as something that can have a name or any other attributes for that matter.

We get an error because, in Rubyland, a Person class of object is not something that is associated with or capable of having a "name" BUT we can use any of the given methods see previous answers as a way to say, "An instance of a Person class baby can now have an attribute called 'name', therefore we not only have a syntactical way of getting and setting that name, but it makes sense for us to do so.

Again, hitting this question from a slightly different and more general angle, but I hope this helps the next instance of class Person who finds their way to this thread.

Simply attr-accessor creates the getter and setter methods for the specified attributes. BankAccount class does not have def owner and def balance. If it does, then you can use the two commands below. But those two methods aren't there. It accesses attributes like you would access a method. Now you can use the last 2 methods. Defines a named attribute for this module, where the name is symbol. In the old ruby docs a hash tag means a method.

It could also include a class name prefix I am new to ruby and had to just deal with understanding the following weirdness. Might help out someone else in the future.

Attributes are class components that can be accessed from outside the object. They are known as properties in many other programming languages. Unlike Python and a few other languages, Ruby does not allow instance variables to be accessed directly from outside the object. In the above example, c is an instance object of the Car class. We tried unsuccessfully to read the value of the wheels instance variable from outside the object.

What happened is that Ruby attempted to call a method named wheels within the c object, but no such method was defined. To access the value of the wheels variable from the outside, we need to implement an instance method by that name, which will return the value of that variable when called.

That's called an accessor method. In the general programming context, the usual way to access an instance variable from outside the object is to implement accessor methods, also known as getter and setter methods. A getter allows the value of a variable defined within a class to be read from the outside and a setter allows it to be written from the outside.

In the following example, we have added getter and setter methods to the Car class to access the wheels variable from outside the object. This is not the "Ruby way" of defining getters and setters; it serves only to illustrate what getter and setter methods do. The above example works and similar code is commonly used to create getter and setter methods in other languages.

In the above example, the wheels attribute will be readable and writable from outside the object. Those three methods are not getters and setters in themselves but, when called, they create getter and setter methods for us. They are methods that dynamically programmatically generate other methods; that's called metaprogramming.

The first longer example, which does not employ Ruby's built-in methods, should only be used when additional code is required in the getter and setter methods. For instance, a setter method may need to validate data or do some calculation before assigning a value to an instance variable.

However, this is rarely justifiable and usually a bad idea, as bypassing encapsulation tends to wreak all sorts of havoc. Despite the large number of existing answers, none of them seems to me to explain the actual mechanism involved here.

It's metaprogramming; it takes advantage of the following two facts:. We are declaring a class method named which, when called with a value, creates an instance method called name which returns that value.

That is the metaprogramming part. What on earth did we just do? Well, in the class declaration, executable code executes with reference to the class. So the bare word named is actually a call to the class method named , which we inherited from Nameable; and we are passing the string "Fido" as the argument.

And what does the class method named do? It creates an instance method called name , which returns that value. So now, behind the scenes, Dog has a method that looks like this:. Why did I tell you all that? In particular, it creates a getter and setter method for the instance property whose name you provide as argument, so that you don't have to write those getter and setter methods yourself. I think of it as my to go method because it is more well rounded or versatile.

Also, peep in mind that in Rails, this is eliminated because it does it for you in the back end. I know this is more of a general explanation but it helped me as a beginner.

Stack Overflow for Teams — Collaborate and share knowledge with a private group.