Digging Deeper

In this section we look at some of the inner workings of parameter-passing and object equality. I also discuss the value of parentheses for code clarity.

By Reference or By Value?

Earlier, I said that Ruby does not make a distinction between arguments that are passed “by value” and “by reference.” Even so, if you search the Internet, you’ll soon discover that Ruby programmers often get into arguments about how exactly arguments are passed. In many procedural programming languages such as Pascal or C, there is a clear distinction between arguments passed by value or by reference.

A by value argument is a copy of the original variable; you can pass it to a function and mess around with it, and the value of the original variable remains unchanged.

A by reference argument, on the other hand, is a pointer to the original variable. When this gets passed to a procedure, you are not passing a new copy but a reference to the bit of memory in which the original data is stored. So, any changes made inside the procedure are made to the original data and necessarily affect the value of the original variable.

So, which way does Ruby pass arguments? It’s actually pretty easy to resolve this issue. If Ruby passes by value, then it makes a copy of the original variable, and that copy will therefore have a different object_id. In fact, this is not the case. Try the arg_passing.rb program to prove this point.

arg_passing.rb

def aMethod( anArg )
    puts( "#{anArg.object_id}

" )
end

class MyClass
end


i = 10
f = 10.5
s = "hello world"
ob = MyClass.new


puts( "#{i}.object_id = #{i.object_id}" )
aMethod( i )
puts( "#{f}.object_id = #{f.object_id}" )
aMethod( f )
puts( "#{s}.object_id = #{s.object_id}" )
aMethod( s )
puts( "#{ob}.object_id = #{ob.object_id}" )
aMethod( ob )

This prints out the object IDs of an integer, a floating-point number, a string, and a custom object both when they are originally declared and when they are passed as arguments to the aMethod() method. In each case, the ID of the argument is the same as the ID of the original variable, so the arguments must be passed by reference.

Now, it may well be that in certain circumstances the passing of arguments could, “behind the scenes” so to speak, be implemented as “by value.” However, such implementation details should be of interest to writers of Ruby interpreters and compilers rather than to Ruby programmers. The plain fact of the matter is that if you program in a “pure” object-oriented way—by passing arguments into methods but only subsequently using the values that those methods return—the implementation details (by value or by reference) will be of no consequence to you.

Nevertheless, because Ruby can occasionally modify arguments (for example, using ! methods or <<, as explained in Modifying Receivers and Yielding New Objects in Modifying Receivers and Yielding New Objects), some programmers have formed the habit of using the modified values of the arguments themselves (equivalent to using by reference arguments in C) rather than using the values returned. In my view, this is a bad practice. It makes your programs reliant upon the implementation details of methods and should, therefore, be avoided.

Are Assignments Copies or References?

I said earlier that a new object is created when a value is yielded by some expression. So, for example, if you assign a new value to a variable called x, the object after the assignment will be a different object from the one before the assignment (that is, it will have a different object_id):

x = 10      # this x has one object_id
x +=1       # and this x has a different one

But it isn’t the assignment that creates a new object. It is the value that is yielded that causes a new object to be created. In the previous example, +=1 is an expression that yields a value (x+=1 is equivalent to the expression x=x+1).

Simple assignment of one variable to another does not create a new object. So, let’s assume you have one variable called num and another called num2. If you assign num2 to num, both variables will refer to the same object. You can test this using the equal? method of the Object class:

assign_ref.rb

num = 11.5
num2 = 11.5

    # num and num 2 are not equal
puts( "#{num.equal?(num2)}" )    #=> false

num = num2
    # but now they are equal
puts( "#{num.equal?(num2)}" )    #=> true

Tests for Equality: == or equal?

By default (as defined in Ruby’s Kernel module), a test using == returns true when both objects being tested are the same object. So, it will return false if the values are the same but the objects are different:

equal_tests.rb

ob1 = Object.new
ob2 = Object.new
puts( ob1==ob2 ) #=> false

In fact, == is frequently overridden by classes such as String and will then return true when the values are the same but the objects are different:

s1 = "hello"
s2 = "hello"
puts( s1==s2 ) #=> true

For that reason, the equal? method is preferable when you want to establish whether two variables refer to the same object:

puts( ob1.equal?(ob2) )    #=> false
puts( s1.equal?(s2) )      #=> false

When Are Two Objects Identical?

As a general rule, if you initialize 10 variables with 10 values, each variable will refer to a different object. For example, if you create two strings like this:

identical.rb

s1 = "hello"
s2 = "hello"

then s1 and s2 will refer to independent objects. The same goes for two floats:

f1 = 10.00
f2 = 10.00

But, as mentioned earlier, integers are different. Create two integers with the same value, and they will end up referencing the same object:

i1 = 10
i2 = 10

This is even true with literal integer values. If in doubt, use the equals? method to test whether two variables or values reference exactly the same object:

10.0.equal?(10.0) # compare floats - returns false
10.equal?(10)     # compare integers (Fixnums) - returns true

Parentheses Avoid Ambiguity

Methods may share the same name as local variables. For example, you might have a variable called name and a method called name. If it is your habit to call methods without parentheses, it may not be obvious whether you are referring to a method or a variable. Once again, parentheses avoid ambiguity:

parentheses.rb

greet = "Hello"
name = "Fred"

def greet
    return "Good morning"
end

def name
    return "Mary"
end

def sayHi( aName )
    return "Hi, #{aName}"
end

puts( greet )                 #=> Hello
puts greet                    #=> Hello
puts greet()                  #=> good morning
puts( sayHi( name ) )         #=> Hi, Fred
puts( sayHi( name() ) )       #=> Hi, Mary