Private method calls...why can't you use self.priv_method syntax?


#1

Why is it that when you call a private method, you cannot use
self.the_priv_method?
Below is an example that works if you take out self before the method,
but fails with it in.
It is odd because using self should just a more explicit statement.
But either way the method is being sent to the same object.
WEIRD!!!
Please let me know how you gurus wrap your heads around this
(apparent) inconsistency.
Thanks,
Tim

class TestPrivate
def giveValue
@value
end
def callPriv
self.priv #why can’t you put the self in front of a private method?
end

private
def priv
@value = 100
end
end

i = TestPrivate.new
p i
i.callPriv
p i.giveValue

~> -:6:in callPriv': private methodpriv’ called for #<TestPrivate:

0x33e1f4> (NoMethodError)

~> from -:18

>> #TestPrivate:0x33e1f4


#2

In Ruby, private means that the method cannot be called with an
explicit receiver (that includes “self”). This is a bit different
then languages like C++ and Java which use private/protected to
control calling in inheritance chains. Remember, Ruby is all about the
callers and receivers. If you leave off the “self.” at the front, then
self is implicit (which is allowed for private methods. Try this:

class MyClass
def call_protected_on(obj)
obj.protected_method
end

def call_private_on(obj)
obj.private_method
end

protected
def protected_method
puts “Explicit callers are ok”
end

private
def private_method
puts “Implicit callers only!”
end
end

my_obj = MyClass.new
my_other_obj = MyClass.new
my_obj.call_protected_on(my_other_obj)
my_obj.call_private_on(my_other_obj)

Cheers,

Josh


#3

Josh, thanks for the clarification. I guess I just have to accept the
syntax for the private method calls. But it is hard for me to
understand why calling a private method on its own–which has to look
up self to use as a receiver, is any different than me just giving it
the receiver of self. Either way the same object is being used as the
receiver. So there must be something strange about the way private is
implemented that makes it not ever take receivers, even if you give it
the receiver that it is going to lookup and use. Okay, I can tell I am
just grumbling about something that I should just accept. Sorry.
Thanks again,
Tim