赋值¶ ↑

在 Ruby 中，赋值使用 =（等号）字符。此示例将数字 5 赋值给局部变量 v

v = 5

如果之前未引用该变量，则赋值会创建一个局部变量。

赋值表达式的结果始终是被赋值的值，包括赋值方法。

局部变量名¶ ↑

局部变量名必须以小写 US-ASCII 字母或第八位设置的字符开头。通常局部变量是 US-ASCII 兼容的，因为用于键入它们的键存在于所有键盘上。

（Ruby 程序必须使用与 US-ASCII 兼容的字符集编写。在此类字符集中，如果设置了第八位，则表示扩展字符。Ruby 允许局部变量包含此类字符。）

局部变量名可以包含字母、数字、_（下划线或下横线）或第八位设置的字符。

局部变量作用域¶ ↑

一旦局部变量名被赋值，则该名称在作用域的其余部分的所有使用都被视为局部变量。

这是一个示例

1.times do
  a = 1
  puts "local variables in the block: #{local_variables.join ", "}"
end

puts "no local variables outside the block" if local_variables.empty?

这将打印

local variables in the block: a
no local variables outside the block

由于代码块创建了一个新的作用域，因此在其中创建的任何局部变量都不会泄露到周围的作用域。

在外层作用域中定义的变量会出现在内层作用域中

a = 0

1.times do
  puts "local variables: #{local_variables.join ", "}"
end

这将打印

local variables: a

您可以通过在代码块的参数中在 ; 之后列出变量，将代码块中的变量与外层作用域隔离。有关示例，请参阅调用方法文档中关于块局部变量的文档。

另请参阅 Kernel#local_variables，但请注意，for 循环不像代码块那样创建新的作用域。

局部变量和方法¶ ↑

在 Ruby 中，局部变量名和方法名几乎相同。如果您没有赋值给其中一个模糊的名称，Ruby 会假定您希望调用一个方法。一旦您赋值给该名称，Ruby 会假定您希望引用一个局部变量。

局部变量在解析器遇到赋值时创建，而不是在赋值发生时创建

a = 0 if false # does not assign to a

p local_variables # prints [:a]

p a # prints nil

方法名和局部变量名之间的相似性可能会导致代码混乱，例如

def big_calculation
  42 # pretend this takes a long time
end

big_calculation = big_calculation()

现在，对 big_calculation 的任何引用都被视为局部变量并被缓存。要调用该方法，请使用 self.big_calculation。

您可以通过使用如上所示的空参数括号或使用像 self 这样的显式接收器来强制进行方法调用。如果该方法的可见性不是公共的，或者接收器是字面量 self，则使用显式接收器可能会引发 NameError。

另一个常见的混淆情况是当使用修饰符 if 时

p a if a = 0.zero?

您不会收到 “true” 的输出，而是收到 NameError，“未定义的局部变量或方法 'a'”。由于 Ruby 首先解析 if 左侧的裸 a，并且尚未看到对 a 的赋值，它会假定您希望调用一个方法。然后，Ruby 会看到对 a 的赋值，并假定您正在引用一个局部变量。

混淆源于表达式的乱序执行。首先，局部变量被赋值，然后您尝试调用一个不存在的方法。

局部变量和 eval¶ ↑

使用 eval 来评估 Ruby 代码将允许访问在同一作用域中定义的局部变量，即使局部变量在调用 eval 之后才被定义。但是，在 eval 调用内部定义的局部变量不会反映在周围的作用域中。在 eval 调用内部，可以访问在周围作用域中定义的局部变量和在 eval 调用内部定义的局部变量。但是，您将无法访问在同一作用域中先前或后续的 eval 调用中定义的局部变量。将每个 eval 调用视为单独的嵌套作用域。示例

def m
  eval "bar = 1"
  lvs = eval "baz = 2; ary = [local_variables, foo, baz]; x = 2; ary"
  eval "quux = 3"
  foo = 1
  lvs << local_variables
end

m
# => [[:baz, :ary, :x, :lvs, :foo], nil, 2, [:lvs, :foo]]

实例变量¶ ↑

实例变量在同一对象的所有方法之间共享。

实例变量必须以 @（“at” 符号或商业 at）开头。否则，实例变量名遵循与局部变量名相同的规则。由于实例变量以 @ 开头，因此第二个字符可以是字母大写。

这是一个实例变量用法的示例

class C
  def initialize(value)
    @instance_variable = value
  end

  def value
    @instance_variable
  end
end

object1 = C.new "some value"
object2 = C.new "other value"

p object1.value # prints "some value"
p object2.value # prints "other value"

未初始化的实例变量的值为 nil。

value 方法可以访问 initialize 方法设置的值，但仅限于同一对象。

类变量¶ ↑

类变量在类、其子类和其实例之间共享。

类变量必须以 @@（两个 “at” 符号）开头。名称的其余部分遵循与实例变量相同的规则。

这是一个示例

class A
  @@class_variable = 0

  def value
    @@class_variable
  end

  def update
    @@class_variable = @@class_variable + 1
  end
end

class B < A
  def update
    @@class_variable = @@class_variable + 2
  end
end

a = A.new
b = B.new

puts "A value: #{a.value}"
puts "B value: #{b.value}"

这将打印

A value: 0
B value: 0

继续相同的示例，我们可以使用来自任一类的对象进行更新，并且该值是共享的

puts "update A"
a.update

