Ruby Variables Tutorial

In this section we will learn what Variables are and how to use them in Ruby.

What is variable in Ruby? (Defining Variable)

In short, a variable is a name which points to a memory location where data could be stored! Consider a variable as a door to a storage place where you can put things in there temporarily!

You see, in almost every program out there, there are data! For example, a calculator takes numbers as its inputs and runs the desired operation on those numbers (data) and then returns the result to users.

Now the data that we put in the calculator can’t stay on the fly somehow until the calculator program summon it! It needs to be stored in a place temporarily until it is needed!

That temporarily place is called memory (RAM).

Now in order to store a value in the memory, we use variables! Basically, these variables are our access point to the memory in order to either get a value that is currently in the memory or set a new value to the memory and access it later.

Another way of thinking about variables is to consider them as a label for a data. For example, you have the number 10 in your program and it is needed in a certain area. Now you can temporarily store this value in the memory and create a variable to point to it (or label it if you will). Then in later time when you needed the value, all you need to do is to call the variable! Your program then is smart enough to use the variable name and see the actual value beneath it and use that actual value instead.

Don’t worry if the concept of variables is still confusing! As we go along, you’ll see tons of examples and the concept becomes really easy to understand.

Ruby variable syntax:

In other programming languages when you want to create a variable, we usually use the keywords var or let or const first and then put the variable name after that. But in the world of Ruby we don’t need those keywords! We directly use the variable name and then assign a value to it!

For example:

age = 50

Now if you had this statement in a program, Ruby would’ve created a variable named age, stored the value 50 in the memory and made the age variable to point to that memory location where the value 50 is stored.

Now the age variable is representing the value 50. Basically the label of the value 50 is now age. So anywhere in the program (except on the left side of the assignment = operator which we will explain in a bit) that we use the age variable, it will be replaced with the value 50.

Identifiers in Ruby

Another name for the variables in Ruby is identifier! So you could say I have an identifier age that represents the value 50 or you could say I have a variable named age with the current value of 50.

Note: the word identifier is also used for other tools in Ruby as well. For example, the name of a method or the name of a class etc. they all are identifiers which identify a section of your program. We will learn more about them in later sections.

Data Types of Variables in Ruby

In other programming languages, variables have a data type! For example, if you assign a whole number like 10 to a variable then the data type of that variable is considered as int which stands for integer. But in the world of Ruby, a variable itself doesn’t have a data type! A variable is merely a pointer to a memory location where a value of any data type could be stored.

For example, a variable could point to an integer value at first but then it can be reassigned to another value (make it to point to another memory space) and hence represents another data type.

So just remember that although values in Ruby have different data type, a variable itself doesn’t.

Declaration and Initialization of Variables in Ruby

In programming in general, when we create a variable, it is called declaration. And then when we assign a value to that variable for the first time, it is called initialization.

Now in Ruby, a variable only comes to life when we initialize it right away! Basically, in Ruby, the process of declaring a variable and initializing it happens at the same time (at the same statement).

Example: creating Ruby variables

age = 10
name = "John"
lastName = "Doe"
puts age
puts name
puts lastName
Output:
10
John
Doe

In this little program, we have 3 variables named age, name, lastName. The age variable is representing the value 10 (basically the value 10 is stored in the memory and the age variable is pointing to that memory space to represent the value). The name variable is representing the value John which is a string value (in the data type section we will explain more about data types). And the variable lastName is pointing to the Doe value.

As you can see the process of creating (declaring) a variable happens when we assign a value to them right away (initialization).

Note: the puts is called method. A method is a name that represents a set of instructions and codes that will do something! For example, the puts method takes one or more values and send that value to the output stream (terminal) to be printed. For example, here when we called the puts name the value that the name variable was pointing to, is taken and given to the puts method and then this method sent that value to the output stream to be printed. The same process happened for the age and lastName variables too.

Ruby Variables Naming Conventions

When creating a variable, there are a couple of conventions (commonly used by Ruby developers) and rules that it’s best to follow if you want your code to run properly and to be read by other developers without any sort of confusion:

• Ruby is case sensitive! That means if you create a variable with
  the name `age` then you can’t call the variable with the name `AGE` or
  `Age`! These are different variables from the perspective of
  Ruby.

• A variable name can contain letters, numbers and underscore. But
  the name of a viable cannot start with a number! For example, if we
  create a variable with the name `1name` we will get error because the
  variable is starting with a number.

• Between a variable name we can’t use space! For example, `full
  name` is not a variable because there’s a space between the characters
  of the variable. If you want to create a variable with multiple names,
  you can either use the camelCase form (the letter of each word starts
  with a capital letter except for the first word of the variable which is
  a lowercase letter) or put underscore `_` between each word. The
  convention in Ruby is to use underscore between words.

• Don’t use the reserved words that Ruby is already using for other
  purposes. (These words are explained in the section below).

Ruby Reserved Words

Ruby has a set of words that it uses them for specific purposes! So when creating variables or other stuff like methods and classes etc. don’t use these reserved words as the name for the identifiers:

Ruby Variable Assignment

If you put a variable on the left side of the assignment = operator, you’re basically invoking the variable to assign a value to it.

Note that a variable is not limited to just one value!

Basically, after creating a variable, you’re free to reassign values to that variable! Also note that there’s no limit on the type of value we assign to a variable! For example, if the variable at first had an integer value, we can reassign it to a value of different type like string or Boolean at later times.

Example: Variable Assignment in Ruby

age = 10
age = “ten”

Note that here the age variable had the value 10 at first (basically it represented this value) but then we’ve changed the value of the variable to ten which is a string value! So after the second assignment, the age variable is representing the value ten` (The old value is replaced with the new one).

Note: we will learn more about the assignment = operator in later sections.

Ruby Variable Reading

If you call a variable in any place other than on the left side of the assignment = operator, you’re calling the variable to read its current value!

For example, the puts method that we mentioned at the beginning of this section, takes a value and send that to the output stream to be printed. So we can easily pass the variable to this method and it will take the value inside that variable and sends it to the output stream.

Example: reading variables value in Ruby

nickname = "Jack"
first_name = "John"
first_name = nickname
puts first_name
puts nickname
Output:
Jack
Jack

Take a look at this statement in the program above:

first_name = nickname

In this statement we’re reading the value of the nickname and assigning it to the first_name variable. So when we called the puts method on both variables, they both printed the value “Jack” to the output stream.

Note: calling a variable to get its value is not a cut operation! It’s simply passing a reference from one variable to another! So that means both variables will point to the same value!

More to Read:

Ruby global and local variables