understanding .self / class and instance variable in Ruby

Question

i am trying to understand the .self pointer , class and instance variable and their uses. I found many useful links but nothing seems to get into my head. like this medium post ::

medium.com - @/@@ vs. self in Ruby

here is the code I tried (filename = hello.rb)

class Person
    def instance_variable_get
        @instance_var = "instance variable"
    end

    def class_var
        @@class_var = "class variable"
    end

    def sayhi
        puts "this is a ins #{@instance_var}"
        puts "this is a cls #{class_var}"  #note i removed the @ sign from this.
    end

    def self.sayhi
        puts "this is a ins from class #{@instance_var}"
        puts "this is a cls from class #{@class_var}"
    end
end
bob = Person.new
bob.sayhi
Person.sayhi

and by executing this i got

cd@CD:~/Desktop$ ruby hello.rb 
this is a ins 
this is a cls class variable
this is a ins from class 
this is a cls from class 

how does this all thing work? what am I doing wrong? the result I am expecting from this is

this is a ins instance variable
this is a cls class variable
this is a ins from class instance variable
this is a cls from class class variable

Answer 1

That code doesn't actually work since you're not calling any of methods that set the variables. Its kind of a mess and I think I can explain this better with more idiomatic examples.

In Ruby instance variables are just lexically scoped local variables that are scoped to an object instance. They are always "private" but you can provide accessor methods to provide access from the outside (and the insider also):

class Person
  def initialize(name)
    @name = name
  end

  def name=(value)
    @name = name
  end

  def name
    @name
  end

  def hello
    "Hello, my name is #{name}"
  end
end

jane = Person.new("Jane")
puts jane.hello # "Hello, my name is Jane"
jane.name = "Jaayne"
puts jane.hello # "Hello, my name is Jaayne"

Inside the hello method self is the instance of Person that you are calling the the method on.

We can simply call name instead of self.name since its the implicit reciever. We could also write "Hello, my name is #{@name}" and it would give the exact same result since the getter method is just returning the instance variable.

Ending setter methods with = is just a convention that lets you use the method with the = operator. You can actually set instance variables from any method.

class Person
  attr_accessor :name

  def initialize(name)
    @name = name
  end

  def backwardize!
    @name = @name.reverse
  end
end

Class variables on the other hand are a whole different cup of tea. The scope of a class variable is a class - but the are also shared with any subclasses. This is an example of why they are best avoided:

class Vehicle
  def self.number_of_wheels=(value)
    @@number_of_wheels = value
  end

  def self.number_of_wheels
    @@number_of_wheels
  end
end

class Car < Vehicle
  self.number_of_wheels = 4  
end

puts Car.number_of_wheels # 4 - good

class Bike < Vehicle
  self.number_of_wheels = 2  
end

puts Bike.number_of_wheels # 2 - good
puts Car.number_of_wheels # 2 - WAAAT?!

Setting class variables from an instance method which you have done in your example is not commonly done. If you have an instance method that changes the behavior of all other instances of the same class it will often lead to a large amount of swearing.

Instead of class variables use class instance variables:

class Vehicle
  def self.number_of_wheels=(value)
    @number_of_wheels = value
  end

  def self.number_of_wheels
    @number_of_wheels
  end
end

class Car < Vehicle
  # you need to explicitly use self when calling setter methods
  # otherwise Ruby will think you're setting a local variable.
  self.number_of_wheels = 4  
end

puts Car.number_of_wheels # 4 - good

class Bike < Vehicle
  self.number_of_wheels = 2  
end

puts Bike.number_of_wheels # 2 - good
puts Car.number_of_wheels # 4 - good

This can be a mind boggling concept but just try to remember that in Ruby classes are just instances of Class.

You also seem to be somewhat confused about what instance_variable_get whould be used for. Its used to violate encapsulation and get the instance variables of an object from the outside.

class Foo
  def initialize
     @bar = "I'm Foo's secret"
  end
end

puts Foo.new.instance_variable_get(:@bar) # "I'm Foo's secret"

Violating encapsulation should not normally be how you structure your code but it can be very useful in some circumstances. It is not called when accessing instance variables from within an object. I don't think I have ever seen anyone redefine the method - just because you can doesn't mean you should.

Answer 2

Because the functions which assign values to variables are not called at all. Do something like this. This ensures the variable values are set when you run a method from object or class:

class Person
    @instance_var = "instance variable"
    @@class_var = "class variable"

    def sayhi
        puts "this is a ins #{@instance_var}"
        puts "this is a cls #{class_var}"  #note i removed the @ sign from this.
    end

    def self.sayhi
        puts "this is a ins from class #{@instance_var}"
        puts "this is a cls from class #{@class_var}"
    end
end
bob = Person.new
bob.sayhi
Person.sayhi

Additionally refer to this: Ruby class instance variable vs. class variable