Protect your privates

Protect your privates

When you write little helper methods in your controllers, do you use protected or private? Do you know why?

Pop quiz: what will this sample print out?

class Parent
  def mr_public
    'public'
  end

  def access_other_protected(other)
    other.mr_protected
  end

  def access_other_private(other)
    other.mr_private
  end

  def access_self_protected
    self.mr_protected
  end

  def access_self_private
    self.mr_private
  end

  protected

  def mr_protected
    'protected'
  end

  private

  def mr_private
    'private'
  end
end

class Child < Parent
  def access_parent_protected
    mr_protected
  end

  def access_parent_private
    mr_private
  end
end

def attempt
  puts yield
rescue
  puts 'forbidden'
end

parent = Parent.new
other = Parent.new
child = Child.new

attempt { parent.mr_public  }
attempt { parent.mr_protected  }
attempt { parent.mr_private  }

attempt { parent.access_self_protected  }
attempt { parent.access_self_private  }

attempt { parent.access_other_protected(other)  }
attempt { parent.access_other_private(other)  }

attempt { child.access_parent_protected  }
attempt { child.access_parent_private  }

Answer:

public
forbidden
forbidden
protected
forbidden
protected
forbidden
protected
private

What the hell just happened

Some lesser-known rules:

  • A child class can invoke private methods defined on its parent
  • A class cannot invoke private methods on itself if you use self
  • A class cannot access private methods an another instance of its own class

Some guidelines:

  • Define almost everything as private instead of protected!
  • You essentially only need to use protected together with methods like ==, <, or >.
Joe Ferris Developer

Sharpen your programming skills by completing coding exercises that are reviewed by other developers at Upcase today.