Assignment
分配
在 Ruby 中，赋值使用=（等号）字符。本例将数字5分配给本地变量v：
v = 5
如果变量先前未被引用，则赋值会创建一个局部变量。
局部变量名称
局部变量名称必须以小写的 US-ASCII 字母或设置了8位的字符开头。通常，本地变量与 US-ASCII 兼容，因为键入它们的键存在于所有键盘上。
（Ruby 程序必须使用 US-ASCII 兼容的字符集编写，在这种字符集中，如果设置了8位，则表示扩展字符，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
您可以通过;在块的参数中列出它们来将块中的变量与外部范围隔离。有关示例，请参阅调用方法文档中的块局部变量文档。
另请参阅内核＃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.。如果方法的可见性不公开，则使用明确的接收方可能会引发 NameError。
另一个通常令人困惑的情况是使用修饰符时if：
p a if a = 0.zero?
而非打印的“真”，你收到一个 NameError，“未定义的局部变量或方法a'”. Since ruby parses the bare一left of the，如果first and has not yet seen an assignment to一个it assumes you wish to call a method. Ruby then sees the assignment to了`，并会假设你引用一个本地方法。
这种混淆来自表达的乱序执行。首先分配局部变量 - 然后尝试调用不存在的方法。
变量实例
实例变量在同一对象的所有方法中共享。
实例变量必须以@（“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。如果您在启用警告的情况下运行 Ruby，您将在访问未初始化的实例变量时收到警告。
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]
您可以在任务右侧的任何地方摔打：
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]}
