Object Model & Everything is an Object

Ruby Object Model Mastery

Understand Ruby's fundamental principle: "Everything is an object." Master the object model, BasicObject hierarchy, and how Ruby's object-oriented design influences every aspect of the language.

Everything is an Object

Ruby's Core Philosophy: In Ruby, everything is an object - numbers, strings, classes, modules, even true, false, and nil. This unified object model makes Ruby incredibly consistent and powerful.

Proving Everything is an Object

# Numbers are objects
42.class
# => Integer
42.methods.count
# => 170+ methods!
42.even?
# => true

# Strings are objects
"hello".class
# => String
"hello".upcase
# => "HELLO"
"hello".reverse
# => "olleh"

# Even true, false, and nil are objects!
true.class
# => TrueClass
false.class
# => FalseClass
nil.class
# => NilClass

# Classes are objects too!
String.class
# => Class
Class.class
# => Class

# Methods are objects
method_obj = "hello".method(:upcase)
method_obj.class
# => Method
method_obj.call
# => "HELLO"

Ruby Object Hierarchy

Object Hierarchy: Ruby's object system is built on a clear hierarchy starting with BasicObject at the root, providing a clean and consistent foundation for all objects.

The Object Hierarchy Tree

# Ruby Object Hierarchy
BasicObject
└── Object
    ├── String
    ├── Numeric
    │   ├── Integer
    │   └── Float
    ├── Array
    ├── Hash
    ├── Class
    ├── Module
    ├── TrueClass
    ├── FalseClass
    ├── NilClass
    └── ... (all other classes)

# Verify the hierarchy
String.superclass
# => Object
Object.superclass
# => BasicObject
BasicObject.superclass
# => nil (top of hierarchy)

# Check if everything inherits from Object
42.is_a?(Object)
# => true
"hello".is_a?(Object)
# => true
[1, 2, 3].is_a?(Object)
# => true
String.is_a?(Object)
# => true (classes are objects too!)

BasicObject vs Object

# BasicObject - minimal object with almost no methods
BasicObject.instance_methods
# => [:==, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]

# Object - adds common methods we expect
Object.instance_methods.count
# => 60+ methods
Object.instance_methods.include?(:to_s)
# => true
Object.instance_methods.include?(:inspect)
# => true
Object.instance_methods.include?(:class)
# => true

# Why BasicObject exists - for proxy objects
class
MinimalProxy
 < BasicObject
  def
initialize
(target)
            @target = target
  end

  def
method_missing
(method, *args, &block)
            @target.send(method, *args, &block)
  end
end

proxy = MinimalProxy.new("hello")
proxy.upcase
# => "HELLO" (delegated to target)

Object Identity & Equality

Object Identity: Every object in Ruby has a unique identity (object_id) and various ways to compare objects for equality and identity.

Object Identity Methods

# Object identity - unique ID for each object
str1 = "hello"
str2 = "hello"
str3 = str1

str1.object_id
# => 70368527277240 (unique number)
str2.object_id
# => 70368527277220 (different object)
str3.object_id
# => 70368527277240 (same as str1)

# Identity comparison with equal?
str1.equal?(str2)
# => false (different objects)
str1.equal?(str3)
# => true (same object)

# Value comparison with ==
str1 == str2
# => true (same content)
str1 == str3
# => true (same content)

# Special case: small integers and symbols are cached
42.equal?(42)
# => true (same object!)
:symbol.equal?(:symbol)
# => true (symbols are immutable and cached)

Object Inspection and Debugging

# Object inspection methods
obj = "Hello Ruby"

obj.class
# => String
obj.inspect
# => "\"Hello Ruby\"" (shows quotes)
obj.to_s
# => "Hello Ruby" (string representation)

# Object introspection
obj.methods.count
# => 180+ (all available methods)
obj.instance_variables
# => [] (strings have no instance variables)
obj.respond_to?(:upcase)
# => true

# Object ancestry
String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]

# Check object type
obj.kind_of?(String)
# => true
obj.kind_of?(Object)
# => true
obj.instance_of?(String)
# => true (exact class match)

Classes as Objects

