Scope of class instance variables?

Ruby
1

I am reading Hal F.'s “The Ruby Way” On page 57 he makes the
statement:
“Class instance variables cannot be referenced from within instance
methods and, in general are not very useful”

huh?..
This , in my feeble mind, contradicts everything else I have ever
read, except that the example he gives is similar to the @y = 7
example below, and in that case, @y is not available to the accessor
or any other method that I have played with.

In the following code, the original assignment of @x = 7 and @y = 5
don’t seem to do anything, even with the attr_accessor. I know that
both are read by the compiler as I can assign @y = 5/0 and get a
division by zero error.

So, could someone please explain why the accessor for @y does not work
here. If I hand write a reader and writer for @y, it works just fine.
There are different scopes here, but I had the impression that the
accessor would break down that barrier and make @y available
throughout the class just as the initialize method is able to access
the class variable @x and assign the passed in value. That value is
then available to the @x accessor.

I thought for a while that the @y accessor might work in the singleton
class of Myclass, but it doesn’t.

class Myclass
attr_accessor :y, :x

@x = 7
@y = 5

def initialize(new_val= l)
@x = new_val ? new_val : 0
end
end

mc = Myclass.new(3)

puts mc.y #=> Nil
puts mc.x #-> 3

I know I can make the @x and @y class variables available to instance
methods by referencing them inside defined methods and the scope seem
to be class wide, but it just seems like the first assignments above
should work as written.

Thanks in advance

2

On Mar 29, 11:40 am, Ruby F. [email protected] wrote:

I am reading Hal F.'s “The Ruby Way” On page 57 he makes the
statement:
“Class instance variables cannot be referenced from within instance
methods and, in general are not very useful”

I think that just an out-dated way of looking at things. I expect Hal
would agree that needs to be updated to current trends.

I remember once, Hal and I got in a big argument about floating-point
arithmetic. A tad spiteful I pointed out a flaw in his book. Despite
the heated argument, he took it quite gracefully, saying he was always
happy to receive comments/corrections. That was pretty damn
respectable, IMHO. If he doesn’t see this thread, write him directly.

T.

3

unsuscribe

2008/3/29, Trans [email protected]:

4

unsubscribe

2008/3/29, surreal [email protected]:

5

On Mar 29, 9:39 am, surreal [email protected] wrote:

unsuscribe

would agree that needs to be updated to current trends.
Harshad Joshi

–
Harshad Joshi

Thanks Trans.

I guess Harshad didn’t like my post! :slight_smile:

Anyway, I would still appreciate an explanation for the difference in
scope, or the reason the first assignment doesn’t work.

Thanks

6

On Sat, Mar 29, 2008 at 4:40 PM, Ruby F. [email protected]
wrote:

or any other method that I have played with.
throughout the class just as the initialize method is able to access
the class variable @x and assign the passed in value. That value is
then available to the @x accessor.

I thought for a while that the @y accessor might work in the singleton
class of Myclass, but it doesn’t.

class Myclass

make this

     class << self

    attr_accessor :y, :x

     end

Now this is an accessor to the singleton class of the class where the
class instance variables are stored (that is not completely correct,
maybe I shall say from where one has access to them).

    @x = 7
    @y = 5

    def initialize(new_val= l)
            @x = new_val ? new_val : 0

and this shall read

                self.class.x = new_val || 0

    end

end

puts mc.y #=> Nil
Myclass.x → 7
mc = Myclass::new( 42 )
Myclass.x → 42
mc = Myclass::new 101010
Myclass.x → 101010
there is of course no mc.x but please see below.

I do however fear that you confuse instance variables with class
instance variables.
The former exist on an per object base and the later on a per class
base ( a class being an object of course ).
For completeness I’ll show you how to use the former

class A
attr_accessor :a
def initialize; @a = 42 end
end
a= A.new
a.a → 42
b = A.new
a.a = 101010
a.a → 101010
b.a → 42

HTH
Robert

http://ruby-smalltalk.blogspot.com/

Whereof one cannot speak, thereof one must be silent.
Ludwig Wittgenstein