As you learn your way through Ruby’s OOP, you will eventually stumble upon the concept of object passing. It might not be very clear if Ruby uses pass-by-reference or pass-by-value to send objects to a method. So I’m going to explain how all that works.

What is pass-by-reference?

Pass-by-reference means that the arguments of a method are references to the variables that were passed into the method, and modifying the arguments modifies the original variables.

val = "Hello"

def my_method(arg)
  arg = "Hi"
end

my_method(val)
puts val # => In pass-by-reference the result would be "Hi"

If Ruby were pass-by-reference, changing the value of the argument (arg) would change the value of the variable val. That is because in pass-by-reference, arg is a reference, a memory address. It’s not the actual string "Hello".

What is pass-by-value?

On the other hand, pass-by-value means that the arguments of a method are the values of the variables that were passed into the method, and modifying the arguments does not modify the original variables.

val = "Hello"

def my_method(arg)
  arg = "Hi"
end

my_method(val)
puts val # => In pass-by-value the result would be "Hello"

What is a reference type?

There’s one more concept you need to understand before I can answer the main question. And that is about reference types.

A reference type is a type whose value is a reference to something else. Let me explain.

So when you pass the variable some_string to a method, the method receives a copy of some_string‘s value, which is a reference.

As you can see in the image, what is passed into my_method is not a reference to some_string. It’s the value of some_string. But that value is actually a reference to the Hey There! object.

That means that if you were to modify arg, the changes would be seen by some_string, because they are both refering the same object in memory.

Example:

some_string = "Hey There!"

def my_mehtod(arg)
  # Changing the value of `arg`
  arg = "Hello!"
end

my_mehtod(some_string)

puts "The value of some_string is: #{some_string}"
# => The value of some_string is: Hey There!

Now, let’s change the behavior of my_method to modify the object that it references.

some_string = "Hey There!"

def my_mehtod(arg)
  # Changing the value of the object it references
  arg.gsub!(/Hey/, "Hi")
end

my_mehtod(some_string)

puts "The value of some_string is: #{some_string}"
# => The value of some_string is: Hi There!

See what happened there? By changing the actual string that arg was refering to, made it visible to some_string because we changed the object that both arg and some_string refer to.

So is Ruby pass-by-reference or pass-by-value?

As you can see from the examples above, what is actually passed into the method is the value. But that value is actually a reference. So even though the terminology is confusing, I would say Ruby is pass-by-value, but all the values are references.