# Ruby 变量

> 原文： [https://zetcode.com/lang/rubytutorial/variables/](https://zetcode.com/lang/rubytutorial/variables/)

在 Ruby 教程的这一部分中，我们将更详细地研究变量。

变量是存储数据的地方。 每个变量都有一个唯一的名称。 有一些命名约定适用于变量名。 变量保存对象。 更准确地说，它们是指位于计算机内存中的特定对象。 每个对象都是特定的数据类型。 有内置数据类型和自定义数据类型。 Ruby 属于动态语言家族。 与 Java，C 或 Pascal 等强类型语言不同，动态语言不会将变量声明为某些数据类型。 取而代之的是，解释器在分配时确定数据类型。 随着时间的流逝，Ruby 中的变量可以包含不同的值和不同类型的值。

```ruby
#!/usr/bin/ruby

i = 5
puts i
i = 7
puts i

```

变量一词来自这样一个事实，即变量与常量不同，可以随时间采用不同的值。 在上面的示例中，有一个名为`i`的变量。 首先为它分配一个值 5，然后给它一个不同的值 7。

## Ruby 变量命名约定

像其他任何编程语言一样，Ruby 也有一些变量标识符的命名约定。

Ruby 是区分大小写的语言。 这意味着`age`和`Age`是两个不同的变量名称。 大多数语言区分大小写。 BASIC 是一个例外。 这是一种不区分大小写的语言。 虽然我们可以通过更改字符的大小写来创建不同的名称，但不建议这样做。

```ruby
#!/usr/bin/ruby

i = 5
p i
I = 7
p I

```

该代码示例定义了两个变量：`I`和`i`。 它们具有不同的价值。

```ruby
./case.rb
5
7

```

`case.rb`示例的输出。

Ruby 中的变量名可以由字母数字字符和下划线`_`字符创建。 变量不能以数字开头。 这使解释器更容易区分文字数和变量。 变量名不能以大写字母开头。 如果标识符以大写字母开头，则在 Ruby 中将其视为常量。

```ruby
#!/usr/bin/ruby

name = "Jane"
placeOfBirth = "Bratislava"
placeOfBirth = "Kosice"
favorite_season = "autumn"

n1 = 2
n2 = 4
n3 = 7

p name, placeOfBirth, favorite_season
p n1, n2, n3

```

在此脚本中，我们显示了一些有效的变量名。

变量名应为有意义的。 选择变量的描述性名称是一种很好的编程习惯。 这些程序更具可读性。

```ruby
#!/usr/bin/ruby

name = "Jane"
place_of_birth = "Bratislava"
occupation = "student"

i = 5
while i > 0 do
    puts name
    i -= 1
end

```

该脚本显示了三个描述性变量名。 与`pob`相比，`place_of_birth`对程序员的描述更多。 通常认为在循环中选择简单的变量名是可以的。

## Ruby 标记

变量标识符可以以也称为信号符的特殊字符开头。 标记是附加到标识符的符号。 Ruby 中的变量信号表示变量作用域。 这与 Perl 相反，后者的信号符号表示数据类型。 Ruby 变量信号为`$`和`@`。

```ruby
#!/usr/bin/ruby

tree_name = "pine"
$car_name = "Peugeot"
@sea_name = "Black sea"
@@species = "Cat"

p local_variables
p global_variables.include? :$car_name
p self.instance_variables
p Object.class_variables

```

我们有四个范围不同的变量。 范围是可以引用变量的范围。 我们使用特殊的内置方法来确定变量的范围。

```ruby
tree_name = "pine"

```

没有符号的变量是局部变量。 局部变量仅在局部有效：例如，在方法，块或模块内部。

```ruby
$car_name = "Peugeot"

```

全局变量以`$`字符开头。 它们在任何地方都有效。 程序中应限制全局变量的使用。

```ruby
@sea_name = "Black sea"

```

以`@`标记开头的变量名称是实例变量。 此变量在对象内部有效。

```ruby
@@species = "Cat"

```

最后，我们有一个类变量。 此变量对特定类的所有实例均有效。

```ruby
p local_variables

```

`local_variables`给出了在特定上下文中定义的所有局部变量的数组。 我们的上下文是 Ruby 顶级。

```ruby
p global_variables.include? :$car_name

```

同样，`global_variables`产生一个全局数组。 我们不会将所有全局变量打印到终端，因为其中有很多。 每个 Ruby 脚本都以一堆预定义变量开头。 取而代之的是，我们调用数组的`include?`方法来检查是否在数组中定义了我们的全局变量。 还要注意，我们使用变量符号来引用变量。 （符号以冒号开头。）

```ruby
p self.instance_variables

```

`self`伪变量指向`instance_variables`方法的接收者。 在我们的例子中，接收者是`main`，这是 Ruby 顶级执行区域。

```ruby
p Object.class_variables

```

最后，我们有一组类变量。 `main`是`Object`类的实例。

```ruby
$ ./sigils.rb
[:tree_name]
true
[:@sea_name]
[:@@species]

```

示例的输出。 我们看到变量的符号名称。

## Ruby 局部变量

局部变量是在 Ruby 源代码的局部区域内有效的变量。 该区域也称为本地范围。 局部变量存在于 Ruby 模块，方法，类的定义中。

```ruby
#!/usr/bin/ruby

def method1
   x = 5
   p x    
end

method1 

p x

```

我们有一个叫做`method1`的方法，它有一个变量。 该变量是局部的。 这意味着它仅在方法定义内有效。 我们只能在方法名称和`end`关键字之间引用`x`变量。

```ruby
def method1
   x = 5
   p x    
end

```

这是`method1`方法的定义。 在方法内部，我们创建一个本地`x`变量。 我们将变量的值打印到终端。

```ruby
method1 

```

该方法被调用。

```ruby
p x

```

我们尝试引用方法定义之外的局部变量。 这导致`NameError`。 Ruby 解释器找不到此类标识符。

```ruby
$ ./locals.rb
5
./locals.rb:11:in `<main>': undefined local variable 
or method `x' for main:Object (NameError)

```

运行示例将得到以上输出。

以下示例是对先前示例的略微修改。

```ruby
#!/usr/bin/ruby

x = 5

def method1
    x = 10
    p x
end

method1

p x

```

我们有两个`x`变量。 一个在`method1`内部定义，另一个在外部定义。 它们是两个不同的局部变量。 他们不会互相冲突。

```ruby
x = 5

```

我们创建了一个本地`x`变量，该变量保留值 5。该变量在主执行区的本地范围内有效。 在`method1`内部无效。

```ruby
def method1
    x = 10
    p x
end

```

在`method1`的定义内，定义了一个新的局部变量`x`。 它的值为 10。它存在于`method1`方法的主体中。 在`end`关键字之后，它不再存在。

```ruby
$ ./locals2.rb
10
5

```

输出。

如果方法采用参数，则会为每个参数创建一个局部变量。

```ruby
#!/usr/bin/ruby

def rectangle_area a, b
    puts local_variables
    return a * b
end

puts rectangle_area 5, 6

```

我们有一个方法定义，它有两个值。 该方法返回矩形的面积。

```ruby
def rectangle_area a, b
    puts local_variables
    return a * b
end

```

`rectangular_area`方法采用两个参数。 它们是矩形的边，我们将为其计算面积。 将自动为标识符`a`和`b`创建两个局部变量。 我们调用`local_variables`方法来查看该方法中包含哪些局部变量。

```ruby
puts rectangle_area 5, 6

```

在这里，我们将两个值传递给方法`rectangle_area`。 这些值将分配给在方法内部创建的两个局部变量。

```ruby
$ ./parameters.rb
a
b
30

```

输出显示三件事。 前两个是`rectangular_area`方法中局部变量的名称。 第三是给定矩形的计算面积。

可以在另一个方法内部定义一个方法。 内部方法具有自己的局部变量。

```ruby
#!/usr/bin/ruby

def method1

    def method2

        def method3
            m5, m6 = 3
            puts "Level 3"
            puts local_variables
        end            

        m3, m4 = 3
        puts "Level 2"
        puts local_variables
        method3    
    end        

    m1, m2 = 3
    puts "Level 1"
    puts local_variables
    method2

end

method1

```

在这个 Ruby 脚本中，我们创建三个方法。 `method2`和`method3`是内部方法。 `method2`定义在`method1`内部，`method3`定义在`method2`内部。 每个方法的局部变量只能在定义它们的方法中访问。

```ruby
$ ./lms.rb
Level 1
m1
m2
Level 2
m3
m4
Level 3
m5
m6

```

从输出中我们可以看到`method1`有两个局部变量`m1`和`m2`。 内部的`method2`具有局部变量`m3`和`m4`。 最里面的方法`method3`具有局部变量`m5`和`m6`。

本节的最后一个示例将展示本地范围的一些演示。

```ruby
module ModuleM
    m1, m2 = 4

    puts "Inside module"
    puts local_variables        
end

def method1
    v, w = 3
    puts "Inside method"
    puts local_variables
end

class Some
    x, y = 2
    puts "Inside class"
    puts local_variables
end 

method1

t1, t2 = 7

puts "Inside toplevel"
puts local_variables   

```

在代码示例中，我们在模块，方法，类和顶层内部创建局部变量。 `local_variables`是`Kernel`模块的一种方法，它返回所有当前的局部变量。

```ruby
module ModuleM
    m1, m2 = 4

    puts "Inside module"
    puts local_variables        
end

```

模块是方法和常量的集合。 我们创建两个局部变量`m1`和`m2`。

```ruby
def method1
    v, w = 3
    puts "Inside method"
    puts local_variables
end

```

在`method1`中创建了两个局部变量`v`和`w`。

```ruby
class Some
    x, y = 2
    puts "Inside class"
    puts local_variables
end 

```

`x`和`y`局部变量在`Some`类的定义内创建。

```ruby
t1, t2 = 7

```

最后，创建两个属于 Ruby 顶级本地范围的本地变量。

```ruby
$ ./locals3.rb 
Inside module
m1
m2
Inside class
x
y
Inside method
v
w
Inside toplevel
t1
t2

```

输出显示每个局部作用域的局部变量。

## Ruby 全局变量

全局变量在脚本中的任何地方都有效。 他们以 Ruby 中的`$`标记开头。

不鼓励使用全局变量。 全局变量很容易导致许多编程错误。 仅在有理由时才使用全局变量。 建议程序员尽可能使用局部变量来代替全局变量。

```ruby
#!/usr/bin/ruby

$gb = 6

module ModuleM        
    puts "Inside module"
    puts $gb
end

def method1
    puts "Inside method"
    puts $gb
end

class Some
    puts "Inside class"
    puts $gb
end 

method1

puts "Inside toplevel"
puts $gb
puts global_variables.include? :$gb

```

在示例中，我们有一个全局变量`$gb`。 我们展示了可以在模块，方法，类和顶级中引用该变量。 全局变量`$gb`在所有这些实体中均有效。

```ruby
$gb = 6

```

创建一个全局变量`$gb`； 它的价值为 6。

```ruby
module ModuleM        
    puts "Inside module"
    puts $gb
end

```

在模块的定义内，我们打印全局变量的值。

```ruby
def method1
    puts "Inside method"
    puts $gb
end

```

在方法的定义内，我们打印全局变量的值。

```ruby
class Some
    puts "Inside class"
    puts $gb
end

```

在类的定义内，我们打印全局变量的值。

```ruby
puts $gb
puts global_variables.include? :$gb

```

最后，在顶层执行区域中，我们将打印全局变量的值以及该变量是否在`global_variables`方法生成的数组中。

```ruby
$ ./globals.rb
Inside module
6
Inside class
6
Inside method
6
Inside toplevel
6
true

```

该示例的输出确认了全局变量可在任何地方访问。

当 Ruby 脚本启动时，它可以访问多个预定义的全局变量。 这些全局变量不被认为是有害的，可以帮助解决常见的编程工作。

```ruby
#!/usr/bin/ruby

p $LOAD_PATH
p $:

```

该脚本显示了`$LOAD_PATH`全局变量。 该变量列出了通过`load`和`require`方法搜索的目录。 `$:`是`$LOAD_PATH`名称的简短同义词。

更多全局变量将在本章的“预定义变量”部分中介绍。

## Ruby 实例，类变量

在本节中，我们将简要介绍实例变量和类变量。 它们将在面向对象的编程章节中更详细地描述。

实例变量是属于特定对象实例的变量。 每个对象都有其自己的对象变量。 实例变量以`@`标记开头。 类变量属于特定类。 从特定类创建的所有对象共享类变量。 类变量以`@@`字符开头。

```ruby
#!/usr/bin/ruby

class Being

    @@is = true

    def initialize nm
        @name = nm
    end

    def to_s
        "This is #{@name}"
    end    

    def does_exist?
        @@is
    end
end

b1 = Being.new "Being 1"
b2 = Being.new "Being 2"
b3 = Being.new "Being 3"

p b1, b2, b3

p b1.does_exist?
p b2.does_exist?
p b3.does_exist?

```

我们创建一个自定义的`Being`类。 `Being`类具有一个类和一个实例变量。

```ruby
class Being

    @@is = true

```

`@@is`是一个类变量。 `Being`类的所有实例都共享此变量。 此示例的逻辑是`Being`是，`NotBeing`不是。

```ruby
def initialize nm
    @name = nm
end

```

`initialize`方法是一个构造器。 创建对象时将调用该方法。 创建一个`@name`实例变量。 此变量特定于具体对象。

```ruby
def to_s
    "This is #{@name}"
end       

```

当对象是打印方法的参数（例如`p`或`puts`）时，将调用`to_s`方法。 在我们的情况下，该方法给出了对象的简短人类可读描述。

```ruby
def does_exist?
    @@is
end

```

`does_exist?`方法返回类变量。

```ruby
b1 = Being.new "Being 1"
b2 = Being.new "Being 2"
b3 = Being.new "Being 3"

```

从`Being`类中创建了三个对象。 每个对象都有不同的名称。 对象的名称将存储在实例方法中，该方法对于每个对象实例都是唯一的。 这将在`to_s`方法中使用，该方法给出了对象的简短说明。

```ruby
p b1, b2, b3

```

`p`方法将创建的对象作为三个参数。 它在每个这些对象上调用`to_s`方法。

```ruby
p b1.does_exist?
p b2.does_exist?
p b3.does_exist?

```

最后，我们调用每个实例的`does_exist?`方法并打印其返回值。 这三个方法的输出是相同的，因为每个方法都返回类变量。

```ruby
$ ./icvars.rb
This is Being 1
This is Being 2
This is Being 3
true
true
true

```

示例的输出。 前三个消息是唯一的。 字符串存储在对象的实例变量中。 真实值是类变量的值，它被调用了三次。

## Ruby 环境&命令行变量

`ENV`常数允许访问环境变量。 这是一个 Ruby 哈希。 每个环境变量都是`ENV`哈希的键。

`ARGV`常量保存命令行参数值。 它们在脚本启动时由程序员传递。 `ARGV`是一个将参数存储为字符串的数组。 `$*`是`ARGV`的别名。

`ENV`和`ARGV`都是全局常数。

```ruby
#!/usr/bin/ruby

ARGV.each do |a|
  puts "Argument: #{a}"
end

```

在脚本中，我们遍历`ARGV`数组并打印其每个值。

```ruby
$ ./commandline.rb 1 2 3
Argument: 1
Argument: 2
Argument: 3

```

我们给出了三个命令行参数。 它们被打印到控制台，每个都打印在单独的行上。

以下示例将处理环境变量。

```ruby
#!/usr/bin/ruby

puts ENV['SHELL']
puts ENV['LANG']
puts ENV['TERM']

```

该脚本会将三个环境变量的值输出到终端。 这些值取决于我们操作系统的 OS 设置。

```ruby
$ ./environment.rb
/bin/bash
en_US.utf8
xterm

```

样本输出。

## Ruby 伪变量

Ruby 具有一些称为伪变量的变量。 它们不同于常规变量。 我们不能为伪变量赋值。

`self`是当前方法的接收者。 `nil`是`NilClass`的唯一实例。 它表示一个值的缺失。 `true`是`TrueClass`的唯一实例。 它表示布尔值`true`。 `false`是`FalseClass`的唯一实例。 它表示布尔值`false`。

`true`和`false`是布尔数据类型的值。 从另一个角度来看，它们是特定类的实例。 这是因为 Ruby 中的所有内容都是一个对象。 这看起来不必要地复杂。 但这是上述 Ruby 习惯用法的结果。

```ruby
#!/usr/bin/ruby

p self
p nil
p true
p false

p self.class
p nil.class
p true.class
p false.class

```

这是伪变量的示例。 我们使用`p`方法打印所有四个伪变量。 然后我们找出所有它们的类名。

```ruby
p self

```

在这种情况下，`self`伪变量返回主执行上下文。

```ruby
$ ./pseudo.rb
main
nil
true
false
Object
NilClass
TrueClass
FalseClass

```

示例输出。

在本节的第二个示例中，我们将进一步查看`self`。

```ruby
#!/usr/bin/ruby

class Some
    puts self
end

class Other
    puts self
end

puts self

```

如前所述，`self`引用了当前方法的接收者。 上面的示例显示了不同接收器的三个示例。

```ruby
class Some
    puts self
end

```

接收器是称为`Some`的类。

```ruby
class Other
    puts self
end

```

这是另一个接收器：名为`Other`的类。

```ruby
puts self

```

第三个接收器是 Ruby 顶级。

```ruby
$ ./pseudoself.rb
Some
Other
main

```

示例输出。

本节的最后一个示例将展示其他三个伪变量。

```ruby
#!/usr/bin/ruby

if true
    puts "This message is shown"
end

if false
    puts "This message is not shown"
end

p $name
p $age

```

上面的示例显示了正在使用的`true`，`false`和`nil`伪变量。

```ruby
if true
    puts "This message is shown"
end

```

`true`用于布尔表达式。 该消息始终被打印。

```ruby
if false
    puts "This message is not shown"
end

```

此消息从不打印。 不满足条件。 在布尔表达式中，我们总是得到一个负值。

```ruby
p $name
p $age

```

如果引用了全局值且尚未初始化，则它们包含`nil`伪变量。 它代表没有价值。

```ruby
$ ./pseudo2.rb
This message is shown
nil
nil

```

伪脚本`pseudo2.rb`的输出。

## Ruby 预定义变量

Ruby 有很多预定义的全局变量。 这是 Perl 语言的传承。 Ruby 受 Perl 的强烈影响。 当 Ruby 脚本启动时，它们是可访问的。 我们为预定义的 Ruby 变量提供了一些示例。

```ruby
#!/usr/bin/ruby

print "Script name: ", $0, "\n"
print "Command line arguments: ", $*, "\n"

puts "Process number of this script: #{$$}"

```

已经使用了三个预定义变量：`$0`，`$*`和`$$`。 `$0`存储当前脚本名称。 `$*`变量存储命令行参数。 并且`$$`存储脚本的 PID（进程 ID）。

```ruby
$ ./predefined.rb 1 2 3
Script name: ./predefined.rb
Command line arguments: ["1", "2", "3"]
Process number of this script: 3122

```

样本输出。

`$?`全局变量存储最后执行的子进程的退出状态。

```ruby
#!/usr/bin/ruby

system 'echo "Ruby"'
puts $?

%x[exit '1']
puts $?

```

我们运行两个外部子进程，并使用`$?`变量检查其退出状态。

```ruby
system 'echo "Ruby"'
puts $?

```

使用`system`方法，我们启动了一个子进程。 这是一个`echo` bash 命令，该命令将消息输出到终端。

```ruby
%x[exit '1']
puts $?

```

在第二种情况下，我们以状态 1 执行 bash `exit`命令。这一次，我们使用`%x`运算符在两个选定的定界符之间执行命令。 我们选择了`[]`字符。

```ruby
$ ./predefined2.rb
Ruby
pid 3131 exit 0
pid 3133 exit 1

```

第一个子进程以状态 0 终止，第二个子进程以退出状态 1 终止。

`$;`变量具有`String`类的`split`方法的默认分隔符。

```ruby
#!/usr/bin/ruby

str = "1,2,3,4,5,6,7"
p str.split

$; = ","
p str.split

```

我们使用`$;`变量来控制如何使用`split`方法剪切字符串。 该方法带有一个参数，该参数指示应在何处分割字符串。 如果省略该参数，则使用`$;`中的值。

```ruby
$; = ","
p str.split

```

我们为`$;`变量指定分隔符。 `split`方法不带参数，因此使用`$;`的值。

```ruby
$ ./predefined3.rb
["1,2,3,4,5,6,7"]
["1", "2", "3", "4", "5", "6", "7"]

```

在第一种情况下，字符串未拆分。 在第二种情况下，按照我们的预期正确分割了字符串。

在最后一个示例中，我们显示了三个与正则表达式一起使用的全局预定义变量。

```ruby
#!/usr/bin/ruby

"Her name is Jane" =~ /name/

p $`
p $&
p $'

```

当我们在字符串上应用`=~`运算符时，Ruby 会设置一些变量。 `$&`变量的字符串与最后一个正则表达式匹配相匹配。 `` $` ``在`$&`之前有一个字符串，`$'`在`$&`之后有一个字符串。

```ruby
$ ./predefined4.rb
"Her "
"name"
" is Jane"

```

Example output.

在 Ruby 教程的这一部分中，我们更深入地研究了 Ruby 变量。