Ruby Variables, Constants

Ruby Variables

Variable is a symbol or name that stands for a value. Variables locate in memory locations and are used to store values such as numeric values, characters, character strings, or memory addresses so that they can be used in any part of the program.

We have discussed the following types of variables and constants supported by Ruby :

• Local Variables
• Instance Variables
• Class Variables
• Global Variables
• Constants

Local Variable:

A local variable name must start with a lowercase letter (a-z) or underscore (_) with the eight-bit set.

Local Variable Scope

A local variable is only accessible from within the block of its initialization. See the following example :

In the following example, there are three local variables called color. One is assigned the value, 'Red' within the ‘main scope’ of the program; two others are assigned integers within the scope of two separate methods. As each local variable has a different scope, the assignments have no affect on the other local variables with the same name in different scopes. We have verified it by calling the methods at the end of the program.:

Example:

color = "Red"
def method1 
color = 192
puts("Color Value in method1 : ",color)
end 

def method2
color = 255
puts("Color Value method2: ",color)
end

method1 
method2  
method1
puts("Color Value outside methods : "+color)

Output:

H:\>ruby abc.rb
Color Value in method1 :
192
Color Value method2:
255
Color Value in method1 :
192
Color Value outside methods : Red

Local Variables and Methods:

In Ruby, local variable names and method names are nearly identical. If you have not assigned to one of these ambiguous names ruby will assume you wish to call a method. Once you have assigned to the name ruby will assume you wish to reference a local variable.

The local variable is created when the parser encounters the assignment, not when the assignment occurs:

a = 0 if false # does not assign to a

p local_variables # prints [:a]

p a # prints nil

def big_calculation
  42 # pretend this takes a long time
end

big_calculation = big_calculation()

Now any reference to big_calculation is considered a local variable and will be cached. To call the method, use self.big_calculation.

You can force a method call by using empty argument parentheses as shown above or by using an explicit receiver like self. Using an explicit receiver may raise a NameError if the method's visibility is not public.

Another commonly confusing case is when using a modifier if:

p a if a = 0.zero?

Rather than printing “true” you receive a NameError, “undefined local variable or method `a'”. Since ruby parses the bare a left of the if first and has not yet seen an assignment to it assumes you wish to call a method. Ruby then sees the assignment to a and will assume you are referencing a local method.

The confusion comes from the out-of-order execution of the expression. First, the local variable is assigned to then you attempt to call a nonexistent method.

Instance Variables:

Instance variables are shared across all methods for the same object. The instance variable name must start with '@' character, otherwise instance variable names follow the rules as a local variable(discussed earlier) name.

Syntax:

@insvar

In the following example, Student.new creates a new object - an instance of the class Student. The instance variables @student_id and @student_name.

class Student
  def initialize(student_id, student_name)
    @student_id = student_id
    @student_name = student_name
  end
  
  def show
    puts "Student Name and ID : "
    puts(@student_id, @student_name)
  end
end
Student.new(1, "Sara").show
Student.new(2, "Raju").show

Output:

Student Name and ID :
1
Sara
Student Name and ID :
2
Raju

Note : An uninitialized instance variable has a value of nil.

Class Variables:

Class variables are shared between a class, its subclasses, and its instances.

A class variable must start with a @@ (two “at” signs). The rest of the name follows the same rules as instance variables.

Syntax:

@@classvar

The following example shows that all classes change the same variable. Class variables behave like global variables which are visible only in the inheritance tree. Because Ruby resolves variables by looking up the inheritance tree first, this can cause problems if two subclasses both add a class variable with the same name.

Example:

class School
@@no_off_students = 650
end

# class V sub-class of School  
class V < School
@@no_off_students = 75
end

# class VI sub-class of School  
class VI < School
@@no_off_students = 80
end


puts School.class_eval("@@no_off_students")
puts V.class_eval("@@no_off_students")
puts VI.class_eval("@@no_off_students")

Output:

80
80
80

Global Variables:

In Ruby a global variables start with a $ (dollar sign). The rest of the name follows the same rules as instance variables. Global variables are accessible everywhere.

Syntax:

$globalvar

Example:

$global = 0

class C
  puts "in a class: #{$global}"

  def my_method
    puts "in a method: #{$global}"

    $global = $global + 1
    $other_global = 3
  end
end

C.new.my_method

puts "at top-level, $global: #{$global}, $other_global: #{$other_global}"

Output:

in a class: 0
in a method: 0
at top-level, $global: 1, $other_global: 3

An uninitialized global variable has a value of nil.

Ruby has some special globals that behave differently depending on context such as the regular expression match variables or that have a side-effect when assigned to. See the global variables documentation for details.

Ruby Constants:

A variable whose name begins with an uppercase letter (A-Z) is a constant. A constant can be reassigned a value after its initialization, but doing so will generate a warning. Every class is a constant.
Trying to access an uninitialized constant raises the NameError exception.

Syntax:

ABCD

Example :

class Student
 NO_Students = 800
end
puts  'No of students in the school : ', Student::NO_Students

Here NO_Students is the constant.

Output:

No of students in the school :
800

Ruby : Pseudo Variables

Ruby : Pre-defined Variables

Ruby : Pre-defined Constants

Previous: Ruby Style Guide
Next: Ruby Operators Precedence