def sumdiff(x, y)
  return x+y, x-y
end
#=> nil

sumdiff(3, 4)
#=> [7, -1]

a = sumdiff(3,4)
#=> [7, -1]
a
#=> [7, -1]

a,b=sumdiff(3,4)
#=> [7, -1]
a
#=> 7
b
#=> -1

a,b,c=sumdiff(3,4)
#=> [7, -1]
a
#=> 7
b
#=> -1
c
#=> nil

Ruby有一种受限的解构绑定形式：

ary = [1, 2, 3, 4]
a, b, c = ary
p a # => 1
p b # => 2
p c # => 3

a, b, *c = ary
p c # => [3, 4]

a, b, c, d, e = ary
p d # => 4
p e # => nil

它还有一种有限形式的结构化绑定：

a = 1, 2, 3
 p a # => [1, 2, 3]

你可以这样合并这两种形式：

a, b = b, a # Nice way to swap two variables

a, b = 1, 2, 3
p b # => 2

def foo; return 1, 2 end
a, b = foo
p a # => 1
p b # => 2

你还可以用解构/结构化绑定做其他一些事情。我没有在右边展示使用splat操作符（*）。我没有展示嵌套（使用parantheses）。我没有展示你可以在块或方法的参数列表中使用解构绑定。
这只是开胃菜：

def foo(((a, b, c, d), e, *f), g, *h)
  local_variables.sort.each do |lvar| puts "#{lvar} => #{eval(lvar).inspect}" end
end

foo([[1, 2, 3], 4, 5, 6], 7, 8, 9)
# a => 1
# b => 2
# c => 3
# d => nil
# e => 4
# f => [5, 6]
# g => 7
# h => [8, 9]

虽然返回多个值通常很有用，但我通常发现它是指向新对象需求的指针。
也就是说，我通常发现这些返回值在含义/上下文中紧密地联系在一起，并像这样传递。因此，在这种情况下，我会创建一个新对象来将它们联系在一起。这是我学会识别的一种特殊代码气味。

您也可以通过返回数组来实现这一点，例如

def sumdiff(x, y)
    [x+y, x-y]
end

它在功能上相当于

def sumdiff(x, y)
    return x+y, x-y
end

您也可以使用以下命令忽略第二个返回值：

a,=sumdiff(3,4)