Ruby Tutorial: Scope

Ruby Scope

This section covers self and additional scoping concerns (e.g. globals, class variables, and private/protected).

Ref.: WGR Ch. 5, The default object (self), scope, and visibility

Who Am I?

  • All Ruby programs suffer from multiple personality disorder
  • self is the default message receiver

how self is determined

self in different contexts

main, the magic self

$ ruby -e 'puts self'

Methods defined inside main become private methods of Object

self in class and module definitions

@@@ ruby
class C
  puts self    # "C"
  module M
    puts self  # "C::M"
  puts self    # "C"

self during class methods definitions

  • This allows the fun trick def to define class methods
  • Easier to identify class methods, also easier to rename your class

self in method definitions

  • This is weird if you think about it too hard
  • When the interpreter hits a def, it defines the method immediately but doesn't execute it until later
  • When it's executed, self is pointing to the instance the method was called on

      @@@ ruby
      class C
        def x
          puts self

self in instance methods

@@@ ruby
class C
  def x
    puts "x"

  def y
    puts "y"
    self.x   # << same
    x        # << thing

The setter gotcha

  • Inside an object, you can't call that object's setter methods directly
  • Why not?
    • Because "age = 2" looks like a local variable assignment, which takes precedence
    • It eclipses the setter method!
    • Syntax ambiguity! Oh noes!
  • Solution: use "self.age = 2"

An Elegant Object, using implicit self

class Student
  attr_accessor :first_name, :middle_name, :last_name

  def initialize first_name, middle_name, last_name
    @first_name, @middle_name, @last_name = 
      first_name, middle_name, last_name

  def name        
    name = "" 
    name << first_name
    name << " #{middle_name}" if middle_name
    name << " #{last_name}"   # returns name

Digging into the name method

>>"alex", "day", "chaffee").name
=> "alex day chaffee"

>>"alex", "", "chaffee").name
=> "alex  chaffee"

>>"alex", nil, "chaffee").name
=> "alex chaffee"

Global and Class Variable Scope

Global Variables

  • start with $
  • available everywhere
  • Danger!

Built-in Global Variables

  • $: load path (also $LOAD_PATH)
  • $* command-line args (also ARGV)
  • $$ pid
  • $! the most recent shell error
  • for more, open English.rb in the Ruby source
    • $HOME/.rvm/src/ruby-1.9.2-*/lib/English.rb

Class Variables

  • start with @@
  • really "class and instance and descendants" variables
  • available inside class definitions and instance methods
  • used for counters, caches, etc.

Class Variable Problems

  • must be initialized before access (unlike instance vars)
  • very widely shared, so easily polluted
  • can be replaced with class instance variables
    • single-@ vars inside class methods

Method Scope (Public/Protected/Private)

private methods

  • declared with private keyword
  • only accessible to that specific instance
    • i.e. from inside an instance method of that class
    • i.e. when self is the receiving object

you can't even access your siblings' private parts

@@@ ruby
class Midas
  def initialize(initial_gold)
    @gold = initial_gold

  def gold

  def take_gold_from(other)
    @gold +=

  private :gold

>> m1 =
>> m2 =
>> m1.take_gold_from(m2)
NoMethodError: private method `gold' called

protected methods

  • available when self is an instance of that class or one of its descendants

      class Midas
        protected :gold
      => 30

scoping toggles

  • private, protected, and public without arguments turn scoping on or off
  • all upcoming methods assume that scope, until another scope is set, or the class definition ends
  • this is the normal way to mark methods' scope

weird top-level scope

(advanced topic)

  1. methods defined outside any class or module become private methods on Object and are available everywhere
  2. private methods defined inside the Kernel are also available everywhere

require, load, raise etc. are Kernel methods

ruby -e 'print Kernel.private_instance_methods(false)'