Classes are Objects: In Ruby, classes themselves are objects! They're instances of the Class class and can be manipulated at runtime like any other object.

Classes as First-Class Objects

# Classes are instances of Class
String.class
# => Class
Array.class
# => Class
Class.class
# => Class (even Class is an instance of Class!)

# Classes have methods like any object
String.methods.include?(:new)
# => true
String.respond_to?(:ancestors)
# => true

# You can store classes in variables
my_class = String
instance = my_class.new("hello")
instance.class
# => String

# Classes can be created dynamically
DynamicClass = Class.new do
  def
greet
    "Hello from dynamic class!"
  end
end

obj = DynamicClass.new
obj.greet
# => "Hello from dynamic class!"

Metaclasses and Eigenclasses

# Every object has a hidden eigenclass (singleton class)
str = "hello"
eigenclass = str.singleton_class
eigenclass.class
# => Class

# Add methods to specific objects
def
 str.shout

self.upcase + "!!!"

end

str.shout

# => "HELLO!!!"

other_str = "world"

other_str.respond_to?(:shout)

# => false (method only on str object)

# Class methods are singleton methods on the class object

class

MyClass

def

self

.class_method

"I'm a class method"

end

MyClass.singleton_class.instance_methods(false)

# => [:class_method]

What You've Learned

Key Takeaways

Everything is an object: Numbers, strings, classes, modules, and even nil are objects with methods
Object hierarchy starts with BasicObject: The minimal root class with essential methods only
Object identity vs equality: Use equal? for identity, == for value comparison
Classes are objects too: They're instances of Class and can be manipulated at runtime
Eigenclasses enable singleton methods: Each object can have unique behavior via its hidden singleton class

Try It Yourself - Interactive Practice

Learning Tip: The best way to understand Ruby's object model is by exploring it hands-on! Use these examples to discover how objects, classes, and methods work together.

Interactive Code Runner

Ruby Code Editor

# Ruby Object Model Exploration
# Discover Ruby's "everything is an object" philosophy!

# 1. Everything is an Object
puts "=== Everything is an Object ==="
puts 42.class
puts 42.methods.count
puts 42.even?
puts

puts "hello".class
puts "hello".methods.include?(:upcase)
puts true.class
puts nil.class
puts String.class
puts Class.class

# 2. Object Hierarchy
puts "\n=== Object Hierarchy ==="
puts String.superclass
puts Object.superclass
puts BasicObject.superclass

# Check inheritance
puts "hello".is_a?(Object)
puts "hello".is_a?(BasicObject)
puts String.is_a?(Object)

# 3. Object Identity vs Equality
puts "\n=== Identity vs Equality ==="
str1 = "hello"
str2 = "hello"
str3 = str1

puts "str1.object_id: #{str1.object_id}"
puts "str2.object_id: #{str2.object_id}"
puts "str3.object_id: #{str3.object_id}"

puts "str1 == str2: #{str1 == str2}"  # value comparison
puts "str1.equal?(str2): #{str1.equal?(str2)}"  # identity comparison
puts "str1.equal?(str3): #{str1.equal?(str3)}"

# Special case: small integers
puts "42.equal?(42): #{42.equal?(42)}"
puts ":symbol.equal?(:symbol): #{:symbol.equal?(:symbol)}"

# 4. Classes as Objects
puts "\n=== Classes as Objects ==="
puts String.class
puts String.methods.include?(:new)

# Store class in variable
my_class = String
instance = my_class.new("dynamic!")
puts instance.class

# Create class dynamically
DynamicClass = Class.new do
  def greet
    "Hello from dynamic class!"
  end
end

obj = DynamicClass.new
puts obj.greet

# 5. Eigenclasses and Singleton Methods
puts "\n=== Singleton Methods ==="
str = "hello"

# Add method to specific object
def str.shout
  self.upcase + "!!!"
end

puts str.shout
puts str.singleton_class

# Other strings don't have this method
other_str = "world"
puts "other_str responds to shout?: #{other_str.respond_to?(:shout)}"

# Experiment with your own examples below!

Output will appear here when you run the code...

Ruby Language

Rails Framework

Production Ready