Ruby 变量 · ZetCode 中文系列教程

# 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 变量。