深入分析Ruby 变量

变量是编程中最基础的概念之一，简单说就是存放数据的容器，任何程序都能用它来读写信息。Ruby 对变量的处理相当灵活，但也有一套清晰的命名约定，让你一看到变量名字就知道它的作用域和生命周期。

Ruby 一共支持五种变量类型，它们的区别基本就体现在前缀上：

• 以小写字母或下划线开头：普通变量（Variable）。
• 以 $ 开头：全局变量（Global variable）。
• 以 @ 开头：实例变量（Instance variable）。
• 以 @@ 开头：类变量（Class variable），整个继承链共享。
• 以大写字母开头：常量（Constant）。

接下来逐个拆开说。

Ruby 全局变量

全局变量以 $ 打头。如果你声明了一个全局变量但没初始化，它的值会是 nil，并且在用 -w 选项运行时，Ruby 会给出警告信息。给全局变量赋值等于改变了整个程序的全局状态——这个副作用很大，所以一般情况下不推荐使用全局变量。

下面这段代码很直观地展示了全局变量的效果：

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

这里 $global_variable 是个全局变量，两个类都可以直接访问它。运行结果：

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

一个小技巧：在 Ruby 中，你可以用 # 加在变量或常量名前的方式来插值取值。

Ruby 实例变量

实例变量以 @ 开头。和全局变量一样，未初始化的实例变量也是 nil，-w 选项下也会给警告。它的作用是让每个对象拥有自己独立的数据副本。

看一下例子就明白了：

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

这里的 @cust_id、@cust_name 和 @cust_addr 都是实例变量，每个顾客对象都保存着自己的数据。输出结果是：

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

Ruby 类变量

类变量以 @@ 开头，记住一条铁律：必须初始化之后才能在方法中使用。如果你引用了一个没初始化的类变量，Ruby 会直接报错。类变量在定义它的类以及所有子类、子模块中都是共享的——也就是说，整个继承树都能访问到同一个变量。如果用 -w 选项，重载类变量时也会收到警告。

下面这个例子常被拿来演示类变量的计数器效果：

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

这里的 @@no_of_customers 就是类变量，每次调用 total_no_of_customers 都会递增并共享这个计数。运行结果：

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

Ruby 局部变量

局部变量用起来最无拘束——以小写字母或下划线 _ 开头就行。它的作用域范围是从所在的 class、module、def、do 关键字开始，一直到对应的 end 或右大括号。这里有个容易踩的坑：如果你调用一个未初始化的局部变量，Ruby 不会直接报错，而是会尝试把它当作一个无参数的方法调用来解释。但如果你对它赋值，那就等于直接声明了这个变量。变量的生命周期在 Ruby 解析阶段就已经确定了。

回到上面的实例代码里，id、name、addr 就都是局部变量。

Ruby 常量

常量以大写字母开头。定义在类或模块内部的常量只能从类或模块内部访问，而定义在外部的常量则是全局可访问的。注意，常量不可以在方法内部定义，引用未初始化的常量会直接报错。如果你尝试对已初始化的常量重新赋值，Ruby 不会禁止，但会给出警告——这不是一个推荐的做法。

看代码：

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

这里的 VAR1 和 VAR2 就是常量。输出：

第一个常量的值为 100
第二个常量的值为 200

Ruby 伪变量

伪变量有局部变量的外表，但行为更像常量——你不能给它们赋任何值。它们是 Ruby 语言预定义好的特殊标识符：

• self：当前方法的接收器对象。
• true：代表 true 的值。
• false：代表 false 的值。
• nil：代表 undefined 的值。
• __FILE__：当前源文件的名称。
• __LINE__：当前行在源文件中的编号。

这些变量用起来挺顺手，但千万别尝试给它们赋值——Ruby 会直接甩给你一个语法错误。