Understanding Ruby Variables: Scope and Persistence

Table of Contents

1. What Are Variables in Ruby?
2. Ruby Variable Types
3. Scope: Where Variables Live
   • Local Variables
   • Instance Variables
   • Class Variables
   • Global Variables
   • Constants
   • Block Scope: A Special Case
4. Persistence: How Long Variables Last
   • Local Variables
   • Instance Variables
   • Class Variables
   • Global Variables
   • Constants
5. Variable Scope & Persistence: A Comparison Table
6. Common Pitfalls & Best Practices
7. Conclusion
8. References

What Are Variables in Ruby?

In Ruby, variables are dynamically typed, meaning you don’t need to declare their data type (e.g., String, Integer). Instead, Ruby infers the type based on the value assigned. For example:

name = "Alice"  # String
age = 30        # Integer
is_student = true  # Boolean

What makes Ruby variables unique is their contextual behavior. The same variable name (e.g., count) can behave differently depending on how it’s declared (e.g., count, @count, @@count, $count). This is where scope and persistence come into play.

Ruby Variable Types

Ruby has five primary variable types, each with distinct syntax, scope, and persistence rules. Let’s list them upfront before diving into details:

Scope: Where Variables Live

Scope determines the “visibility” of a variable. A variable is only accessible within its scope; outside of it, Ruby treats it as undefined. Let’s explore how scope works for each variable type.

Local Variables (Scope)

Syntax: Start with a lowercase letter or underscore (e.g., x, user_name, _temp).

Local variables have the narrowest scope in Ruby. They are scoped to the lexical context where they are defined, such as:

• A method or function.
• A block (e.g., do...end, {}).
• A loop, conditional, or begin...end block.

Example 1: Local variable in a method

def greet
  message = "Hello, Ruby!"  # Local to `greet` method
  puts message
end

greet  # Output: "Hello, Ruby!"
puts message  # Error: undefined local variable or method `message'

Here, message exists only inside the greet method. Outside the method, it’s undefined.

Example 2: Local variable in a block
Blocks (e.g., with each, map, or custom procs) create their own lexical scope. However, blocks are closures: they can access local variables from the surrounding (outer) scope but cannot modify them unless explicitly declared.

outer_var = "I'm outside!"

[1, 2, 3].each do |num|
  inner_var = "I'm inside the block!"  # Local to the block
  puts outer_var  # Accessible: "I'm outside!"
  puts inner_var  # Accessible: "I'm inside the block!"
end

puts inner_var  # Error: undefined local variable or method `inner_var'

Instance Variables (Scope)

Syntax: Start with @ (e.g., @name, @balance).

Instance variables are scoped to individual object instances. They belong to a specific instance of a class and are accessible to all instance methods of that object.

Example:

class User
  def initialize(name)
    @name = name  # Instance variable initialized in the constructor
  end

  def greet
    "Hello, #{@name}!"  # Accessible in instance method
  end
end

user1 = User.new("Alice")
puts user1.greet  # Output: "Hello, Alice!"

user2 = User.new("Bob")
puts user2.greet  # Output: "Hello, Bob!"

puts @name  # Error: undefined instance variable `@name' (no object context)

Here, @name is unique to user1 and user2. Outside of an instance method (or without an explicit object context), @name is undefined.

Class Variables (Scope)

Syntax: Start with @@ (e.g., @@count, @@default_timeout).

Class variables are scoped to the class hierarchy (the class and all its subclasses). They are shared across all instances of the class and its subclasses.

Example:

class Animal
  @@total_animals = 0  # Class variable

  def initialize
    @@total_animals += 1  # Incremented for every new instance
  end

  def self.total_animals  # Class method to access @@total_animals
    @@total_animals
  end
end

class Dog < Animal; end  # Subclass of Animal

# Create instances
Animal.new
Dog.new
Dog.new

puts Animal.total_animals  # Output: 3 (1 Animal + 2 Dogs)
puts Dog.total_animals     # Output: 3 (shares @@total_animals with Animal)

Class variables are accessible in both instance methods and class methods of the class (and subclasses).

Global Variables (Scope)

Syntax: Start with $ (e.g., $debug_mode, $stdout).

Global variables have the broadest scope: they are accessible everywhere in your Ruby program, including inside classes, methods, and blocks.

Example:

$app_version = "1.0.0"  # Global variable

class Logger
  def log(message)
    puts "[#{$app_version}] #{message}"  # Accessible here
  end
end

logger = Logger.new
logger.log("System started")  # Output: "[1.0.0] System started"

def helper_method
  puts "Version: #{$app_version}"  # Also accessible here
end

helper_method  # Output: "Version: 1.0.0"

Constants (Scope)

Syntax: Start with an uppercase letter (e.g., API_URL, MAX_ITEMS).

Constants are scoped to the module or class where they are defined. They are accessible wherever that module/class is visible (e.g., inside the module, its submodules, or via explicit references like MyModule::CONSTANT).

Example:

module Config
  MAX_RETRIES = 3  # Constant in a module
end

class API
  def fetch_data
    retries = 0
    while retries < Config::MAX_RETRIES  # Access via module reference
      # ... fetch logic ...
      retries += 1
    end
  end
end

puts Config::MAX_RETRIES  # Output: 3 (explicit access)

Constants can also be defined at the top level (outside any module/class), making them globally accessible (but still scoped to the top-level namespace).

Block Scope: A Special Case

Blocks (e.g., each, map, loop) have unique scoping rules. Unlike methods, blocks inherit local variables from their outer lexical scope (the code surrounding the block). This is because blocks are closures—they “capture” variables from the scope where they are defined.

