赋值

在 Ruby 中，赋值使用 =（等号）字符。此示例将数字五赋给局部变量 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。

隐式 Array 赋值

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

a = 1, 2, 3

p a # prints [1, 2, 3]

这会隐式创建一个 Array。

您可以使用 * 或“splat”运算符来解包 Array 进行赋值。这类似于多重赋值。

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}

但是，一次赋值中只能使用一个 *。

Array 分解

就像在 方法参数 中的 Array 分解一样，您可以使用括号在赋值期间分解 Array。

(a, b) = [1, 2]

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

您可以将 Array 分解为更大的多重赋值的一部分。

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]}