Ruby Variables

A variable is a storage location that holds any data accessible by any program.

Ruby supports five types of variables.

• General lowercase letters, underscore开头: Variable.

• $开头: Global variable.

• @开头: Instance variable.

• @@开头: Class variable. Class variables are shared across the inheritance chain.

• Capital letter开头: Constant.

You have roughly understood these variables in previous chapters, and this chapter will detail these five types of variables for you.

Ruby Global Variables

Global variables begin with $. Uninitialized global variables have a value of nil and produce a warning with the -w option.

Assigning to a global variable changes the global state, so it is not recommended to use global variables.

The following example demonstrates the use of global variables.

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$global_variable = 10
class Class1
  def print_global
      puts "Global variable in Class1 is #$global_variable"
  end
end
class Class2
  def print_global
      puts "Global variable in Class2 is #$global_variable"
  end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

Here, $global_variable is a global variable. This will produce the following result:

Note: In Ruby, you can access the value of any variable or constant by placing the # character before the variable or constant.

Global variable in Class1 is 10
Global variable in Class2 is 10

Ruby Instance Variables

Instance variables begin with @. Uninitialized instance variables have a value of nil and produce a warning with the -w option.

The following example demonstrates the use of instance variables.

Example

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
end

# Create objects
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# Call methods
cust1.display_details()
cust2.display_details()

Here, @cust_id, @cust_name, and @cust_addr are instance variables. This will produce the following result:

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Ruby Class Variables

Class variables begin with @@ and must be initialized before they can be used in method definitions.

Referencing an uninitialized class variable produces an error. Class variables are shared between the class definition and all subclasses and modules.

Overloading a class variable produces a warning with the -w option.

The following example demonstrates the use of class variables.

Example

#!/usr/bin/ruby

class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
    def total_no_of_customers()
       @@no_of_customers += 1
       puts "Total number of customers: #@@no_of_customers"
    end
end

# Create objects
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# Call methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

Here, @@no_of_customers is a class variable. This will produce the following result:

Total number of customers: 1
Total number of customers: 2

Ruby Local Variables

Local variables begin with a lowercase letter or underscore _. The scope of a local variable ranges from class, module, def, or do to the corresponding end or from the left brace to the right brace {}.

When calling an uninitialized local variable, it is interpreted as a call to a method that takes no arguments.

Assigning a value to an uninitialized local variable also acts as a variable declaration. The variable will exist until the current scope ends. The lifespan of a local variable is determined when Ruby parses the program.

In the above examples, the local variables are id, name, and addr.

Ruby Constants

Constants begin with a capital letter. Constants defined within a class or module can be accessed from within that class or module, and constants defined outside a class or module can be accessed globally.

Constants cannot be defined within methods. Referencing an uninitialized constant produces an error. Assigning a value to an already initialized constant produces a warning.

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

class Example
   VAR1 = 100
   VAR2 = 200
   def show
       puts "The value of the first constant is #{VAR1}"
       puts "The value of the second constant is #{VAR2}"
   end
end

# Create object
object=Example.new()
object.show

Here, VAR1 and VAR2 are constants. This will produce the following result:

The value of the first constant is 100
The value of the second constant is 200

Ruby Pseudo Variables

They are special variables that have the appearance of local variables but behave like constants. You cannot assign any value to these variables.

• self: The receiver object of the current method.

• true: The value representing true.

• false: The value representing false.

• nil: The value representing undefined.

• _FILE_: The name of the current source file.

• _LINE_: The current line number in the source file.