Example: Block accessing an outer local variable

greeting = "Hello"  # Outer local variable

["Alice", "Bob"].each do |name|
  puts "#{greeting}, #{name}!"  # Uses `greeting` from outer scope
end
# Output:
# Hello, Alice!
# Hello, Bob!

Caveat: Shadowing variables in blocks
If you assign a new value to a variable inside a block with the same name as an outer variable, Ruby treats it as a new local variable inside the block (unless the variable is already defined in the outer scope).

count = 0  # Outer variable

[1, 2, 3].each do |num|
  count = num  # Reassigns the outer `count` (since it’s already defined)
end

puts count  # Output: 3 (outer `count` was modified)

# If the outer variable is NOT defined:
[1, 2, 3].each do |num|
  temp = num  # `temp` is local to the block
end

puts temp  # Error: undefined local variable or method `temp'

Persistence: How Long Variables Last

Persistence refers to the lifecycle of a variable’s value—how long it remains in memory before being discarded.

Local Variables (Persistence)

Local variables have the shortest persistence. They exist only for the duration of their lexical context:

• In a method: Created when the method is called, destroyed when the method returns.
• In a block: Created when the block runs, destroyed when the block exits.

Example: Local variable in a method

def add(a, b)
  sum = a + b  # `sum` is created here
  sum  # `sum` is destroyed after the method returns
end

add(2, 3)  # Returns 5; `sum` no longer exists

Instance Variables (Persistence)

Instance variables persist for the lifetime of the object they belong to. They are created when first assigned (even if nil), and destroyed when the object is garbage-collected (i.e., when no references to the object remain).

Example: Instance variable persistence

class User
  def set_name(name)
    @name = name  # `@name` created when this method is called
  end

  def get_name
    @name  # `@name` persists as long as the `User` instance exists
  end
end

user = User.new
user.set_name("Alice")
puts user.get_name  # Output: "Alice"

# `@name` remains until `user` is garbage-collected (e.g., when `user = nil`)

Class Variables (Persistence)

Class variables persist for the entire lifetime of the class (and its subclasses). Since classes in Ruby are objects themselves (instances of Class), class variables exist from the moment the class is defined until the program exits (or the class is unloaded, which is rare in practice).

Example: Class variable persistence

class Counter
  @@count = 0  # Created when the class is defined

  def self.increment
    @@count += 1
  end

  def self.get_count
    @@count
  end
end

Counter.increment
Counter.increment
puts Counter.get_count  # Output: 2 (persists across method calls)

# `@@count` remains until the program exits

Global Variables (Persistence)

Global variables persist for the entire duration of the program. They are initialized when first assigned and exist until the Ruby process terminates.

Example: Global variable persistence

$start_time = Time.now  # Initialized at program start

def log_runtime
  runtime = Time.now - $start_time  # Persists until program ends
  puts "Runtime: #{runtime} seconds"
end

# ... hours later ...
log_runtime  # Still calculates correctly

Constants (Persistence)

Constants persist for the lifetime of their parent module/class. Like class variables, modules/classes are loaded once (at program start), so constants typically exist for the entire program duration.

Note: Unlike true constants in some languages (e.g., Java), Ruby constants can be reassigned (though Ruby warns you with warning: already initialized constant). Their persistence remains unchanged, but their value can be modified.

Variable Scope & Persistence: A Comparison Table

To summarize, here’s a quick reference for scope and persistence across all variable types:

Common Pitfalls & Best Practices

Pitfalls to Avoid

1. Overusing global variables: They introduce hidden dependencies and side effects (e.g., changing $app_mode in one part of the code breaks another part).
2. Class variable inheritance issues: Class variables are shared across parent and child classes. Modifying a class variable in a subclass affects the parent class too:

   class Parent
     @@value = 10
   end
   
   class Child < Parent
     @@value = 20  # Modifies Parent's @@value as well!
   end
   
   puts Parent.class_variable_get(:@@value)  # Output: 20 (unexpected!)

3. Shadowing variables in blocks: Accidentally redefining an outer variable inside a block can lead to bugs:

   total = 0
   [1, 2, 3].each do |total|  # `total` here shadows the outer `total`
     puts total
   end
   puts total  # Output: 0 (outer `total` was never modified!)

Best Practices

• Prefer local variables for temporary values with limited scope (e.g., loop counters, method parameters).
• Use instance variables to store object-specific state (e.g., @user_id, @email).
• Avoid class variables unless you explicitly need shared state across a class hierarchy (use class-level instance variables like @total_users in a class method instead).
• Never use global variables unless absolutely necessary (e.g., built-in globals like $stdout).
• Use constants for fixed values (e.g., API_BASE_URL) and avoid reassigning them.

Conclusion

Variables in Ruby are more than just placeholders for data—their scope and persistence dictate how they interact with the rest of your code. By mastering these concepts, you’ll write Ruby that is:

• Cleaner: Variables are only visible where they’re needed.
• More maintainable: State is managed predictably (no hidden side effects).
• Less error-prone: You’ll avoid bugs from undefined variables or accidental reassignments.

Remember: Choose the narrowest scope and shortest persistence possible for each variable. When in doubt, start with a local variable—expand to instance or class variables only when needed.

References

• Ruby Official Documentation: Variables
• Programming Ruby: The Pragmatic Programmer’s Guide (The “Pickaxe Book”)
• Ruby Variables, Constants, and Literals (TutorialsPoint)
• Understanding Ruby Closures (RubyGuides)