# The Ruby Koans: About Class Methods

The Ruby Koans are a fantastic resource to introducing the concepts and syntax of the Ruby programming language. In this post, we’ll explore the concepts posed by `about_class_methods.rb`: class methods, instance methods, and singleton methods.

## **Objects, Classes, and Class Objects**

Let's start with some fundamental truths:

* **Instances of a class are objects.**
    
* **A class itself is an instance of** `Class`**.**
    
* **Since classes are objects, they can have their own methods.**
    

### **Objects are instances of a class**

```ruby
class Dog
end

fido = Dog.new
puts fido.is_a?(Object)  # => true
```

Every object in Ruby inherits from `Object`, so even instances of `Dog` are objects.

### **Classes are objects too**

```ruby
puts Dog.is_a?(Class)  # => true
puts Dog.is_a?(Object) # => true
```

Since `Dog` itself is an instance of `Class`, it is both a **class** and an **object** at the same time.

## **Instance Methods vs. Class Methods**

Instance methods are methods that belong to a specific instance of a class and operate on that instance’s data, whereas class methods belong to the class itself and can be called without creating an instance.

### **Defining an Instance Method**

```ruby
class Dog
  def wag
    :instance_level_wag
  end
end

fido = Dog.new
puts fido.wag  # => :instance_level_wag
```

Here, `wag` is an **instance method**. Each instance of `Dog` (e.g., `fido`) can call this method.

### **Defining a Class Method**

There are multiple ways to define class methods:

#### **Using** `self.method_name`

```ruby
class Dog
  def self.class_method
    :dogs_class_method
  end
end

puts Dog.class_method  # => :dogs_class_method
```

By using `self.` inside the class definition, we define a **class method** directly on `Dog`.

#### **Using** `class << self` **(Singleton Class Syntax)**

```ruby
class Dog
  class << self
    def another_class_method
      :still_another_way
    end
  end
end

puts Dog.another_class_method  # => :still_another_way
```

This technique defines class methods using the singleton class, which is a special, hidden class that Ruby creates for each object to hold methods specific to that object. A singleton class (also called a metaclass or eigenclass) is unique to each object and allows defining methods that only that particular object can access. In this case, `class << self` opens up the singleton class of `Dog`, allowing us to define methods that belong only to the `Dog` class itself.

For example:

```ruby
class Dog
  class << self
    def bark
      'Woof!'
    end
  end
end

puts Dog.bark  # => 'Woof!'
```

This is equivalent to:

```ruby
class Dog
  def self.bark
    'Woof!'
  end
end

puts Dog.bark  # => 'Woof!'
```

Singleton methods can also be applied to individual instances:

```ruby
fido = Dog.new

def fido.speak
  'Arf!'
end

puts fido.speak  # => 'Arf!'
```

However, this method is only available to `fido`, not other instances of `Dog`.

## **Singleton Methods on Objects**

Since everything in Ruby is an object, we can define methods on individual instances:

```ruby
fido = Dog.new

def fido.wag
  :fidos_wag
end

puts fido.wag  # => :fidos_wag
```

However, this method **only applies to** `fido`, not other `Dog` instances:

```ruby
rover = Dog.new
puts rover.wag  # => NoMethodError
```

## **Class Instance Variables vs. Instance Variables**

Instance variables inside a class belong to **instances of that class**, whereas instance variables inside the class definition itself belong to the **class object**.

```ruby
class Dog
  attr_accessor :name
end

def Dog.name
  @name
end

fido = Dog.new
fido.name = "Fido"

puts fido.name  # => "Fido"
puts Dog.name   # => nil
```

The instance variable `@name` on `fido` does not affect `Dog` because `Dog.name` refers to an **instance variable on the class object**, not on an instance.

## **The Value of** `self` **in a Class Definition**

Inside a class definition, `self` refers to the class itself:

```ruby
class Dog
  puts self  # => Dog
end
```

Since `self` refers to the class, we can define class methods like this:

```ruby
class Dog
  def self.class_method2
    :another_way_to_write_class_methods
  end
end

puts Dog.class_method2  # => :another_way_to_write_class_methods
```

## **Returning Values from Class Definitions**

In Ruby, the **last expression** inside a class definition determines its return value:

```ruby
LastExpression = class Dog
                   21
                 end

puts LastExpression  # => 21
```

For example, this behavior can be used in metaprogramming to dynamically define constants or class-level settings based on computations performed within the class definition:

```ruby
DefaultLimit = class Configuration
                 100 * 2
               end

puts DefaultLimit  # => 200
```

Here, the last evaluated expression (`100 * 2`) is returned and assigned to `DefaultLimit`.

## **Calling Class Methods from Instances**

Although class methods belong to the class, instances can still access them indirectly:

```ruby
fido = Dog.new
puts fido.class.another_class_method  # => :still_another_way
```

This works because `fido.class` evaluates to `Dog`, and `Dog.another_class_method` is a valid class method.

## **Which Class Method Syntax Should You Use?**

Both of the following approaches work for defining class methods:

```ruby
class Demo
  def self.method_one
  end

  class << self
    def method_two
    end
  end
end
```

Which one should you prefer?

* `self.method_name` is more common and easier to read. This is usually what you should do.
    
* `class << self` is useful when defining multiple class methods at once.
    

Hopefully this post has clarified some key concepts in this chapter of the Koans. As you continue your Ruby journey, may you keep in mind (my personal favorite axiom from the test output): `mountains are merely mountains`.