{"id":7041,"date":"2014-05-17T00:24:11","date_gmt":"2014-05-17T00:24:11","guid":{"rendered":"https:\/\/unknownerror.org\/index.php\/2014\/05\/17\/scope-of-class-variable-collection-of-common-programming-errors\/"},"modified":"2014-05-17T00:24:11","modified_gmt":"2014-05-17T00:24:11","slug":"scope-of-class-variable-collection-of-common-programming-errors","status":"publish","type":"post","link":"https:\/\/unknownerror.org\/index.php\/2014\/05\/17\/scope-of-class-variable-collection-of-common-programming-errors\/","title":{"rendered":"Scope of class variable-Collection of common programming errors"},"content":{"rendered":"

My notes below are taken from Metaprogramming Ruby (by Paolo Perrotta), which I happened to be reading right now just as I came across your question. I hope that these excerpts (page numbers will be in parentheses) and my explanation are helpful to you.<\/p>\n

Keep in mind that class variables<\/em> are different from class instance variables<\/em>.<\/p>\n

\n

A Class instance variable belongs to an object of class Class<\/code>, and is accessible only by the class itself – not by an instance or by a subclass. (106)<\/p>\n<\/blockquote>\n

The class variable<\/em>, on the other hand, belongs to class hierarchies<\/em>. That means that it belongs to any class as well as all descendants of that class.<\/p>\n

Here is an example from the author:<\/p>\n

@@v = 1\n\nclass MyClass\n  @@v = 2\nend\n\n@@v    # => 2\n<\/code><\/pre>\n
\n
You get this result because class variables don’t really belong to classes – they belong to class hierarchies<\/em>. Since @@v is defined in the context of main<\/code>, it belongs to main's<\/code> class Object<\/code>… and to all the descendants of Object<\/code>. MyClass<\/code> inherits from Object<\/code>, so it ends up sharing the same class variable. (107)<\/p>\n<\/blockquote>\n
But also, since your specific question has to do not only with classes but also with modules:<\/p>\n
\n
When you include a module in a class, Ruby will create an anonymous class that wraps the module and inserts the anonymous class in the chain, just above the including class itself. (26)<\/p>\n<\/blockquote>\n
So, as you look at B.ancestors<\/code>, you will see:<\/p>\n
=> [B, A, Object, Kernel, BasicObject]\n<\/code><\/pre>\n
Similarly, for C.ancestors<\/code>, you will see:<\/p>\n
=> [C, A, Object, Kernel, BasicObject]\n<\/code><\/pre>\n
If we keep in mind that class variables belong to class hierarchies, then the class variable @@foo<\/code>, as soon as it is defined in Module A<\/code> (and so, the anonymous class just above B<\/code> that is created as soon as B<\/code> includes A<\/code>), will belong to B<\/code> (and also to C<\/code>, since it includes A<\/code>).<\/p>\n
To put it simply:<\/p>\n
    \n
  1. When @@foo<\/code> was only defined in B<\/code> and in C<\/code> (but not in A<\/code>), then B<\/code> had a class variable @@foo<\/code> that was different than the class variable @@foo<\/code> in C<\/code>. This is because the class variables are only accessible to that class and to all descendants. But B<\/code> and C<\/code> are related through their ancestor A<\/code>, and not through their descendants.<\/li>\n
  2. As soon as @@foo<\/code> was defined in A<\/code>, that class variable became inherited by all descendants of A<\/code> – that is, B<\/code> and C<\/code>. From here on out, the reference to @@foo<\/code> in class B<\/code> is really referencing the class variable that belongs to A<\/code>. The original @@foo<\/code> which was defined in B<\/code> has been overwritten replaced (taken over by its ancestor). The same has happened to the @@foo<\/code> in C<\/code>. B<\/code> and C<\/code> can both write to and read from the same class variable @@foo<\/code>, since it belongs to their common ancestor, A<\/code>.<\/li>\n<\/ol>\n
    At this point, anyone of A<\/code>, B<\/code>, or C<\/code> can all modify @@foo<\/code>. For example:<\/p>\n
    class B\n  p @@foo  # => 3\n  @@foo = 1\nend\n\nmodule A\n  p @@foo  # => 1\nend\n<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
    My notes below are taken from Metaprogramming Ruby (by Paolo Perrotta), which I happened to be reading right now just as I came across your question. I hope that these excerpts (page numbers will be in parentheses) and my explanation are helpful to you. Keep in mind that class variables are different from class instance […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-7041","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts\/7041","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/comments?post=7041"}],"version-history":[{"count":0,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts\/7041\/revisions"}],"wp:attachment":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/media?parent=7041"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/categories?post=7041"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/tags?post=7041"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}