是的，但是....

Ruby将引用传递给一个对象，因为Ruby中的所有东西都是对象，那么你可以说它是通过引用传递的。

我不同意这里的帖子声称它是通过价值，这对我来说似乎是迂腐的赛门铁克游戏。

然而，实际上它“隐藏”了行为，因为ruby提供的大多数操作都是“开箱即用”的——例如字符串操作，会生成对象的副本:

> astringobject = "lowercase"

> bstringobject = astringobject.upcase
> # bstringobject is a new object created by String.upcase

> puts astringobject
lowercase

> puts bstringobject
LOWERCASE

这意味着大多数时候，原始对象保持不变，给人一种ruby是“传递值”的感觉。

当然，在设计自己的类时，理解这种行为的细节对于功能性行为、内存效率和性能都很重要。

试试这个:——

1.object_id
#=> 3

2.object_id
#=> 5

a = 1
#=> 1
a.object_id
#=> 3

b = 2
#=> 2
b.object_id
#=> 5

标识符a包含值对象1的object_id 3，标识符b包含值对象2的object_id 5。

现在这样做:——

a.object_id = 5
#=> error

a = b
#value(object_id) at b copies itself as value(object_id) at a. value object 2 has object_id 5
#=> 2

a.object_id 
#=> 5

现在，a和b都包含相同的object_id 5，它指向值对象2。 因此，Ruby变量包含object_ids来引用值对象。

执行以下操作也会给出错误:——

c
#=> error

但是这样做不会产生错误:——

5.object_id
#=> 11

c = 5
#=> value object 5 provides return type for variable c and saves 5.object_id i.e. 11 at c
#=> 5
c.object_id
#=> 11 

a = c.object_id
#=> object_id of c as a value object changes value at a
#=> 11
11.object_id
#=> 23
a.object_id == 11.object_id
#=> true

a
#=> Value at a
#=> 11

这里标识符a返回值对象11，其对象id为23，即object_id 23位于标识符a，现在我们看到一个使用method的例子。

def foo(arg)
  p arg
  p arg.object_id
end
#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23

foo中的Arg被赋值为x。 它清楚地表明参数是由值11传递的，值11本身是一个对象，对象id为23。

现在再看这个:——

def foo(arg)
  p arg
  p arg.object_id
  arg = 12
  p arg
  p arg.object_id
end

#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23
#=> 12
#=> 25
x
#=> 11
x.object_id
#=> 23

在这里，标识符arg首先包含object_id 23来引用11，在对值对象12进行内部赋值后，它包含object_id 25。但它不会改变在调用方法中使用的标识符x引用的值。

因此，Ruby是按值传递的，Ruby变量不包含值，但包含对值对象的引用。

Two references refer to same object as long as there is no reassignment. 

同一对象中的任何更新都不会引用到新的内存，因为它仍然在相同的内存中。 以下是一些例子:

    a = "first string"
    b = a



    b.upcase! 
    => FIRST STRING
    a
    => FIRST STRING

    b = "second string"


a
    => FIRST STRING
    hash = {first_sub_hash: {first_key: "first_value"}}
first_sub_hash = hash[:first_sub_hash]
first_sub_hash[:second_key] = "second_value"

    hash
    => {first_sub_hash: {first_key: "first_value", second_key: "second_value"}}

    def change(first_sub_hash)
    first_sub_hash[:third_key] = "third_value"
    end

    change(first_sub_hash)

    hash
    =>  {first_sub_hash: {first_key: "first_value", second_key: "second_value", third_key: "third_value"}}

关于Ruby的“按值传递引用”如何工作的理论，有很多很棒的答案。但以身作则，我能更好地学习和理解一切。希望这对你们有帮助。

def foo(bar)
  puts "bar (#{bar}) entering foo with object_id #{bar.object_id}"
  bar =  "reference"
  puts "bar (#{bar}) leaving foo with object_id #{bar.object_id}"
end

bar = "value"
puts "bar (#{bar}) before foo with object_id #{bar.object_id}"
foo(bar)
puts "bar (#{bar}) after foo with object_id #{bar.object_id}"

# Output
bar (value) before foo with object_id 60
bar (value) entering foo with object_id 60
bar (reference) leaving foo with object_id 80 # <-----
bar (value) after foo with object_id 60 # <-----

正如你所看到的，当我们输入这个方法时，我们的工具条仍然指向字符串“value”。但是之后我们给bar分配了一个字符串对象“reference”，它有一个新的object_id。在这种情况下，foo内部的bar具有不同的作用域，无论我们在方法中传递什么，当我们重新分配它并将其指向内存中包含String "reference"的新位置时，bar都不再访问它。

现在考虑同样的方法。唯一的区别是在方法中使用do

def foo(bar)
  puts "bar (#{bar}) entering foo with object_id #{bar.object_id}"
  bar.replace "reference"
  puts "bar (#{bar}) leaving foo with object_id #{bar.object_id}"
end

bar = "value"
puts "bar (#{bar}) before foo with object_id #{bar.object_id}"
foo(bar)
puts "bar (#{bar}) after foo with object_id #{bar.object_id}"

# Output
bar (value) before foo with object_id 60
bar (value) entering foo with object_id 60
bar (reference) leaving foo with object_id 60 # <-----
bar (reference) after foo with object_id 60 # <-----

注意到区别了吗?我们在这里所做的是:我们修改了String对象的内容，变量所指向的对象。bar的范围在方法内部仍然是不同的。

所以要注意如何处理传递给方法的变量。如果修改传入的变量-in-place (gsub!， replace, etc)，然后在方法的名称中以砰的一声表示so，比如“def foo!”

注:

重要的是要记住，foo的“bar”的内部和外部是“不同的”“bar”。它们的范围不同。在该方法中，您可以将“bar”重命名为“club”，结果将是相同的。

我经常看到变量在方法内部和外部被重用，虽然这很好，但它降低了代码的可读性，是一种代码气味。我强烈建议不要做我在上面例子中所做的:)，而是这样做

def foo(fiz)
  puts "fiz (#{fiz}) entering foo with object_id #{fiz.object_id}"
  fiz =  "reference"
  puts "fiz (#{fiz}) leaving foo with object_id #{fiz.object_id}"
end

bar = "value"
puts "bar (#{bar}) before foo with object_id #{bar.object_id}"
foo(bar)
puts "bar (#{bar}) after foo with object_id #{bar.object_id}"

# Output
bar (value) before foo with object_id 60
fiz (value) entering foo with object_id 60
fiz (reference) leaving foo with object_id 80
bar (value) after foo with object_id 60

参数是原始引用的副本。因此，您可以更改值，但不能更改原始引用。

在传统术语中，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.)