Ruby alias Keyword

last modified April 27, 2025

This tutorial explains how to use Ruby’s alias keyword to create method aliases. Method aliasing provides alternative names for existing methods.

The alias keyword creates a new name for an existing method. The original method remains accessible. Aliases are permanent and affect all calls.

Aliasing is useful for backward compatibility, readability, or method augmentation. It works with both instance and class methods. Aliases can be defined inside classes or modules.

Basic Method Aliasing

This example shows the simplest use of alias to create an alternative method name. Both names refer to the same implementation.

basic_alias.rb

class Greeter def hello puts “Hello!” end

alias hi hello end

g = Greeter.new g.hello # => “Hello!” g.hi # => “Hello!”

The hi method becomes an exact copy of hello. Both methods can be called interchangeably. The alias persists for all instances.

Aliasing Built-in Methods

Ruby allows aliasing built-in methods. This example creates a more readable name for the puts method.

builtin_alias.rb

alias say puts

say “This works like puts” say 1, 2, 3

The say alias works exactly like puts, accepting multiple arguments. Global aliases affect the entire program scope.

Alias in Module Context

When used inside modules, alias affects all classes that include the module. This demonstrates module method aliasing.

module_alias.rb

module Logging def log(message) puts “[LOG] #{message}” end

alias record log end

class Service include Logging end

s = Service.new s.log(“Starting service”) # => “[LOG] Starting service” s.record(“Service started”) # => “[LOG] Service started”

Both log and record methods are available to any class including the Logging module. The alias works at the module level.

Method Augmentation with Alias

A common pattern uses alias to preserve original methods when augmenting behavior. This example adds logging to an existing method.

augmentation.rb

class Calculator def add(x, y) x + y end end

class EnhancedCalculator < Calculator alias original_add add

def add(x, y) puts “Adding #{x} and #{y}” original_add(x, y) end end

calc = EnhancedCalculator.new puts calc.add(3, 4) # Logs and returns 7

The original add method is preserved as original_add. The new version adds logging while maintaining the same interface.

Alias with Method Parameters

Method aliases preserve all original parameters. This example shows aliasing methods with different parameter patterns.

parameters.rb

class Formatter def format_name(first, last) “#{first} #{last}” end

alias full_name format_name

def format_date(year, month=1, day=1) “#{year}-#{month}-#{day}” end

alias date full_date=format_date end

f = Formatter.new puts f.full_name(“John”, “Doe”) # => “John Doe” puts f.date(2025) # => “2025-1-1”

Both required and optional parameters work correctly with aliases. The alias maintains the exact same signature as the original method.

Dynamic Aliasing

Ruby allows creating aliases dynamically using alias_method. This example shows runtime method aliasing based on conditions.

dynamic.rb

class DynamicAlias def greet puts “Hello!” end

def self.create_alias(new_name) alias_method new_name, :greet end end

DynamicAlias.create_alias(:welcome) DynamicAlias.create_alias(:salute)

obj = DynamicAlias.new obj.welcome # => “Hello!” obj.salute # => “Hello!”

The create_alias class method generates new aliases at runtime. This technique is useful for metaprogramming scenarios.

Alias Chains and Super

Aliases work correctly with inheritance and super. This example demonstrates method chaining through aliases.

inheritance.rb

class Parent def process puts “Parent processing” end end

class Child < Parent alias parent_process process

def process puts “Child preprocessing” parent_process puts “Child postprocessing” end end

Child.new.process

The output shows the complete call chain: Child’s preprocessing, Parent’s processing, and Child’s postprocessing. Aliases maintain proper inheritance.

Source

Ruby Keywords Documentation

This tutorial covered Ruby’s alias keyword with examples showing basic usage, method augmentation, dynamic aliasing, and inheritance patterns.

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.