已经有了一些很好的答案，但我想在这里发布关于这个主题的一对权威的定义，但也希望有人能解释一下权威Matz (Ruby的创造者)和David Flanagan在他们的O'Reilly著作《Ruby编程语言》中所说的意思。

[from 3.8.1: Object References] When you pass an object to a method in Ruby, it is an object reference that is passed to the method. It is not the object itself, and it is not a reference to the reference to the object. Another way to say this is that method arguments are passed by value rather than by reference, but that the values passed are object references. Because object references are passed to methods, methods can use those references to modify the underlying object. These modifications are then visible when the method returns.

直到最后一段，尤其是最后一句，我才明白这一切。往好了说是误导，往坏了说是混淆。对值传递引用的修改如何以任何方式改变底层对象?

在传统术语中，Ruby是严格的值传递。但这不是你真正想要的。

Ruby doesn't have any concept of a pure, non-reference value, so you certainly can't pass one to a method. Variables are always references to objects. In order to get an object that won't change out from under you, you need to dup or clone the object you're passed, thus giving an object that nobody else has a reference to. (Even this isn't bulletproof, though — both of the standard cloning methods do a shallow copy, so the instance variables of the clone still point to the same objects that the originals did. If the objects referenced by the ivars mutate, that will still show up in the copy, since it's referencing the same objects.)

Ruby是通过引用传递还是通过值传递?

Ruby是值传递。总是这样。没有例外。没有如果。少啰嗦

下面是一个简单的程序，说明了这一事实:

def foo(bar)
  bar = 'reference'
end

baz = 'value'

foo(baz)

puts "Ruby is pass-by-#{baz}"
# Ruby is pass-by-value

Ruby是解释性的。变量是对数据的引用，而不是数据本身。这便于对不同类型的数据使用相同的变量。

赋值lhs = rhs然后复制rhs上的引用，而不是数据。这与其他语言不同，比如C语言，赋值是从rhs复制数据到lhs。

对于函数调用，传递的变量，比如x，确实被复制到函数中的局部变量中，但x是一个引用。然后会有两个引用副本，它们都引用相同的数据。一个在调用者中，一个在函数中。

函数中的赋值会将一个新的引用复制到函数的x版本。在此之后，调用者的x版本保持不变。它仍然是对原始数据的引用。

相反，在x上使用.replace方法将导致ruby执行数据复制。如果在任何新赋值之前使用replace，那么调用者确实也会在其版本中看到数据更改。

类似地，只要传入变量的原始引用是恰当的，则调用者看到的实例变量将是相同的。在对象的框架内，实例变量总是具有最新的引用值，无论这些引用值是由调用者提供的，还是在类传入的函数中设置的。

“按值调用”或“按引用调用”在这里被混淆了，因为在编译语言中“=”是一个数据副本。在这种解释语言中，'='是一个参考副本。在这个例子中，你有一个传入的引用，后面跟着一个引用副本，尽管'='破坏了传入的原始引用，然后人们谈论它就好像'='是一个数据副本。

为了与定义保持一致，我们必须与'保持一致。替换'，因为它是一个数据副本。从的角度来看。替换'我们看到这确实是通过引用传递的。此外，如果我们在调试器中遍历，我们会看到传入的引用，因为变量是引用。

However if we must keep '=' as a frame of reference, then indeed we do get to see the passed in data up until an assignment, and then we don't get to see it anymore after assignment while the caller's data remains unchanged. At a behavioral level this is pass by value as long as we don't consider the passed in value to be composite - as we won't be able to keep part of it while changing the other part in a single assignment (as that assignment changes the reference and the original goes out of scope). There will also be a wart, in that instance variables in objects will be references, as are all variables. Hence we will be forced to talk about passing 'references by value' and have to use related locutions.

需要注意的是，您甚至不需要使用“replace”方法来更改原始值。如果你为一个哈希值分配了其中一个哈希值，你就是在改变原始值。

def my_foo(a_hash)
  a_hash["test"]="reference"
end;

hash = {"test"=>"value"}
my_foo(hash)
puts "Ruby is pass-by-#{hash["test"]}"

其他的答案都是正确的，但是一个朋友让我向他解释这一点，归根结底就是Ruby是如何处理变量的，所以我想分享一些我为他写的简单的图片/解释(很抱歉篇幅太长，可能有些过于简化了):

Q1:当你将一个新变量str赋值为'foo'时会发生什么?

str = 'foo'
str.object_id # => 2000

答:一个名为str的标签被创建，指向对象'foo'，对于这个Ruby解释器的状态来说，它恰好位于内存位置2000。

Q2:当你使用=将现有变量str赋值给一个新对象时会发生什么?

str = 'bar'.tap{|b| puts "bar: #{b.object_id}"} # bar: 2002
str.object_id # => 2002

A:标签str现在指向一个不同的对象。

Q3:当你分配一个新的变量= str会发生什么?

str2 = str
str2.object_id # => 2002

答:创建一个名为str2的新标签，指向与str相同的对象。

Q4:如果被str和str2引用的对象被改变了会发生什么?

str2.replace 'baz'
str2 # => 'baz'
str  # => 'baz'
str.object_id # => 2002
str2.object_id # => 2002

答:两个标签仍然指向同一个对象，但是对象本身已经发生了变化(它的内容已经改变为其他东西)。

这和最初的问题有什么关系?

这与第三季度和第四季度的情况基本相同;该方法获得传入给它的变量/ label (str2)的私有副本(str)。它不能改变标签str指向的对象，但它可以改变它们都引用的对象的内容，以包含else:

str = 'foo'

def mutate(str2)
  puts "str2: #{str2.object_id}"
  str2.replace 'bar'
  str2 = 'baz'
  puts "str2: #{str2.object_id}"
end

str.object_id # => 2004
mutate(str) # str2: 2004, str2: 2006
str # => "bar"
str.object_id # => 2004