要理解这一点，你必须区分变量和这个变量代表什么。请考虑以下示例：

items = [1, 2, 3]
# the variable items points to an array we just instantiated
items = [4, 5, 6]
# items now points to a new array

如果ruby通过引用传递参数，那么在方法中使用它接收的参数也会使调用者向方法公开的变量指向一个新位置

items = [1, 2, 3]
def my_method array
    array = [4, 5, 6]
    return array
end
my_method(items) # --> [4, 5, 6]
items # --> [1, 2, 3]
# if ruby passed arguments by reference, items would now be [4, 5, 6]

现在ruby通过值传递参数，但是你收到的值是对内存中相同位置的引用，就像被调用者传递给你的值一样。换句话说，你得到的不是一个克隆，一个复制，而是同一个对象。

items = [1, 2, 3]
def my_method array
    array << 4
    return array
end
my_method(items) # --> [1, 2, 3, 4]
items # --> [1, 2, 3, 4]

如果你想让你的方法对它的参数没有副作用，你可以克隆它们。

在Ruby中，几乎所有的东西都是对象。在方法中，对象通过引用传递。

a = [1,2,3,4]

a是一个变量，它的值是数组的引用。

def someMethod(b)
#...
end

someMethod(a)

这里a的值是数组的引用，它在变量b中被接收。这意味着a和B都有值作为数组的引用。

def someMethod(b)
b = [4,5,6] 
end

这里B被赋予一个新的值，该值引用新数组。a仍然将原始数组的引用作为值。
数组是可变的，这意味着我们可以改变数组对象的内容。

a = [1,2,3]
a[1]= 5
puts a

将打印[1，5，3]
所有像数字这样的原始对象都是不可变对象。

a =5

a存储包含值5的整数对象的引用。

a = a +1

现在A存储包含值6的整数对象的引用。包含6的对象不同于包含5的对象。之前包含5的对象仍然包含5，但它的引用没有存储在任何地方。