Ruby extend Method

last modified April 27, 2025

This tutorial explains how to use Ruby’s extend method to add module functionality to objects. The extend method is a powerful way to mix in module methods at the object level.

The extend method adds module methods to the receiver’s singleton class. Unlike include, which affects instances, extend works on individual objects. This allows for flexible object augmentation.

Extended methods become available as instance methods on the extended object. This technique is useful for adding functionality to specific objects without affecting their class. Multiple modules can be extended in sequence.

Basic extend Example

This simple example demonstrates how to extend an object with module methods. The methods become available on that specific object only.

basic_extend.rb

module Greeter def greet “Hello from #{self}” end end

obj = Object.new obj.extend(Greeter)

puts obj.greet

The extend method adds Greeter module methods to obj. Now obj can call greet even though its class doesn’t include this method. Other objects of the same class won’t have this method.

Extending Class Objects

Since classes are objects in Ruby, we can extend them with module methods. This makes the methods available as class methods rather than instance methods.

extend_class.rb

module ClassMethods def class_info “Class name: #{name}” end end

class MyClass extend ClassMethods end

puts MyClass.class_info

Here extend adds class_info as a class method to MyClass. This is a common pattern for adding class-level functionality. The method becomes available on the class itself.

Multiple Module Extension

Multiple modules can be extended onto an object. The methods are added in the order they’re extended, with later modules taking precedence in case of conflicts.

multiple_modules.rb

module A def identify “From module A” end end

module B def identify “From module B” end end

obj = Object.new obj.extend(A, B)

puts obj.identify

The output shows B’s version of identify because it was extended last. The order of extension matters when methods have the same name. This demonstrates method lookup precedence.

Extending Inside Classes

The extend method can be used inside class definitions to add module methods to the class object itself. This is different from include.

class_extension.rb

module InstanceMethods def instance_identify “Instance method” end end

module ClassMethods def class_identify “Class method” end end

class MyClass include InstanceMethods extend ClassMethods end

puts MyClass.class_identify puts MyClass.new.instance_identify

This example shows the difference between include and extend. include adds instance methods, while extend adds class methods. Both are useful in different scenarios.

Dynamic Extension

Objects can be extended dynamically at runtime. This allows for flexible object behavior modification based on program conditions.

dynamic_extension.rb

module AdminFeatures def admin_action “Performing admin action” end end

module UserFeatures def user_action “Performing user action” end end

class User attr_accessor :role end

user = User.new user.role = :admin

user.extend(AdminFeatures) if user.role == :admin user.extend(UserFeatures) if user.role == :user

puts user.admin_action if user.role == :admin

The user object is extended with different modules based on its role. This pattern enables role-specific functionality without subclassing. The methods only exist on objects that need them.

Extending Core Objects

Ruby’s core objects can be extended with custom methods. This should be done judiciously to avoid conflicts and confusion.

core_extension.rb

module StringExtensions def shout upcase + “!” end end

str = “hello world” str.extend(StringExtensions)

puts str.shout puts “another string”.respond_to?(:shout) # false

Only the specific str object gets the shout method. Other strings remain unaffected. This is safer than monkey-patching the String class directly. It limits the scope of changes.

Extend vs Include

This example contrasts extend and include to clarify their different behaviors. They serve related but distinct purposes.

extend_vs_include.rb

module SharedMethods def identify “From SharedMethods” end end

class ExtendedClass extend SharedMethods end

class IncludedClass include SharedMethods end

puts ExtendedClass.identify puts IncludedClass.new.identify

ExtendedClass gets identify as a class method, while IncludedClass gets it as an instance method. This demonstrates the key difference between these two approaches to mixing in module functionality.

Source

Ruby Module#extend Documentation

This tutorial covered Ruby’s extend method with practical examples showing object extension, class methods, and dynamic behavior modification.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.