self, Class Methods & Class Variables

In Ruby, self is a keyword that points at the current object, and it is the key to understanding class methods, the singleton class, and how class-level state is stored.

Learn self, Class Methods & Class Variables in our free Ruby course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a…

Part of the free Ruby course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

You'll learn what self means in each context, how to write class methods with def self.method and class << self , and why @@class variables are a trap you can avoid.

What You'll Learn in This Lesson

1️⃣ What Is self?

There is always a current object in Ruby, and self names it. At the top level it's the special main object; inside a class body it's the class; inside an instance method it's the object the method was called on. Reading self in each spot tells you exactly which object owns the code running there.

2️⃣ Class Methods: def self.method and class << self

A class method is called on the class itself, not on an instance — like Time.now or Array.new . The most common way to write one is def self.name . These make great factory methods that build and return a configured object.

When a class has several class methods, repeating def self. gets noisy. Open the singleton class once with class << self and define them all inside, just like ordinary methods.

3️⃣ Class Variables (@@) vs Class Instance Variables

A @@variable stores state at the class level and is shared by the class and all of its subclasses through one slot. That sharing is occasionally what you want — but it bites hard in inheritance, because a subclass assigning to the same name overwrites the parent's value. A class instance variable (a plain @var written in class scope) gives each class its own private copy instead.

🎯 Your Turn

Fill in the two blanks so User.total reports how many users were created. The shared @@total counter is appropriate here because there are no subclasses to surprise.

Common Errors (and the fix)

• ❌ Calling a class method on an instance: Temperature.new(0).from_celsius(100) raises NoMethodError . ✅ Fix: call class methods on the class: Temperature.from_celsius(100) .
• ❌ Forgetting self: def from_celsius(c) makes an INSTANCE method by mistake. ✅ Fix: write def self.from_celsius(c) for a class method.
• ❌ Subclass overwrites @@var: a subclass assigning a @@variable silently changes the parent's value. ✅ Fix: use a class instance variable ( @var in class scope) with accessors.
• ❌ self.attr = inside a method without setter: assigning self.name = "x" fails if there's no attr_writer :name . ✅ Fix: add attr_accessor :name or assign the @name ivar directly.

Mini-Challenge: A Factory with a Safe Counter

Combine everything: a class method factory that also tracks how many objects it has built — using a class instance variable so subclasses wouldn't interfere. Run with ruby book.rb .

Pro Tips

• 💡 Print self while learning: drop a puts self anywhere to see which object owns the code.
• 💡 Prefer class instance variables: reach for @var + accessors over @@var in any class that might be subclassed.
• 💡 Factories read well: def self.build(...) beats sprinkling setup logic across the caller.

📋 Quick Reference — self & Class-Level Code

Concept

Ruby Syntax

Class method

def self.name ... end

Many class methods

class << self ... end

Class variable (shared)

@@count = 0

Class instance var

@count (in class scope)

Class-level accessor

class << self; attr_accessor :x; end

Current object

self

Frequently Asked Questions

🎉 Lesson Complete!

• ✅ self is the current object — class in a class body, instance in a method
• ✅ def self.method defines a class method
• ✅ class << self groups many class methods and accessors
• ✅ @@variables are shared with subclasses — a common pitfall
• ✅ Class instance variables ( @var ) keep per-class state safely
• ✅ Next lesson: Constants & Freezing — naming, scoping, and immutability

Practice quiz

Continue this course

• Previous: Inheritance & super
• Next: Constants & Freezing