Ruby variables


A variable is a storage location that holds any data that can be used by any program.

Ruby supports five types of variables.

  • Generally, lowercase letters, starting with an underscore: variable (Variable).

  • #$Starts with: Global variable.

  • #@Starts with: Instance variable.

  • @@Begins with: Class variable (Class variable) Class variables are shared in the entire inheritance chain

  • Capitalized Letters starting with: Constant.

You have already roughly understood these variables in the previous chapters. This chapter will explain these five types of variables to you in detail.

Ruby global variables

Global variables start with $. The value of an uninitialized global variable is nil, and a warning will be generated after using the -w option.

Assigning values ​​to global variables will change the global state, so it is not recommended to use global variables.

The following example shows the usage of global variables. 

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

$global_variable = 10
class Class1
  def print_global
      puts "全局变量在 Class1 中输出为 #$global_variable"
  end
end
class Class2
  def print_global
      puts "全局变量在 Class2 中输出为 #$global_variable"
  end
end

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


Here, $global_variable is the 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 in front of the variable or constant. 

全局变量在 Class1 中输出为 10
全局变量在 Class2 中输出为 10

Ruby instance variables

Instance variables start with @. An uninitialized instance variable has a value of nil, and a warning is generated after using the -w option.

The following example shows the usage of instance variables. 

#!/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

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.display_details()
cust2.display_details()


Here, @cust_id, @cust_name and @cust_addr are instance variables. This produces the following results: 

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 a method definition.

Referencing an uninitialized class variable will generate an error. Class variables can be shared among subclasses or submodules of the class or module in which they are defined.

After using the -w option, overloading class variables will generate a warning.

The following example shows the usage of class variables. 

#!/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

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()


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

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

Ruby Local Variables

Local variables start with a lowercase letter or an underscore _. Local variables are scoped from class, module, def or do to the corresponding end or from the opening brace to the closing brace {}.

When an uninitialized local variable is called, it is interpreted as calling a method without parameters.

Assignment to uninitialized local variables can also be regarded as variable declaration. The variable will exist until the end of the current scope. The lifetime of local variables is determined when Ruby parses the program.

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

Ruby Constants

Constants start with an uppercase letter. Constants defined within a class or module can be accessed from within the class or module, and constants defined outside the class or module can be accessed globally.

Constant cannot be defined within a method. Referring to an uninitialized constant will generate an error. Assigning a value to an initialized constant will generate a warning. 

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

class Example
   VAR1 = 100
   VAR2 = 200
   def show
       puts "第一个常量的值为 #{VAR1}"
       puts "第二个常量的值为 #{VAR2}"
   end
end

# 创建对象
object=Example.new()
object.show


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

第一个常量的值为 100
第二个常量的值为 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: represents the value of true.

  • false: represents the value of false.

  • nil: represents the value of undefined.

  • __FILE__: The name of the current source file.

  • #__LINE__: The number of the current line in the source file.