What is the difference between local, instance, and class variables? [duplicate]

Question 1

What is an instance variable?

It's a variable that has an idependant value that pertains to this instance of a class. For example, a Person class could have @name and @age as instance variables. All instance of Person have a name and age, but each instance will have a different value for those things.

What is a class instance variable?

This is a little wierd, but you have to realize that the Person class is itself an instance of Class. So it too can have instance variables. This is often used to configure a class. Like perhaps to add an API key to a class so that all instance can be created with that data.

class PersonFetcher

  # class method can set class instance variables
  def self.set_api_key(key)
    @api_key = key
  end

  # instance method sets instance variables
  def set_name(name)
    @name = name
  end

end

What is the difference between a variable, @instance_var and @class_instance_var?

How it persists.

variable is local. It's simply a reference to an object. Once no code or object has a reference to this value it is destroyed via garbage collection. It only persists if you keep using it.

@instance_var persists on an instance. So long as the instance persists, the instance variables it has will as well. So long as the Person instance exists, that instance will have a @name.

@class_instance_var persists on the class object (which remember is an instance of Class). So it will exist in the class object forever, since you can never really get rid of declared classes.

Question 2

Variable Type Affects Scope

There are many canonical explanations on the web, and some in-depth explanations elsewhere on SO, but I'll share with you another way of looking at it: variable scope.

Local Variables

A local variable is typically used in a method, and has only local scope. For example:

def foo
  # bar is only in scope within #foo.
  bar = true
end

The bar variable goes out of scope whenever the method returns.

Instance Variables

Instance variables are available to any method bound to an object instance. As a practical matter, this generally gives it scope within some instantiated class object. For example:

class Foo
  def bar
    @quux = true
  end

  def baz
    @quux == true
  end
end

foo = Foo.new

While @quux isn't truly global, it is visible to all methods bound to our instantiated foo object without the need to pass it around explicitly as a parameter.

Class Variables

Class variables are shared among all instances of a class. That means that if you change @@bar from instance foo, then the value is also changed for instance bar.

class Foo
  @@bar = true

  def show_class_variable
    @@bar
  end

  def bar= value
    @@bar = value
  end
end

foo = Foo.new
bar = Foo.new

foo.show_class_variable # => true
bar.show_class_variable # => true

foo.bar = false
foo.show_class_variable # => false
bar.show_class_variable # => false

Note how changing @@bar affected both instances simultaneously. That's the beauty (and the horror) of class variables.

Question 3

You could find alot of articles in regards with a simple google search:

http://blog.codegram.com/2011/4/understanding-class-instance-variables-in-ruby

http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/

Question 4

A varaible is something local to a method and thus should be defined in this method, an instance variable is a variable that is defined for (instance of) an object of the given class and has a value for each object. A class instance variable is denoted with @@(as opposed to the single @ you mention) and is shared between all instances of a class and if one of them changes its value then all the instances will see the new value. A class instance variable is equivelent to c++ and java's static member variables and the instance variables are equivelent to the non-static ones.

Question 5

Instance variables are defined at the moment when a class has been instaniated. Suppose you have a class Point, which define some local variables and methods.

class Point
  def initialize(x,y)
     @x, @y = x, y
  end

  def add(other)
     Point.new(@x + other, @y + other)
  end
end

When you instantiate the defined class and assign it to a variable you are instantiating the class:

point = Point.new(2,2)

..this is the instance variable.

Classes in Ruby are Objects and can have instance variables as other objects can. An instance variable defined inside a class definition, but outside an instance method definition is called class instance variable.

Example:

class Point 
  @n = 0
  @total_x = 0
  @total_y = 0

  def initialize(x,y)
     @x,@y = x,y
  end
end

There is a third one, namely the class variable. Class variables are visible to, and shared by the class methods and the instance methods of the class. Like instance variables, class variables can be used by the implementation of a class, but they are not visible to the users of the class. Class variables begin with @@. Instance variables are always evaluated in reference to self. This is a significant difference from class variables, which are always evaluated in reference to the class object created by the enclosing class definition statement. Using the same example we can rewrite the code as follows:

class Point
   @@n = 0
   @@total_x = 0
   @@total_y = 0

   def initialize(x,y)
      @x,@y = x, y
      @@n += 1
   end

   def self.report
      puts "Number of points: #{@@n.to_s}"
   end
end