What does variable mean in Ruby

Question

What are Ruby variables preceded with double at signs       My understanding of a variable preceded with an at sign is that it is an instance variable  like this in PHP   PHP version  class Person        public  name       public function setName  name             this- gt name    name             public function getName             return  this- gt name            Ruby equivalent  class Person      def set name name           name   name     end      def get name            name     end end   What does the double at sign    mean  and how does it differ from a single at sign

User · Answer

The answers are partially correct because @@ is actually a class variable which is per class hierarchy meaning it is shared by a class, its instances and its descendant classes and their instances.

class Person
  @@people = []

  def initialize
    @@people << self
  end

  def self.people
    @@people
  end
end

class Student < Person
end

class Graduate < Student
end

Person.new
Student.new

puts Graduate.people

This will output

#<Person:0x007fa70fa24870>
#<Student:0x007fa70fa24848>

So there is only one same @@variable for Person, Student and Graduate classes and all class and instance methods of these classes refer to the same variable.

There is another way of defining a class variable which is defined on a class object (Remember that each class is actually an instance of something which is actually the Class class but it is another story). You use @ notation instead of @@ but you can't access these variables from instance methods. You need to have class method wrappers.

class Person

  def initialize
    self.class.add_person self
  end

  def self.people
    @people
  end

  def self.add_person instance
    @people ||= []
    @people << instance
  end
end

class Student < Person
end

class Graduate < Student
end

Person.new
Person.new
Student.new
Student.new
Graduate.new
Graduate.new

puts Student.people.join(",")
puts Person.people.join(",")
puts Graduate.people.join(",")

Here, @people is single per class instead of class hierarchy because it is actually a variable stored on each class instance. This is the output:

#<Student:0x007f8e9d2267e8>,#<Student:0x007f8e9d21ff38>
#<Person:0x007f8e9d226158>,#<Person:0x007f8e9d226608>
#<Graduate:0x007f8e9d21fec0>,#<Graduate:0x007f8e9d21fdf8>

One important difference is that, you cannot access these class variables (or class instance variables you can say) directly from instance methods because @people in an instance method would refer to an instance variable of that specific instance of the Person or Student or Graduate classes.

So while other answers correctly state that @myvariable (with single @ notation) is always an instance variable, it doesn't necessarily mean that it is not a single shared variable for all instances of that class.

User · Answer

denotes a class variable  i e  it can be inherited   This means that if you create a subclass of that class  it will inherit the variable  So if you have a class Vehicle with the class variable   number of wheels then if you create a class Car  lt  Vehicle then it too will have the class variable   number of wheels

User · Answer

and    in modules also work differently when a class extends or includes that module   So given  module A      a    module        a    module       def get1          a               end           def get2           a              end           def set1 a            a   a           end           def set2 a             a   a          end           def self set1 a           a   a           end           def self set2 a            a   a          end      end    Then you get the outputs below shown as comments  class X     extend A      puts get1 inspect   nil     puts get2 inspect    module        a    class         a    class        puts get1 inspect    class      puts get2 inspect    module       set1  set       set2  set        puts get1 inspect    set       puts get2 inspect    set        A set1  sset       A set2  sset        puts get1 inspect    set       puts get2 inspect    sset  end   class Y     include A      def doit         puts get1 inspect   nil         puts get2 inspect    module            a    class            a    class           puts get1 inspect    class          puts get2 inspect    class           set1  set           set2  set            puts get1 inspect    set          puts get2 inspect    set           A set1  sset           A set2  sset            puts get1 inspect    set          puts get2 inspect    sset      end end  Y new doit   So use    in modules for variables you want common to all their uses  and use   in modules for variables you want separate for every use context

User · Answer

- Instance variable of a class    - Class variable  also called as static variable in some cases  A class variable is a variable that is shared amongst all instances of a class  This means that only one variable value exists for all objects instantiated from this class  If one object instance changes the value of the variable  that new value will essentially change for all other object instances   Another way of thinking of thinking of class variables is as global variables within the context of a single class  Class variables are declared by prefixing the variable name with two   characters       Class variables must be initialized at creation time

User · Answer

A variable prefixed with   is an instance variable  while one prefixed with    is a class variable  Check out the following example  its output is in the comments at the end of the puts lines   class Test     shared   1    def value       shared   end    def value  value        shared   value   end end  class AnotherTest  lt  Test  end  t   Test new puts  t value is   t value     1 t value   2 puts  t value is   t value     2  x   Test new puts  x value is   x value     2  a   AnotherTest new puts  a value is   a value     2 a value   3 puts  a value is   a value     3 puts  t value is   t value     3 puts  x value is   x value     3   You can see that   shared is shared between the classes  setting the value in an instance of one changes the value for all other instances of that class and even child classes  where a variable named  shared  with one    would not be    Update   As Phrogz mentions in the comments  it s a common idiom in Ruby to track class-level data with an instance variable on the class itself  This can be a tricky subject to wrap your mind around  and there is plenty of additional reading on the subject  but think about it as modifying the Class class  but only the instance of the Class class you re working with  An example   class Polygon   class  lt  lt  self     attr accessor  sides   end end  class Triangle  lt  Polygon    sides   3 end  class Rectangle  lt  Polygon    sides   4 end  class Square  lt  Rectangle end  class Hexagon  lt  Polygon    sides   6 end  puts  Triangle sides     Triangle sides inspect      3 puts  Rectangle sides    Rectangle sides inspect     4 puts  Square sides       Square sides inspect        nil puts  Hexagon sides      Hexagon sides inspect       6   I included the Square example  which outputs nil  to demonstrate that this may not behave 100  as you expect  the article I linked above has plenty of additional information on the subject   Also keep in mind that  as with most data  you should be extremely careful with class variables in a multithreaded environment  as per dmarkow s comment

[ruby] What does @@variable mean in Ruby?

Examples related to ruby

Examples related to syntax

Examples related to instance-variables

Examples related to class-variables