puts "A value: #{a.value}"
puts "B value: #{b.value}"

puts "update B"
b.update

puts "A value: #{a.value}"
puts "B value: #{b.value}"

puts "update A"
a.update

puts "A value: #{a.value}"
puts "B value: #{b.value}"

这将打印

update A
A value: 1
B value: 1
update B
A value: 3
B value: 3
update A
A value: 4
B value: 4

访问未初始化的类变量将引发 NameError 异常。

请注意，类具有实例变量，因为类是对象，因此请尽量不要混淆类变量和实例变量。

全局变量¶ ↑

全局变量在任何地方都可访问。

全局变量以 $（美元符号）开头。名称的其余部分遵循与实例变量相同的规则。

这是一个示例

$global = 0

class C
  puts "in a class: #{$global}"

  def my_method
    puts "in a method: #{$global}"

    $global = $global + 1
    $other_global = 3
  end
end

C.new.my_method

puts "at top-level, $global: #{$global}, $other_global: #{$other_global}"

这将打印

in a class: 0
in a method: 0
at top-level, $global: 1, $other_global: 3

未初始化的全局变量的值为 nil。

Ruby 有一些特殊的全局变量，它们的行为会根据上下文的不同而有所不同，例如正则表达式匹配变量，或者在赋值时会产生副作用。有关详细信息，请参阅全局变量文档。

赋值方法¶ ↑

您可以定义行为类似于赋值的方法，例如

class C
  def value=(value)
    @value = value
  end
end

c = C.new
c.value = 42

使用赋值方法可以使您的程序看起来更好。在为实例变量赋值时，大多数人使用 Module#attr_accessor

class C
  attr_accessor :value
end

当使用方法赋值时，您必须始终有一个接收器。如果您没有接收器，Ruby 会假定您正在为局部变量赋值

class C
  attr_accessor :value

  def my_method
    value = 42

    puts "local_variables: #{local_variables.join ", "}"
    puts "@value: #{@value.inspect}"
  end
end

C.new.my_method

这将打印

local_variables: value
@value: nil

要使用赋值方法，您必须设置接收器

class C
  attr_accessor :value

  def my_method
    self.value = 42

    puts "local_variables: #{local_variables.join ", "}"
    puts "@value: #{@value.inspect}"
  end
end

C.new.my_method

这将打印

local_variables:
@value: 42

请注意，赋值方法返回的值将被忽略，因为赋值表达式的结果始终是赋值值。

简写赋值¶ ↑

您可以混合使用多个运算符和赋值。要将 1 添加到对象，您可以编写

a = 1

a += 2

p a # prints 3

这等效于

a = 1

a = a + 2

p a # prints 3

您可以这样使用以下运算符：+、-、*、/、%、**、&、|、^、<<、>>

还有 ||= 和 &&=。前者在值为 nil 或 false 时进行赋值，而后者在值不为 nil 或 false 时进行赋值。

这是一个示例

a ||= 0
a &&= 1

p a # prints 1

请注意，这两个运算符的行为更像是 a || a = 0，而不是 a = a || 0。

隐式 数组 赋值¶ ↑

您可以通过在赋值时列出多个值来隐式创建数组

a = 1, 2, 3

p a # prints [1, 2, 3]

这会隐式创建一个 数组。

您可以在赋值时使用 * 或“splat”运算符或解包 数组。这与多重赋值类似

a = *[1, 2, 3]

p a # prints [1, 2, 3]

b = *1

p b # prints [1]

您可以在赋值的右侧的任何位置使用 splat 运算符

a = 1, *[2, 3]

p a # prints [1, 2, 3]

多重赋值¶ ↑

您可以在右侧为多个变量赋值多个值

a, b = 1, 2

p a: a, b: b # prints {:a=>1, :b=>2}

在以下各节中，任何使用“变量”的地方，赋值方法、实例、类或全局变量也都可以工作

def value=(value)
  p assigned: value
end

self.value, $global = 1, 2 # prints {:assigned=>1}

p $global # prints 2

您可以使用多重赋值来就地交换两个值

old_value = 1

new_value, old_value = old_value, 2

p new_value: new_value, old_value: old_value
# prints {:new_value=>1, :old_value=>2}

如果赋值右侧的值多于左侧的变量，则会忽略多余的值

a, b = 1, 2, 3

p a: a, b: b # prints {:a=>1, :b=>2}

您可以使用 * 来收集赋值右侧多余的值。

a, *b = 1, 2, 3

p a: a, b: b # prints {:a=>1, :b=>[2, 3]}

* 可以出现在左侧的任何位置

*a, b = 1, 2, 3

p a: a, b: b # prints {:a=>[1, 2], :b=>3}

但是您只能在一个赋值中使用一个 *。

数组 解构¶ ↑

与 方法参数中的 数组 解构类似，您可以在赋值期间使用括号解构 数组

(a, b) = [1, 2]

p a: a, b: b # prints {:a=>1, :b=>2}

您可以将 数组 解构作为较大的多重赋值的一部分

a, (b, c) = 1, [2, 3]

p a: a, b: b, c: c # prints {:a=>1, :b=>2, :c=>3}

由于每个解构都被视为其自身的多重赋值，因此您可以使用 * 来收集解构中的参数

a, (b, *c), *d = 1, [2, 3, 4], 5, 6

p a: a, b: b, c: c, d: d
# prints {:a=>1, :b=>2, :c=>[3, 4], :d=>[5, 6]}