Difference between various variables scopes in ruby

1. Class variables are the same for all instances, because they're class variables–associated with the class. Everything access the same variable, including each instance.

2. No. Local variables are just that–local. They may be local to a function, or local to the class declaration, which is different than being a class variable. Locals in a class declaration go out of scope when the class declaration ends.

3. That's because they're exactly the same–they're global. Global state is always evil; this is not a property of the language or environment. That said, some global state may be required–that's just the way it is. It makes sense to use global state when there's global state. The trick is to use global state properly, which is sometimes a non-trivial endeavor.

4. That's just how Ruby is.

5. One has already been given by Chris.

6. I would think this question would be largely self-answering. Global when the entire world needs access. Instance when it's specific to a class instance. Local when it's only required in a local scope (e.g., a method, a block (note differences between 1.8 and 1.9 with regard to block scope), etc.) Constant when the variable isn't supposed to change. A class variable when it's something that either every instance needs, or if exposed via a class method, something tightly associated with a class.

7. There is no "most use-cases", it totally depends on what you're doing with the variable. And public isn't the de facto choice in Java–it depends on the entity in question. Default Java scope is package-private (methods, properties). Which to use in Ruby depends entirely upon the use-case, noting that as with Java, and even more easily in Ruby, things can be circumvented.

Local variables are not equivalent to class ones, they are tied to the block you are in. Any local declared in a block can be used there. Class variables are tied to the class structure you are in. Defining a class is itself a block, so you might be able to access local variables similarly, but you'll find if you refer to your class in a different context you cannot refer to the local variable in the same fashion.

Global variables are considered bad form, if abused. OOP should help you structure your programs such that constants on the entire program aren't needed. Think of them as actually being global: if you can't vouch for its consistency to the entire world, like the value of PI or whether or not you love your wife, you probably shouldn't be making promises.

Once you get the hang of them, I find "Ruby Variable Scope" to be a good reference.

I found a good and in-depth explanation regarding different scopes and their visibilities in Ruby in the following link .Scopes and Visibilities with Examples in detail.

According to it ,

Class variable (@@a_variable): Available from the class definition and any sub-classes. Not available from anywhere outside.Instance variable (@a_variable): Available only within a specific object, across all methods in a class instance. Not available directly from class definitions.Global variable ($a_variable): Available everywhere within your Ruby script.Local variable (a_variable): It is available only in the particular method or block in ruby script. 

Some more explanation regarding Instance variables is : You can access instance variables in any method of that particular class. While local variables can't be accessed outside of the method. Below is an example from ruby monk which explains this concept thoroughly.

class Item   def initialize(item_name, quantity)       @item_name = item_name          @quantity = quantity   end  def show   puts @item_name   puts @quantity   supplier = "Acme corp"   puts supplier  endend Item.new("tv",1).show

Here supplier is a local variable which can be accessed from show method only in our example.Just try to declare the supplier variable in the initialize method and printing it out in show method. It will give an error as undefined variable supplier.

i hope it helps. :)