calling class method from instance ..

[Larz]

I was puzzled on this but figured out a way to do it. Figured I'd post
it on here, maybe there's a better way ..

class Test

@c = 2
def self.ctest
puts @c
end

def initialize(i)
@i = i
end

def itest
puts @i
# here's what I was trying to do !!!
puts self.class.ctest
end

end

ob = Test.new(7)

ob.itest
Test.ctest

 

[Robert Dober]

puts self.class.ctest

IMHO this call syntax is optimal, because agnostic to the class name.
Robert

 

[7stud --]

puts self.class.ctest

What's the reason for not simply writing your class like this:

class Test
@c = 20

def Test.a
puts @c
end

def b
Test.a
end

end

t = Test.new
t.b

--output:--
20

 

[Rick DeNatale]

[Note: parts of this message were removed to make it a legal post.]

What's the reason for not simply writing your class like this:

class Test
@c = 20

def Test.a
puts @c
end

def b
Test.a
end

end

t = Test.new
t.b

--output:--
20

That's fine unless you want to, say, override the class method in a subclass

class TestSub < Test

def TestSub.a
puts "doin my own thang."
end
end

t = TestSub.new
t.b
--output is still--
20

 

[Robert Dober]

That's fine unless you want to, say, override the class method in a subclass

Good point, but there is another issue here.
Your project guru comes along and tells you: Nice code, but we should
not use the name Test (for a dumb reason of course).
Now you have to change Test to Check in your source
would you prefer to change it here

class Test
def a # multiply this with n entries
self.class.x
end
def self.a
...

or here

class Test
def a
Test.x
end
def Test.a

end


In other words the second version is not DRY and the worst penalty for
unDRYness is the need to change your code.

Robert

 

[Mike Gold]

def itest
puts @i
# here's what I was trying to do !!!
puts self.class.ctest
end

I think Object#class is something to be avoided in most cases. Frankly
it's none of your business what class was used to create an object. It
doesn't matter _how_ an object sprang into existence, what matters is
how it quacks.

I want to replace an object with a delegate with no ill effects. Or
with a mock object, or with whatever. But uses of Object#class defeat
this.

I would be inclined to make shared data explicit either with a constant
or a with a passed-in reference to the shared data, rather than implicit
with Object#class.

class Test
SHARED = Struct.newctest).new(2)

def itest
puts SHARED.ctest
end
end

Test.new.itest #=> 2