Re: instance variable in pseudo-global scope

On Wed, Jun 1, 2011 at 2:37 PM, Sean O'Halpin <[e-mail]>wrote:

> On Wed, Jun 1, 2011 at 6:01 PM, Chad Perrin <[e-mail]> wrote:
> > As I understand things:
> >
> > * Variables whose names have no leading sigil have local scope.
> >
> > * Instance variables are local scope for the particular instance of a
> >  class within which they "live".
> >
> > * A Ruby program's "global" scope is actually the scope of an instance of
> >  Object (or, under certain circumstances, maybe it could be an instance
> >  of something further down the class inheritance hierarchy . . . ?).
> >
> > As such, it seems that within your program's "global" scope (not truly
> > global, but close enough for government work in most cases), the
> > effective difference between variables named foo and @foo is nothing but
> > one character.  Is there some technical difference that might have an
> > effect on the "behavior"[0] of the code I write, as long as neither of
> > them is being exported to some other running code or enclosed in a more
> > restricted scope within my program?
> >
> > ## NOTES
> >
> > [0]:  Someone actually flamed me for referring to the "behavior" of some
> > code, once upon a time -- thus the scare quotes around behavior in this
> > case.
> >
> > --
> > Chad Perrin [ original content licensed OWL: http://owl.apotheon.org ]
> >
>
> Well, @vars in main are visible to methods defined in main. For example:
>
> @foo = 1
> foo = 1
>
> def bar
>  @foo = 10
> end
>
> def baz
>  foo = 10
> end
>
> bar
> baz
>
> p @foo   # => 10
> p foo    # => 2
>
> Is that the kind of difference you're interested in?
>
> Regards,
> Sean
>
>
You will get 10 and 1 as output, not 10 and 2.



I think everyone knows how the local var works, so it's not that
interesting. I think what is much more interesting is the instance var will
change depending on who invokes the foo method.


@foo = 1

def bar
  @foo = 10
end

class C
  @foo # => nil # !> instance variable @foo not initialized
  bar
  @foo # => 10
end

@foo   # => 1


So no, its not that global. But TBH, I'm not sure how I feel about defining
methods and instance vars in main, there are a number of quirky behaviours
like this. I I've started to opt for defining them on main's
singleton_class, unless I really do want them to be "global", which, on any
decently sized project, isn't very common.