Variable Scope

In Ruby, variables act as the pointers to the location of other data. Although they appear to, they do not store the data itself. They only act as a reference to a memory location that some data has been stored in. Regardless of the specifics of how they work, if you assign two different values to the same variable, the first value will be lost. Variables can only store one object at a time. To cope with this variables are given scope. Scope denotes where a variable is visible. If you try to access a variable outside of its scope you will get an error.

The broadest scope is given to constants. Constants have what is called a global scope. That means they can be seen anywhere within your code. Constants are mathematical values that are the same regardless of what your code is doing. They represent basic laws of the universe, like pi or e. In addition to the preset "laws of the universe", you as the programmer can create your own constants. Once you assign a variable, that is named with ALL_CAPITAL_LETTERS, a value that variable is now a constant and will behave in all the ways of the mathematical constants. Despite the name constant, they are actually just like any other object in Ruby. They have attributes and methods that can be used to manipulate the constant itself. Of course this is not recommended, and even if you mean to do it, Ruby will send you a warning.

There are also global variables. These are similar to constants, because they can be accessed anywhere in the program. They are represented by starting with a dollar-sign($), and unlike constants, you get no warning if you change a global variable. This can make global variables dangerous to use. Often times you'll use variables of the same name as counters or as temporary placeholders. If those variables have a global scope you may get unexpected results.

If you want to limit the scope of a variable to just a particular class of objects you can use class variables. These are denoted by starting the variable with two at-signs(@@). The example that always comes to mind for the purpose of class variables would be a parking lot. In the lot you have many cars (which are instantiations of the Car class). We would use a class variable to denote how many cars are in the lot (@@number_of_cars). If a car leaves or enters, it changes the class variable to reflect +1 or -1. Every single car in the class Car has this variable with them, and when each Car object was created it inherited access to the @@number_of_cars variable.

The scope of the entire class is too broad if you want to be able to use a variable within a single object though. Since many objects can be instantiated from a single class, and they will all have the same attributes with different values. They can't all be using the same variables. This is where instance variables come in. They are started with a single at-sign(@). These variables are only accessible within the object itself. They are the equivalent of your personal characteristics and thoughts. No matter how much another Person object wishes to do so, without proper access they can not change your weight. This means that only methods that function within the object can affect the variables. If a different object needs to access a variable, then they need a getter or setter to do so.

Getters and Setters are methods contained within an object that allow the object to be accessed externally. Using @weight as an example of an instance variable we can define the weight of a Person object. In order to increase the value of weight, we would need to use the eat_junk_food method to increase your @weight.

The last kind of variable, with the most limited scope, is the local variable. Local variables can only be started with lowercase letters or underscores(_). They can only be accessed in the block that they were created. Local variables should be used for internal calculations.