Ruby defined? Operator

last modified April 27, 2025

This tutorial explains how to use Ruby's defined? operator. It checks if a variable, method, or expression is defined and returns its type.

The defined? operator is a special keyword that tests existence of Ruby entities. It returns a string describing what it found or nil if undefined.

This operator helps prevent errors by safely checking for definitions before use. It works with variables, methods, constants, and other Ruby language elements.

Basic variable checking

This example shows how to check if local, instance, and global variables exist. The defined? operator returns different strings for each type.

basic_variables.rb

local_var = 10
@instance_var = 20
$global_var = 30

puts defined?(local_var)    # "local-variable"
puts defined?(@instance_var) # "instance-variable"
puts defined?($global_var)   # "global-variable"
puts defined?(unknown_var)   # nil

The operator returns descriptive strings for defined variables and nil for undefined ones. This helps distinguish between variable types and states.

Checking method existence

The defined? operator can verify if methods are available. It checks both built-in methods and user-defined ones.

method_checking.rb

def greet
  "Hello"
end

puts defined?(greet)       # "method"
puts defined?(puts)        # "method"
puts defined?(unknown_method) # nil

# With parameters
puts defined?(greet())     # "method"

The operator returns "method" for both defined methods, including Ruby core methods. Parentheses are optional but can clarify method checking.

Constant verification

Constants behave differently than variables in Ruby. The defined? operator helps check their existence before access.

constant_checking.rb

PI = 3.1415
module MyModule
  VERSION = "1.0"
end

puts defined?(PI)              # "constant"
puts defined?(MyModule::VERSION) # "constant"
puts defined?(UNKNOWN_CONST)   # nil

Constants must be fully qualified with their module when nested. The operator returns "constant" for defined constants regardless of scope.

Checking expressions

The defined? operator can test entire expressions, not just simple identifiers. This helps verify complex operations before execution.

expression_checking.rb

x = 10
y = 20

puts defined?(x + y)      # "method"
puts defined?(x.foo)      # nil
puts defined?(x.methods)  # "method"
puts defined?(x[0])       # nil

Mathematical operations return "method" as they use the + method. Undefined operations return nil. This helps prevent NoMethodError exceptions.

Superclass method checking

When working with inheritance, defined? can check if a superclass implements a method. This is useful for method overriding scenarios.

superclass_checking.rb

class Parent
  def inherited_method
    "Parent method"
  end
end

class Child < Parent
  def inherited_method
    if defined?(super)
      super + " extended"
    else
      "No parent method"
    end
  end
end

puts Child.new.inherited_method # "Parent method extended"

The example safely checks for a superclass implementation before calling it. This pattern prevents errors when parent classes might not define the method.

Conditional assignment

Combining defined? with conditional logic enables safe variable initialization. This prevents reinitialization of existing variables.

conditional_assignment.rb

$counter ||= 0

unless defined?($counter)
  $counter = 0
end

def increment
  $counter += 1
end

increment
puts $counter # 1

Both patterns ensure variables exist before use. The defined? version is more explicit and works with nil/false values unlike ||=.

Checking yield and blocks

The operator can test if a block was given to a method using yield. This helps make methods block-optional.

yield_checking.rb

def process
  if defined?(yield)
    yield
  else
    "No block given"
  end
end

puts process { "Block provided" } # "Block provided"
puts process                      # "No block given"

The method adapts its behavior based on block presence. This creates more flexible APIs that work with or without blocks.

Source

Ruby Keywords Documentation

This tutorial covered Ruby's defined? operator with practical examples showing variable, method, and expression checking 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.

Ebooks